diff options
Diffstat (limited to 'include/clang/Basic')
51 files changed, 2033 insertions, 788 deletions
diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index bfe8093..37aa332 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -29,8 +29,8 @@ class SubsetSubject<AttrSubject base, string description, code check> code CheckCode = check; } -// This is the type of a variable which C++0x defines [[aligned()]] as being -// a possible subject. +// This is the type of a variable which C++11 allows alignas(...) to appertain +// to. def NormalVar : SubsetSubject<Var, "non-register, non-parameter variable", [{S->getStorageClass() != VarDecl::Register && S->getKind() != Decl::ImplicitParam && @@ -91,6 +91,12 @@ class Declspec<string name> : Spelling<name, "Declspec">; class CXX11<string namespace, string name> : Spelling<name, "CXX11"> { string Namespace = namespace; } +class Keyword<string name> : Spelling<name, "Keyword">; + +class Accessor<string name, list<Spelling> spellings> { + string Name = name; + list<Spelling> Spellings = spellings; +} class Attr { // The various ways in which an attribute can be spelled in source @@ -99,8 +105,10 @@ class Attr { list<AttrSubject> Subjects; // The arguments allowed on an attribute list<Argument> Args = []; - // Set to true for attributes with arguments which require delayed parsing. - bit LateParsed = 0; + // Accessors which should be generated for the attribute. + list<Accessor> Accessors = []; + // Set to true for attributes with arguments which require delayed parsing. + bit LateParsed = 0; // Set to false to prevent an attribute from being propagated from a template // to the instantiation. bit Clone = 1; @@ -114,7 +122,7 @@ class Attr { bit Ignored = 0; // Set to true if each of the spellings is a distinct attribute. bit DistinctSpellings = 0; - // Any additional text that should be included verbatim in the class. + // Any additional text that should be included verbatim in the class. code AdditionalMembers = [{}]; } @@ -125,6 +133,13 @@ class InheritableAttr : Attr; /// redeclarations, even when it's written on a parameter. class InheritableParamAttr : InheritableAttr; +/// An ignored attribute, which we parse but discard with no checking. +class IgnoredAttr : Attr { + let Ignored = 1; + let ASTNode = 0; + let SemaHandler = 0; +} + // // Attributes begin here // @@ -132,18 +147,24 @@ class InheritableParamAttr : InheritableAttr; def AddressSpace : Attr { let Spellings = [GNU<"address_space">]; let Args = [IntArgument<"AddressSpace">]; - let ASTNode = 0; + let ASTNode = 0; } def Alias : InheritableAttr { - let Spellings = [GNU<"alias">]; + let Spellings = [GNU<"alias">, CXX11<"gnu", "alias">]; let Args = [StringArgument<"Aliasee">]; } def Aligned : InheritableAttr { - let Spellings = [GNU<"aligned">, GNU<"align">]; + let Spellings = [GNU<"aligned">, Declspec<"align">, CXX11<"gnu", "aligned">, + Keyword<"alignas">, Keyword<"_Alignas">]; let Subjects = [NonBitField, NormalVar, Tag]; - let Args = [AlignedArgument<"Alignment">, BoolArgument<"IsMSDeclSpec">]; + let Args = [AlignedArgument<"Alignment">]; + let Accessors = [Accessor<"isGNU", [GNU<"aligned">, CXX11<"gnu","aligned">]>, + Accessor<"isC11", [Keyword<"_Alignas">]>, + Accessor<"isAlignas", [Keyword<"alignas">, + Keyword<"_Alignas">]>, + Accessor<"isDeclspec",[Declspec<"align">]>]; } def AlignMac68k : InheritableAttr { @@ -152,16 +173,16 @@ def AlignMac68k : InheritableAttr { } def AllocSize : Attr { - let Spellings = [GNU<"alloc_size">]; + let Spellings = [GNU<"alloc_size">, CXX11<"gnu", "alloc_size">]; let Args = [VariadicUnsignedArgument<"Args">]; } def AlwaysInline : InheritableAttr { - let Spellings = [GNU<"always_inline">]; + let Spellings = [GNU<"always_inline">, CXX11<"gnu", "always_inline">]; } def TLSModel : InheritableAttr { - let Spellings = [GNU<"tls_model">]; + let Spellings = [GNU<"tls_model">, CXX11<"gnu", "tls_model">]; let Subjects = [Var]; let Args = [StringArgument<"Model">]; } @@ -200,11 +221,8 @@ def Blocks : InheritableAttr { let Args = [EnumArgument<"Type", "BlockType", ["byref"], ["ByRef"]>]; } -def Bounded : Attr { +def Bounded : IgnoredAttr { let Spellings = [GNU<"bounded">]; - let ASTNode = 0; - let SemaHandler = 0; - let Ignored = 1; } def CarriesDependency : InheritableParamAttr { @@ -214,7 +232,8 @@ def CarriesDependency : InheritableParamAttr { } def CDecl : InheritableAttr { - let Spellings = [GNU<"cdecl">, GNU<"__cdecl">]; + let Spellings = [GNU<"cdecl">, CXX11<"gnu", "cdecl">, Keyword<"__cdecl">, + Keyword<"_cdecl">]; } // cf_audited_transfer indicates that the given function has been @@ -234,11 +253,6 @@ def CFUnknownTransfer : InheritableAttr { let Subjects = [Function]; } -def CFReturnsAutoreleased : Attr { - let Spellings = [GNU<"cf_returns_autoreleased">]; - let ASTNode = 0; -} - def CFReturnsRetained : InheritableAttr { let Spellings = [GNU<"cf_returns_retained">]; let Subjects = [ObjCMethod, Function]; @@ -255,24 +269,24 @@ def CFConsumed : InheritableParamAttr { } def Cleanup : InheritableAttr { - let Spellings = [GNU<"cleanup">]; + let Spellings = [GNU<"cleanup">, CXX11<"gnu", "cleanup">]; let Args = [FunctionArgument<"FunctionDecl">]; } def Cold : InheritableAttr { - let Spellings = [GNU<"cold">]; + let Spellings = [GNU<"cold">, CXX11<"gnu", "cold">]; } def Common : InheritableAttr { - let Spellings = [GNU<"common">]; + let Spellings = [GNU<"common">, CXX11<"gnu", "common">]; } def Const : InheritableAttr { - let Spellings = [GNU<"const">, GNU<"__const">]; + let Spellings = [GNU<"const">, GNU<"__const">, CXX11<"gnu", "const">]; } def Constructor : InheritableAttr { - let Spellings = [GNU<"constructor">]; + let Spellings = [GNU<"constructor">, CXX11<"gnu", "constructor">]; let Args = [IntArgument<"Priority">]; } @@ -301,23 +315,33 @@ def CUDAShared : InheritableAttr { let Spellings = [GNU<"shared">]; } +def C11NoReturn : InheritableAttr { + let Spellings = [Keyword<"_Noreturn">]; + let Subjects = [Function]; + let SemaHandler = 0; +} + +def CXX11NoReturn : InheritableAttr { + let Spellings = [CXX11<"","noreturn">, CXX11<"std","noreturn">]; + let Subjects = [Function]; +} + def OpenCLKernel : Attr { - let Spellings = [GNU<"opencl_kernel_function">]; + let Spellings = [Keyword<"__kernel">, Keyword<"kernel">]; } def OpenCLImageAccess : Attr { let Spellings = [GNU<"opencl_image_access">]; let Args = [IntArgument<"Access">]; - let ASTNode = 0; } def Deprecated : InheritableAttr { - let Spellings = [GNU<"deprecated">]; + let Spellings = [GNU<"deprecated">, CXX11<"gnu", "deprecated">]; let Args = [StringArgument<"Message">]; } def Destructor : InheritableAttr { - let Spellings = [GNU<"destructor">]; + let Spellings = [GNU<"destructor">, CXX11<"gnu", "destructor">]; let Args = [IntArgument<"Priority">]; } @@ -328,12 +352,13 @@ def ExtVectorType : Attr { } def FallThrough : Attr { - let Spellings = [CXX11<"clang","fallthrough">]; + let Spellings = [CXX11<"clang", "fallthrough">]; let Subjects = [NullStmt]; } def FastCall : InheritableAttr { - let Spellings = [GNU<"fastcall">, GNU<"__fastcall">]; + let Spellings = [GNU<"fastcall">, CXX11<"gnu", "fastcall">, + Keyword<"__fastcall">, Keyword<"_fastcall">]; } def Final : InheritableAttr { @@ -347,22 +372,22 @@ def MinSize : InheritableAttr { } def Format : InheritableAttr { - let Spellings = [GNU<"format">]; + let Spellings = [GNU<"format">, CXX11<"gnu", "format">]; let Args = [StringArgument<"Type">, IntArgument<"FormatIdx">, IntArgument<"FirstArg">]; } def FormatArg : InheritableAttr { - let Spellings = [GNU<"format_arg">]; + let Spellings = [GNU<"format_arg">, CXX11<"gnu", "format_arg">]; let Args = [IntArgument<"FormatIdx">]; } def GNUInline : InheritableAttr { - let Spellings = [GNU<"gnu_inline">]; + let Spellings = [GNU<"gnu_inline">, CXX11<"gnu", "gnu_inline">]; } def Hot : InheritableAttr { - let Spellings = [GNU<"hot">]; + let Spellings = [GNU<"hot">, CXX11<"gnu", "hot">]; } def IBAction : InheritableAttr { @@ -379,7 +404,7 @@ def IBOutletCollection : InheritableAttr { } def Malloc : InheritableAttr { - let Spellings = [GNU<"malloc">]; + let Spellings = [GNU<"malloc">, CXX11<"gnu", "malloc">]; } def MaxFieldAlignment : InheritableAttr { @@ -389,7 +414,7 @@ def MaxFieldAlignment : InheritableAttr { } def MayAlias : InheritableAttr { - let Spellings = [GNU<"may_alias">]; + let Spellings = [GNU<"may_alias">, CXX11<"gnu", "may_alias">]; } def MSP430Interrupt : InheritableAttr { @@ -408,14 +433,19 @@ def MBlazeSaveVolatiles : InheritableAttr { let SemaHandler = 0; } +def Mips16 : InheritableAttr { + let Spellings = [GNU<"mips16">, CXX11<"gnu", "mips16">]; + let Subjects = [Function]; +} + def Mode : Attr { - let Spellings = [GNU<"mode">]; + let Spellings = [GNU<"mode">, CXX11<"gnu", "mode">]; let Args = [IdentifierArgument<"Mode">]; let ASTNode = 0; } def Naked : InheritableAttr { - let Spellings = [GNU<"naked">]; + let Spellings = [GNU<"naked">, CXX11<"gnu", "naked">]; } def NeonPolyVectorType : Attr { @@ -431,11 +461,11 @@ def NeonVectorType : Attr { } def ReturnsTwice : InheritableAttr { - let Spellings = [GNU<"returns_twice">]; + let Spellings = [GNU<"returns_twice">, CXX11<"gnu", "returns_twice">]; } def NoCommon : InheritableAttr { - let Spellings = [GNU<"nocommon">]; + let Spellings = [GNU<"nocommon">, CXX11<"gnu", "nocommon">]; } def NoDebug : InheritableAttr { @@ -443,11 +473,16 @@ def NoDebug : InheritableAttr { } def NoInline : InheritableAttr { - let Spellings = [GNU<"noinline">]; + let Spellings = [GNU<"noinline">, CXX11<"gnu", "noinline">]; +} + +def NoMips16 : InheritableAttr { + let Spellings = [GNU<"nomips16">, CXX11<"gnu", "nomips16">]; + let Subjects = [Function]; } def NonNull : InheritableAttr { - let Spellings = [GNU<"nonnull">]; + let Spellings = [GNU<"nonnull">, CXX11<"gnu", "nonnull">]; let Args = [VariadicUnsignedArgument<"Args">]; let AdditionalMembers = [{bool isNonNull(unsigned idx) const { @@ -460,19 +495,19 @@ def NonNull : InheritableAttr { } def NoReturn : InheritableAttr { - let Spellings = [GNU<"noreturn">, CXX11<"","noreturn">, - CXX11<"std","noreturn">]; + let Spellings = [GNU<"noreturn">, CXX11<"gnu", "noreturn">]; // FIXME: Does GCC allow this on the function instead? let Subjects = [Function]; } def NoInstrumentFunction : InheritableAttr { - let Spellings = [GNU<"no_instrument_function">]; + let Spellings = [GNU<"no_instrument_function">, + CXX11<"gnu", "no_instrument_function">]; let Subjects = [Function]; } def NoThrow : InheritableAttr { - let Spellings = [GNU<"nothrow">]; + let Spellings = [GNU<"nothrow">, CXX11<"gnu", "nothrow">]; } def NSBridged : InheritableAttr { @@ -563,26 +598,30 @@ def Ownership : InheritableAttr { } def Packed : InheritableAttr { - let Spellings = [GNU<"packed">]; + let Spellings = [GNU<"packed">, CXX11<"gnu", "packed">]; } def PnaclCall : InheritableAttr { let Spellings = [GNU<"pnaclcall">]; } +def IntelOclBicc : InheritableAttr { + let Spellings = [GNU<"intel_ocl_bicc">]; +} + def Pcs : InheritableAttr { - let Spellings = [GNU<"pcs">]; + let Spellings = [GNU<"pcs">, CXX11<"gnu", "pcs">]; let Args = [EnumArgument<"PCS", "PCSType", ["aapcs", "aapcs-vfp"], ["AAPCS", "AAPCS_VFP"]>]; } def Pure : InheritableAttr { - let Spellings = [GNU<"pure">]; + let Spellings = [GNU<"pure">, CXX11<"gnu", "pure">]; } def Regparm : InheritableAttr { - let Spellings = [GNU<"regparm">]; + let Spellings = [GNU<"regparm">, CXX11<"gnu", "regparm">]; let Args = [UnsignedArgument<"NumParams">]; } @@ -592,6 +631,11 @@ def ReqdWorkGroupSize : InheritableAttr { UnsignedArgument<"ZDim">]; } +def Endian : InheritableAttr { + let Spellings = [GNU<"endian">]; + let Args = [IdentifierArgument<"platform">]; +} + def WorkGroupSizeHint : InheritableAttr { let Spellings = [GNU<"work_group_size_hint">]; let Args = [UnsignedArgument<"XDim">, @@ -605,30 +649,32 @@ def InitPriority : InheritableAttr { } def Section : InheritableAttr { - let Spellings = [GNU<"section">]; + let Spellings = [GNU<"section">, CXX11<"gnu", "section">]; let Args = [StringArgument<"Name">]; } def Sentinel : InheritableAttr { - let Spellings = [GNU<"sentinel">]; + let Spellings = [GNU<"sentinel">, CXX11<"gnu", "sentinel">]; let Args = [DefaultIntArgument<"Sentinel", 0>, DefaultIntArgument<"NullPos", 0>]; } def StdCall : InheritableAttr { - let Spellings = [GNU<"stdcall">, GNU<"__stdcall">]; + let Spellings = [GNU<"stdcall">, CXX11<"gnu", "stdcall">, + Keyword<"__stdcall">, Keyword<"_stdcall">]; } def ThisCall : InheritableAttr { - let Spellings = [GNU<"thiscall">, GNU<"__thiscall">]; + let Spellings = [GNU<"thiscall">, CXX11<"gnu", "thiscall">, + Keyword<"__thiscall">, Keyword<"_thiscall">]; } def Pascal : InheritableAttr { - let Spellings = [GNU<"pascal">]; + let Spellings = [GNU<"pascal">, Keyword<"__pascal">, Keyword<"_pascal">]; } def TransparentUnion : InheritableAttr { - let Spellings = [GNU<"transparent_union">]; + let Spellings = [GNU<"transparent_union">, CXX11<"gnu", "transparent_union">]; } def Unavailable : InheritableAttr { @@ -659,11 +705,11 @@ def ObjCRequiresPropertyDefs : InheritableAttr { } def Unused : InheritableAttr { - let Spellings = [GNU<"unused">]; + let Spellings = [GNU<"unused">, CXX11<"gnu", "unused">]; } def Used : InheritableAttr { - let Spellings = [GNU<"used">]; + let Spellings = [GNU<"used">, CXX11<"gnu", "used">]; } def Uuid : InheritableAttr { @@ -673,21 +719,27 @@ def Uuid : InheritableAttr { } def VectorSize : Attr { - let Spellings = [GNU<"vector_size">]; + let Spellings = [GNU<"vector_size">, CXX11<"gnu", "vector_size">]; let Args = [ExprArgument<"NumBytes">]; let ASTNode = 0; } -def VecTypeHint : Attr { +def VecTypeHint : InheritableAttr { let Spellings = [GNU<"vec_type_hint">]; - let ASTNode = 0; - let SemaHandler = 0; - let Ignored = 1; + let Args = [TypeArgument<"TypeHint">, SourceLocArgument<"TypeLoc">]; } def Visibility : InheritableAttr { let Clone = 0; - let Spellings = [GNU<"visibility">]; + let Spellings = [GNU<"visibility">, CXX11<"gnu", "visibility">]; + let Args = [EnumArgument<"Visibility", "VisibilityType", + ["default", "hidden", "internal", "protected"], + ["Default", "Hidden", "Hidden", "Protected"]>]; +} + +def TypeVisibility : InheritableAttr { + let Clone = 0; + let Spellings = [GNU<"type_visibility">, CXX11<"clang", "type_visibility">]; let Args = [EnumArgument<"Visibility", "VisibilityType", ["default", "hidden", "internal", "protected"], ["Default", "Hidden", "Hidden", "Protected"]>]; @@ -699,11 +751,13 @@ def VecReturn : InheritableAttr { } def WarnUnusedResult : InheritableAttr { - let Spellings = [GNU<"warn_unused_result">]; + let Spellings = [GNU<"warn_unused_result">, + CXX11<"clang", "warn_unused_result">, + CXX11<"gnu", "warn_unused_result">]; } def Weak : InheritableAttr { - let Spellings = [GNU<"weak">]; + let Spellings = [GNU<"weak">, CXX11<"gnu", "weak">]; } def WeakImport : InheritableAttr { @@ -711,16 +765,27 @@ def WeakImport : InheritableAttr { } def WeakRef : InheritableAttr { - let Spellings = [GNU<"weakref">]; + let Spellings = [GNU<"weakref">, CXX11<"gnu", "weakref">]; } def X86ForceAlignArgPointer : InheritableAttr { let Spellings = []; } -// AddressSafety attribute (e.g. for AddressSanitizer) -def NoAddressSafetyAnalysis : InheritableAttr { - let Spellings = [GNU<"no_address_safety_analysis">]; +// Attribute to disable AddressSanitizer (or equivalent) checks. +def NoSanitizeAddress : InheritableAttr { + let Spellings = [GNU<"no_address_safety_analysis">, + GNU<"no_sanitize_address">]; +} + +// Attribute to disable ThreadSanitizer checks. +def NoSanitizeThread : InheritableAttr { + let Spellings = [GNU<"no_sanitize_thread">]; +} + +// Attribute to disable MemorySanitizer checks. +def NoSanitizeMemory : InheritableAttr { + let Spellings = [GNU<"no_sanitize_memory">]; } // C/C++ Thread safety attributes (e.g. for deadlock, data race checking) @@ -876,29 +941,41 @@ def DLLImport : InheritableAttr { } def ForceInline : InheritableAttr { - let Spellings = [Declspec<"__forceinline">]; + let Spellings = [Keyword<"__forceinline">]; } def Win64 : InheritableAttr { - let Spellings = [Declspec<"w64">]; + let Spellings = [Keyword<"__w64">]; } def Ptr32 : InheritableAttr { - let Spellings = [Declspec<"__ptr32">]; + let Spellings = [Keyword<"__ptr32">]; } def Ptr64 : InheritableAttr { - let Spellings = [Declspec<"__ptr64">]; + let Spellings = [Keyword<"__ptr64">]; } -def SingleInheritance : InheritableAttr { - let Spellings = [Declspec<"__single_inheritance">]; +class MSInheritanceAttr : InheritableAttr; + +def SingleInheritance : MSInheritanceAttr { + let Spellings = [Keyword<"__single_inheritance">]; +} + +def MultipleInheritance : MSInheritanceAttr { + let Spellings = [Keyword<"__multiple_inheritance">]; } -def MultipleInheritance : InheritableAttr { - let Spellings = [Declspec<"__multiple_inheritance">]; +def VirtualInheritance : MSInheritanceAttr { + let Spellings = [Keyword<"__virtual_inheritance">]; +} + +// This attribute doesn't have any spellings, but we can apply it implicitly to +// incomplete types that lack any of the other attributes. +def UnspecifiedInheritance : MSInheritanceAttr { + let Spellings = []; } -def VirtualInheritance : InheritableAttr { - let Spellings = [Declspec<"__virtual_inheritance">]; +def Unaligned : IgnoredAttr { + let Spellings = [Keyword<"__unaligned">]; } diff --git a/include/clang/Basic/AttrKinds.h b/include/clang/Basic/AttrKinds.h index 150a30e..bd090ec 100644 --- a/include/clang/Basic/AttrKinds.h +++ b/include/clang/Basic/AttrKinds.h @@ -24,6 +24,7 @@ enum Kind { #define ATTR(X) X, #define LAST_INHERITABLE_ATTR(X) X, LAST_INHERITABLE = X, #define LAST_INHERITABLE_PARAM_ATTR(X) X, LAST_INHERITABLE_PARAM = X, +#define LAST_MS_INHERITABLE_ATTR(X) X, LAST_MS_INHERITABLE = X, #include "clang/Basic/AttrList.inc" NUM_ATTRS }; diff --git a/include/clang/Basic/Builtins.def b/include/clang/Basic/Builtins.def index d48eadc..0a513ef 100644 --- a/include/clang/Basic/Builtins.def +++ b/include/clang/Basic/Builtins.def @@ -31,6 +31,7 @@ // F -> constant CFString // G -> id // H -> SEL +// M -> struct objc_super // a -> __builtin_va_list // A -> "reference" to __builtin_va_list // V -> Vector, followed by the number of elements and the base type. @@ -81,6 +82,7 @@ // through an ellipsis // e -> const, but only when -fmath-errno=0 // j -> returns_twice (like setjmp) +// u -> arguments are not evaluated for their side-effects // FIXME: gcc has nonnull #if defined(BUILTIN) && !defined(LIBBUILTIN) @@ -394,8 +396,8 @@ BUILTIN(__builtin_bswap32, "UiUi", "nc") BUILTIN(__builtin_bswap64, "ULLiULLi", "nc") // Random GCC builtins -BUILTIN(__builtin_constant_p, "i.", "nct") -BUILTIN(__builtin_classify_type, "i.", "nct") +BUILTIN(__builtin_constant_p, "i.", "nctu") +BUILTIN(__builtin_classify_type, "i.", "nctu") BUILTIN(__builtin___CFStringMakeConstantString, "FC*cC*", "nc") BUILTIN(__builtin___NSStringMakeConstantString, "FC*cC*", "nc") BUILTIN(__builtin_va_start, "vA.", "nt") @@ -453,17 +455,17 @@ BUILTIN(__builtin_dwarf_sp_column, "Ui", "n") BUILTIN(__builtin_extend_pointer, "ULLiv*", "n") // _Unwind_Word == uint64_t // GCC Object size checking builtins -BUILTIN(__builtin_object_size, "zvC*i", "n") +BUILTIN(__builtin_object_size, "zvC*i", "nu") BUILTIN(__builtin___memcpy_chk, "v*v*vC*zz", "nF") -BUILTIN(__builtin___memccpy_chk, "v*v*vC*iz", "nF") +BUILTIN(__builtin___memccpy_chk, "v*v*vC*izz", "nF") BUILTIN(__builtin___memmove_chk, "v*v*vC*zz", "nF") BUILTIN(__builtin___mempcpy_chk, "v*v*vC*zz", "nF") BUILTIN(__builtin___memset_chk, "v*v*izz", "nF") BUILTIN(__builtin___stpcpy_chk, "c*c*cC*z", "nF") BUILTIN(__builtin___strcat_chk, "c*c*cC*z", "nF") BUILTIN(__builtin___strcpy_chk, "c*c*cC*z", "nF") -BUILTIN(__builtin___strlcat_chk, "c*c*cC*zz", "nF") -BUILTIN(__builtin___strlcpy_chk, "c*c*cC*zz", "nF") +BUILTIN(__builtin___strlcat_chk, "zc*cC*zz", "nF") +BUILTIN(__builtin___strlcpy_chk, "zc*cC*zz", "nF") BUILTIN(__builtin___strncat_chk, "c*c*cC*zz", "nF") BUILTIN(__builtin___strncpy_chk, "c*c*cC*zz", "nF") BUILTIN(__builtin___stpncpy_chk, "c*c*cC*zz", "nF") @@ -760,17 +762,16 @@ LIBBUILTIN(strlcpy, "zc*cC*z", "f", "string.h", ALL_LANGUAGES) LIBBUILTIN(strlcat, "zc*cC*z", "f", "string.h", ALL_LANGUAGES) // id objc_msgSend(id, SEL, ...) LIBBUILTIN(objc_msgSend, "GGH.", "f", "objc/message.h", OBJC_LANG) - // long double objc_msgSend_fpret(id self, SEL op, ...) LIBBUILTIN(objc_msgSend_fpret, "LdGH.", "f", "objc/message.h", OBJC_LANG) // _Complex long double objc_msgSend_fp2ret(id self, SEL op, ...) LIBBUILTIN(objc_msgSend_fp2ret, "XLdGH.", "f", "objc/message.h", OBJC_LANG) -// id objc_msgSend_stret (id, SEL, ...) -LIBBUILTIN(objc_msgSend_stret, "GGH.", "f", "objc/message.h", OBJC_LANG) +// void objc_msgSend_stret (id, SEL, ...) +LIBBUILTIN(objc_msgSend_stret, "vGH.", "f", "objc/message.h", OBJC_LANG) // id objc_msgSendSuper(struct objc_super *super, SEL op, ...) -LIBBUILTIN(objc_msgSendSuper, "Gv*H.", "f", "objc/message.h", OBJC_LANG) +LIBBUILTIN(objc_msgSendSuper, "GM*H.", "f", "objc/message.h", OBJC_LANG) // void objc_msgSendSuper_stret(struct objc_super *super, SEL op, ...) -LIBBUILTIN(objc_msgSendSuper_stret, "vv*H.", "f", "objc/message.h", OBJC_LANG) +LIBBUILTIN(objc_msgSendSuper_stret, "vM*H.", "f", "objc/message.h", OBJC_LANG) // id objc_getClass(const char *name) LIBBUILTIN(objc_getClass, "GcC*", "f", "objc/runtime.h", OBJC_LANG) // id objc_getMetaClass(const char *name) @@ -833,6 +834,14 @@ LIBBUILTIN(ceil, "dd", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(ceill, "LdLd", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(ceilf, "ff", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(cimag, "dXd", "fnc", "complex.h", ALL_LANGUAGES) +LIBBUILTIN(cimagf, "fXf", "fnc", "complex.h", ALL_LANGUAGES) +LIBBUILTIN(cimagl, "LdXLd", "fnc", "complex.h", ALL_LANGUAGES) + +LIBBUILTIN(creal, "dXd", "fnc", "complex.h", ALL_LANGUAGES) +LIBBUILTIN(crealf, "fXf", "fnc", "complex.h", ALL_LANGUAGES) +LIBBUILTIN(creall, "LdXLd", "fnc", "complex.h", ALL_LANGUAGES) + LIBBUILTIN(copysign, "ddd", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(copysignl, "LdLdLd", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(copysignf, "fff", "fc", "math.h", ALL_LANGUAGES) @@ -917,5 +926,15 @@ LIBBUILTIN(_Block_object_dispose, "vvC*iC", "f", "Blocks.h", ALL_LANGUAGES) // Annotation function BUILTIN(__builtin_annotation, "v.", "tn") +// Multiprecision Arithmetic Builtins. +BUILTIN(__builtin_addcs, "UsUsCUsCUsCUs*", "n") +BUILTIN(__builtin_addc, "UiUiCUiCUiCUi*", "n") +BUILTIN(__builtin_addcl, "ULiULiCULiCULiCULi*", "n") +BUILTIN(__builtin_addcll, "ULLiULLiCULLiCULLiCULLi*", "n") +BUILTIN(__builtin_subcs, "UsUsCUsCUsCUs*", "n") +BUILTIN(__builtin_subc, "UiUiCUiCUiCUi*", "n") +BUILTIN(__builtin_subcl, "ULiULiCULiCULiCULi*", "n") +BUILTIN(__builtin_subcll, "ULLiULLiCULLiCULLiCULLi*", "n") + #undef BUILTIN #undef LIBBUILTIN diff --git a/include/clang/Basic/Builtins.h b/include/clang/Basic/Builtins.h index 257daf1..3b88e15 100644 --- a/include/clang/Basic/Builtins.h +++ b/include/clang/Basic/Builtins.h @@ -109,6 +109,12 @@ public: return strchr(GetRecord(ID).Attributes, 'j') != 0; } + /// \brief Returns true if this builtin does not perform the side-effects + /// of its arguments. + bool isUnevaluated(unsigned ID) const { + return strchr(GetRecord(ID).Attributes, 'u') != 0; + } + /// \brief Return true if this is a builtin for a libc/libm function, /// with a "__builtin_" prefix (e.g. __builtin_abs). bool isLibFunction(unsigned ID) const { diff --git a/include/clang/Basic/BuiltinsX86.def b/include/clang/Basic/BuiltinsX86.def index 5b46f8e..d536821 100644 --- a/include/clang/Basic/BuiltinsX86.def +++ b/include/clang/Basic/BuiltinsX86.def @@ -624,6 +624,11 @@ BUILTIN(__builtin_ia32_rdrand16_step, "UiUs*", "") BUILTIN(__builtin_ia32_rdrand32_step, "UiUi*", "") BUILTIN(__builtin_ia32_rdrand64_step, "UiULLi*", "") +// RDSEED +BUILTIN(__builtin_ia32_rdseed16_step, "UiUs*", "") +BUILTIN(__builtin_ia32_rdseed32_step, "UiUi*", "") +BUILTIN(__builtin_ia32_rdseed64_step, "UiULLi*", "") + // BMI BUILTIN(__builtin_ia32_bextr_u32, "UiUiUi", "") BUILTIN(__builtin_ia32_bextr_u64, "ULLiULLiULLi", "") @@ -739,5 +744,6 @@ BUILTIN(__builtin_ia32_vfrczpd256, "V4dV4d", "") BUILTIN(__builtin_ia32_xbegin, "i", "") BUILTIN(__builtin_ia32_xend, "v", "") BUILTIN(__builtin_ia32_xabort, "vIc", "") +BUILTIN(__builtin_ia32_xtest, "i", "") #undef BUILTIN diff --git a/include/clang/Basic/CharInfo.h b/include/clang/Basic/CharInfo.h new file mode 100644 index 0000000..d0afda4 --- /dev/null +++ b/include/clang/Basic/CharInfo.h @@ -0,0 +1,198 @@ +//===--- clang/Basic/CharInfo.h - Classifying ASCII Characters ------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef CLANG_BASIC_CHARINFO_H +#define CLANG_BASIC_CHARINFO_H + +#include "clang/Basic/LLVM.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/DataTypes.h" + +namespace clang { +namespace charinfo { + extern const uint16_t InfoTable[256]; + + enum { + CHAR_HORZ_WS = 0x0001, // '\t', '\f', '\v'. Note, no '\0' + CHAR_VERT_WS = 0x0002, // '\r', '\n' + CHAR_SPACE = 0x0004, // ' ' + CHAR_DIGIT = 0x0008, // 0-9 + CHAR_XLETTER = 0x0010, // a-f,A-F + CHAR_UPPER = 0x0020, // A-Z + CHAR_LOWER = 0x0040, // a-z + CHAR_UNDER = 0x0080, // _ + CHAR_PERIOD = 0x0100, // . + CHAR_RAWDEL = 0x0200, // {}[]#<>%:;?*+-/^&|~!=,"' + CHAR_PUNCT = 0x0400 // `$@() + }; + + enum { + CHAR_XUPPER = CHAR_XLETTER | CHAR_UPPER, + CHAR_XLOWER = CHAR_XLETTER | CHAR_LOWER + }; +} // end namespace charinfo + +/// Returns true if this is an ASCII character. +LLVM_READNONE static inline bool isASCII(char c) { + return static_cast<unsigned char>(c) <= 127; +} + +/// Returns true if this is a valid first character of a C identifier, +/// which is [a-zA-Z_]. +LLVM_READONLY static inline bool isIdentifierHead(unsigned char c, + bool AllowDollar = false) { + using namespace charinfo; + if (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_UNDER)) + return true; + return AllowDollar && c == '$'; +} + +/// Returns true if this is a body character of a C identifier, +/// which is [a-zA-Z0-9_]. +LLVM_READONLY static inline bool isIdentifierBody(unsigned char c, + bool AllowDollar = false) { + using namespace charinfo; + if (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_DIGIT|CHAR_UNDER)) + return true; + return AllowDollar && c == '$'; +} + +/// Returns true if this character is horizontal ASCII whitespace: +/// ' ', '\\t', '\\f', '\\v'. +/// +/// Note that this returns false for '\\0'. +LLVM_READONLY static inline bool isHorizontalWhitespace(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_HORZ_WS|CHAR_SPACE)) != 0; +} + +/// Returns true if this character is vertical ASCII whitespace: '\\n', '\\r'. +/// +/// Note that this returns false for '\\0'. +LLVM_READONLY static inline bool isVerticalWhitespace(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & CHAR_VERT_WS) != 0; +} + +/// Return true if this character is horizontal or vertical ASCII whitespace: +/// ' ', '\\t', '\\f', '\\v', '\\n', '\\r'. +/// +/// Note that this returns false for '\\0'. +LLVM_READONLY static inline bool isWhitespace(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_HORZ_WS|CHAR_VERT_WS|CHAR_SPACE)) != 0; +} + +/// Return true if this character is an ASCII digit: [0-9] +LLVM_READONLY static inline bool isDigit(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & CHAR_DIGIT) != 0; +} + +/// Return true if this character is a lowercase ASCII letter: [a-z] +LLVM_READONLY static inline bool isLowercase(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & CHAR_LOWER) != 0; +} + +/// Return true if this character is an uppercase ASCII letter: [A-Z] +LLVM_READONLY static inline bool isUppercase(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & CHAR_UPPER) != 0; +} + +/// Return true if this character is an ASCII letter: [a-zA-Z] +LLVM_READONLY static inline bool isLetter(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER)) != 0; +} + +/// Return true if this character is an ASCII letter or digit: [a-zA-Z0-9] +LLVM_READONLY static inline bool isAlphanumeric(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_DIGIT|CHAR_UPPER|CHAR_LOWER)) != 0; +} + +/// Return true if this character is an ASCII hex digit: [0-9a-fA-F] +LLVM_READONLY static inline bool isHexDigit(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_DIGIT|CHAR_XLETTER)) != 0; +} + +/// Return true if this character is an ASCII punctuation character. +/// +/// Note that '_' is both a punctuation character and an identifier character! +LLVM_READONLY static inline bool isPunctuation(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_UNDER|CHAR_PERIOD|CHAR_RAWDEL|CHAR_PUNCT)) != 0; +} + +/// Return true if this character is an ASCII printable character; that is, a +/// character that should take exactly one column to print in a fixed-width +/// terminal. +LLVM_READONLY static inline bool isPrintable(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_PERIOD|CHAR_PUNCT| + CHAR_DIGIT|CHAR_UNDER|CHAR_RAWDEL|CHAR_SPACE)) != 0; +} + +/// Return true if this is the body character of a C preprocessing number, +/// which is [a-zA-Z0-9_.]. +LLVM_READONLY static inline bool isPreprocessingNumberBody(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & + (CHAR_UPPER|CHAR_LOWER|CHAR_DIGIT|CHAR_UNDER|CHAR_PERIOD)) != 0; +} + +/// Return true if this is the body character of a C++ raw string delimiter. +LLVM_READONLY static inline bool isRawStringDelimBody(unsigned char c) { + using namespace charinfo; + return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_PERIOD| + CHAR_DIGIT|CHAR_UNDER|CHAR_RAWDEL)) != 0; +} + + +/// Converts the given ASCII character to its lowercase equivalent. +/// +/// If the character is not an uppercase character, it is returned as is. +LLVM_READONLY static inline char toLowercase(char c) { + if (isUppercase(c)) + return c + 'a' - 'A'; + return c; +} + +/// Converts the given ASCII character to its uppercase equivalent. +/// +/// If the character is not a lowercase character, it is returned as is. +LLVM_READONLY static inline char toUppercase(char c) { + if (isLowercase(c)) + return c + 'A' - 'a'; + return c; +} + + +/// Return true if this is a valid ASCII identifier. +/// +/// Note that this is a very simple check; it does not accept '$' or UCNs as +/// valid identifier characters. +LLVM_READONLY static inline bool isValidIdentifier(StringRef S) { + if (S.empty() || !isIdentifierHead(S[0])) + return false; + + for (StringRef::iterator I = S.begin(), E = S.end(); I != E; ++I) + if (!isIdentifierBody(*I)) + return false; + + return true; +} + +} // end namespace clang + +#endif diff --git a/include/clang/Basic/CommentOptions.h b/include/clang/Basic/CommentOptions.h new file mode 100644 index 0000000..79b9a6b --- /dev/null +++ b/include/clang/Basic/CommentOptions.h @@ -0,0 +1,34 @@ +//===--- CommentOptions.h - Options for parsing comments -----*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief Defines the clang::CommentOptions interface. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_COMMENTOPTIONS_H +#define LLVM_CLANG_COMMENTOPTIONS_H + +#include <string> +#include <vector> + +namespace clang { + +/// \brief Options for controlling comment parsing. +struct CommentOptions { + typedef std::vector<std::string> BlockCommandNamesTy; + + /// \brief Command names to treat as block commands in comments. + /// Should not include the leading backslash. + BlockCommandNamesTy BlockCommandNames; +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Basic/ConvertUTF.h b/include/clang/Basic/ConvertUTF.h deleted file mode 100644 index cdc4269..0000000 --- a/include/clang/Basic/ConvertUTF.h +++ /dev/null @@ -1,203 +0,0 @@ -/*===--- ConvertUTF.h - Universal Character Names conversions ---------------=== - * - * The LLVM Compiler Infrastructure - * - * This file is distributed under the University of Illinois Open Source - * License. See LICENSE.TXT for details. - * - *==------------------------------------------------------------------------==*/ -/* - * Copyright 2001-2004 Unicode, Inc. - * - * Disclaimer - * - * This source code is provided as is by Unicode, Inc. No claims are - * made as to fitness for any particular purpose. No warranties of any - * kind are expressed or implied. The recipient agrees to determine - * applicability of information provided. If this file has been - * purchased on magnetic or optical media from Unicode, Inc., the - * sole remedy for any claim will be exchange of defective media - * within 90 days of receipt. - * - * Limitations on Rights to Redistribute This Code - * - * Unicode, Inc. hereby grants the right to freely use the information - * supplied in this file in the creation of products supporting the - * Unicode Standard, and to make copies of this file in any form - * for internal or external distribution as long as this notice - * remains attached. - */ - -/* --------------------------------------------------------------------- - - Conversions between UTF32, UTF-16, and UTF-8. Header file. - - Several funtions are included here, forming a complete set of - conversions between the three formats. UTF-7 is not included - here, but is handled in a separate source file. - - Each of these routines takes pointers to input buffers and output - buffers. The input buffers are const. - - Each routine converts the text between *sourceStart and sourceEnd, - putting the result into the buffer between *targetStart and - targetEnd. Note: the end pointers are *after* the last item: e.g. - *(sourceEnd - 1) is the last item. - - The return result indicates whether the conversion was successful, - and if not, whether the problem was in the source or target buffers. - (Only the first encountered problem is indicated.) - - After the conversion, *sourceStart and *targetStart are both - updated to point to the end of last text successfully converted in - the respective buffers. - - Input parameters: - sourceStart - pointer to a pointer to the source buffer. - The contents of this are modified on return so that - it points at the next thing to be converted. - targetStart - similarly, pointer to pointer to the target buffer. - sourceEnd, targetEnd - respectively pointers to the ends of the - two buffers, for overflow checking only. - - These conversion functions take a ConversionFlags argument. When this - flag is set to strict, both irregular sequences and isolated surrogates - will cause an error. When the flag is set to lenient, both irregular - sequences and isolated surrogates are converted. - - Whether the flag is strict or lenient, all illegal sequences will cause - an error return. This includes sequences such as: <F4 90 80 80>, <C0 80>, - or <A0> in UTF-8, and values above 0x10FFFF in UTF-32. Conformant code - must check for illegal sequences. - - When the flag is set to lenient, characters over 0x10FFFF are converted - to the replacement character; otherwise (when the flag is set to strict) - they constitute an error. - - Output parameters: - The value "sourceIllegal" is returned from some routines if the input - sequence is malformed. When "sourceIllegal" is returned, the source - value will point to the illegal value that caused the problem. E.g., - in UTF-8 when a sequence is malformed, it points to the start of the - malformed sequence. - - Author: Mark E. Davis, 1994. - Rev History: Rick McGowan, fixes & updates May 2001. - Fixes & updates, Sept 2001. - ------------------------------------------------------------------------- */ - -#ifndef CLANG_BASIC_CONVERTUTF_H -#define CLANG_BASIC_CONVERTUTF_H - -/* --------------------------------------------------------------------- - The following 4 definitions are compiler-specific. - The C standard does not guarantee that wchar_t has at least - 16 bits, so wchar_t is no less portable than unsigned short! - All should be unsigned values to avoid sign extension during - bit mask & shift operations. ------------------------------------------------------------------------- */ - -typedef unsigned int UTF32; /* at least 32 bits */ -typedef unsigned short UTF16; /* at least 16 bits */ -typedef unsigned char UTF8; /* typically 8 bits */ -typedef unsigned char Boolean; /* 0 or 1 */ - -/* Some fundamental constants */ -#define UNI_REPLACEMENT_CHAR (UTF32)0x0000FFFD -#define UNI_MAX_BMP (UTF32)0x0000FFFF -#define UNI_MAX_UTF16 (UTF32)0x0010FFFF -#define UNI_MAX_UTF32 (UTF32)0x7FFFFFFF -#define UNI_MAX_LEGAL_UTF32 (UTF32)0x0010FFFF - -#define UNI_MAX_UTF8_BYTES_PER_CODE_POINT 4 - -typedef enum { - conversionOK, /* conversion successful */ - sourceExhausted, /* partial character in source, but hit end */ - targetExhausted, /* insuff. room in target for conversion */ - sourceIllegal /* source sequence is illegal/malformed */ -} ConversionResult; - -typedef enum { - strictConversion = 0, - lenientConversion -} ConversionFlags; - -/* This is for C++ and does no harm in C */ -#ifdef __cplusplus -extern "C" { -#endif - -ConversionResult ConvertUTF8toUTF16 ( - const UTF8** sourceStart, const UTF8* sourceEnd, - UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF8toUTF32 ( - const UTF8** sourceStart, const UTF8* sourceEnd, - UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); - -#ifdef CLANG_NEEDS_THESE_ONE_DAY -ConversionResult ConvertUTF16toUTF8 ( - const UTF16** sourceStart, const UTF16* sourceEnd, - UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); -#endif - -ConversionResult ConvertUTF32toUTF8 ( - const UTF32** sourceStart, const UTF32* sourceEnd, - UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF16toUTF32 ( - const UTF16** sourceStart, const UTF16* sourceEnd, - UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); - -ConversionResult ConvertUTF32toUTF16 ( - const UTF32** sourceStart, const UTF32* sourceEnd, - UTF16** targetStart, UTF16* targetEnd, ConversionFlags flags); -#endif - -Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd); - -Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd); - -unsigned getNumBytesForUTF8(UTF8 firstByte); - -#ifdef __cplusplus -} - -/*************************************************************************/ -/* Below are LLVM-specific wrappers of the functions above. */ - -#include "llvm/ADT/StringRef.h" - -namespace clang { - -/** - * Convert an UTF8 StringRef to UTF8, UTF16, or UTF32 depending on - * WideCharWidth. The converted data is written to ResultPtr, which needs to - * point to at least WideCharWidth * (Source.Size() + 1) bytes. On success, - * ResultPtr will point one after the end of the copied string. On failure, - * ResultPtr will not be changed, and ErrorPtr will be set to the location of - * the first character which could not be converted. - * \return true on success. - */ -bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source, - char *&ResultPtr, const UTF8 *&ErrorPtr); - -/** - * Convert an Unicode code point to UTF8 sequence. - * - * \param Source a Unicode code point. - * \param [in,out] ResultPtr pointer to the output buffer, needs to be at least - * \c UNI_MAX_UTF8_BYTES_PER_CODE_POINT bytes. On success \c ResultPtr is - * updated one past end of the converted sequence. - * - * \returns true on success. - */ -bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr); - -} - -#endif - -/* --------------------------------------------------------------------- */ diff --git a/include/clang/Basic/DeclNodes.td b/include/clang/Basic/DeclNodes.td index 6f2bb35..45742bc 100644 --- a/include/clang/Basic/DeclNodes.td +++ b/include/clang/Basic/DeclNodes.td @@ -74,4 +74,6 @@ def StaticAssert : Decl; def Block : Decl, DeclContext; def ClassScopeFunctionSpecialization : Decl; def Import : Decl; +def OMPThreadPrivate : Decl; +def Empty : Decl; diff --git a/include/clang/Basic/Diagnostic.h b/include/clang/Basic/Diagnostic.h index e47f3e1..0327636 100644 --- a/include/clang/Basic/Diagnostic.h +++ b/include/clang/Basic/Diagnostic.h @@ -23,9 +23,8 @@ #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/OwningPtr.h" #include "llvm/Support/type_traits.h" - -#include <vector> #include <list> +#include <vector> namespace clang { class DiagnosticConsumer; @@ -78,7 +77,7 @@ public: bool BeforePreviousInsertions = false) { FixItHint Hint; Hint.RemoveRange = - CharSourceRange(SourceRange(InsertionLoc, InsertionLoc), false); + CharSourceRange::getCharRange(InsertionLoc, InsertionLoc); Hint.CodeToInsert = Code; Hint.BeforePreviousInsertions = BeforePreviousInsertions; return Hint; @@ -91,7 +90,7 @@ public: bool BeforePreviousInsertions = false) { FixItHint Hint; Hint.RemoveRange = - CharSourceRange(SourceRange(InsertionLoc, InsertionLoc), false); + CharSourceRange::getCharRange(InsertionLoc, InsertionLoc); Hint.InsertFromRange = FromRange; Hint.BeforePreviousInsertions = BeforePreviousInsertions; return Hint; @@ -176,6 +175,7 @@ private: bool SuppressAllDiagnostics; // Suppress all diagnostics. bool ElideType; // Elide common types of templates. bool PrintTemplateTree; // Print a tree when comparing templates. + bool WarnOnSpellCheck; // Emit warning when spellcheck is initiated. bool ShowColors; // Color printing is enabled. OverloadsShown ShowOverloads; // Which overload candidates to show. unsigned ErrorLimit; // Cap of # errors emitted, 0 -> no limit. @@ -280,6 +280,10 @@ private: /// \brief Sticky flag set to \c true when an error is emitted. bool ErrorOccurred; + /// \brief Sticky flag set to \c true when an "uncompilable error" occurs. + /// I.e. an error that was not upgraded from a warning by -Werror. + bool UncompilableErrorOccurred; + /// \brief Sticky flag set to \c true when a fatal error is emitted. bool FatalErrorOccurred; @@ -432,8 +436,8 @@ public: /// /// If this and IgnoreAllWarnings are both set, then that one wins. void setEnableAllWarnings(bool Val) { EnableAllWarnings = Val; } - bool getEnableAllWarnngs() const { return EnableAllWarnings; } - + bool getEnableAllWarnings() const { return EnableAllWarnings; } + /// \brief When set to true, any warnings reported are issued as errors. void setWarningsAsErrors(bool Val) { WarningsAsErrors = Val; } bool getWarningsAsErrors() const { return WarningsAsErrors; } @@ -463,6 +467,10 @@ public: /// tree format. void setPrintTemplateTree(bool Val = false) { PrintTemplateTree = Val; } bool getPrintTemplateTree() { return PrintTemplateTree; } + + /// \brief Warn when spellchecking is initated, for testing. + void setWarnOnSpellCheck(bool Val = false) { WarnOnSpellCheck = Val; } + bool getWarnOnSpellCheck() { return WarnOnSpellCheck; } /// \brief Set color printing, so the type diffing will inject color markers /// into the output. @@ -559,6 +567,12 @@ public: SourceLocation Loc = SourceLocation()); bool hasErrorOccurred() const { return ErrorOccurred; } + + /// \brief Errors that actually prevent compilation, not those that are + /// upgraded from a warning by -Werror. + bool hasUncompilableErrorOccurred() const { + return UncompilableErrorOccurred; + } bool hasFatalErrorOccurred() const { return FatalErrorOccurred; } /// \brief Determine whether any kind of unrecoverable error has occurred. @@ -574,7 +588,7 @@ public: /// \brief Return an ID for a diagnostic with the specified message and level. /// - /// If this is the first request for this diagnosic, it is registered and + /// If this is the first request for this diagnostic, it is registered and /// created, otherwise the existing ID is returned. unsigned getCustomDiagID(Level L, StringRef Message) { return Diags->getCustomDiagID((DiagnosticIDs::Level)L, Message); @@ -598,6 +612,12 @@ public: ArgToStringCookie = Cookie; } + /// \brief Note that the prior diagnostic was emitted by some other + /// \c DiagnosticsEngine, and we may be attaching a note to that diagnostic. + void notePriorDiagnosticFrom(const DiagnosticsEngine &Other) { + LastDiagLevel = Other.LastDiagLevel; + } + /// \brief Reset the state of the diagnostic object to its initial /// configuration. void Reset(); diff --git a/include/clang/Basic/DiagnosticASTKinds.td b/include/clang/Basic/DiagnosticASTKinds.td index d869c99..9be32af 100644 --- a/include/clang/Basic/DiagnosticASTKinds.td +++ b/include/clang/Basic/DiagnosticASTKinds.td @@ -106,6 +106,9 @@ def note_constexpr_calls_suppressed : Note< "(skipping %0 call%s0 in backtrace; use -fconstexpr-backtrace-limit=0 to " "see all)">; def note_constexpr_call_here : Note<"in call to '%0'">; +def warn_integer_constant_overflow : Warning< + "overflow in expression; result is %0 with type %1">, + InGroup<DiagGroup<"integer-overflow">>; // inline asm related. let CategoryName = "Inline Assembly Issue" in { @@ -135,7 +138,8 @@ def err_odr_function_type_inconsistent : Error< "external function %0 declared with incompatible types in different " "translation units (%1 vs. %2)">; def warn_odr_tag_type_inconsistent : Warning< - "type %0 has incompatible definitions in different translation units">; + "type %0 has incompatible definitions in different translation units">, + InGroup<DiagGroup<"odr">>; def note_odr_tag_kind_here: Note< "%0 is a %select{struct|interface|union|class|enum}1 here">; def note_odr_field : Note<"field %0 has type %1 here">; diff --git a/include/clang/Basic/DiagnosticCommentKinds.td b/include/clang/Basic/DiagnosticCommentKinds.td index e6dfe5b..3880e0e 100644 --- a/include/clang/Basic/DiagnosticCommentKinds.td +++ b/include/clang/Basic/DiagnosticCommentKinds.td @@ -44,18 +44,18 @@ def note_doc_html_end_tag : Note< // Commands def warn_doc_block_command_empty_paragraph : Warning< - "empty paragraph passed to '\\%0' command">, + "empty paragraph passed to '%select{\\|@}0%1' command">, InGroup<Documentation>, DefaultIgnore; def warn_doc_block_command_duplicate : Warning< - "duplicated command '\\%0'">, + "duplicated command '%select{\\|@}0%1'">, InGroup<Documentation>, DefaultIgnore; def note_doc_block_command_previous : Note< - "previous command '\\%0' here">; + "previous command '%select{\\|@}0%1' here">; def note_doc_block_command_previous_alias : Note< - "previous command '\\%0' (an alias of '\\%1') here">; + "previous command '%select{\\|@}0%1' (an alias of '\\%2') here">; // \param command @@ -69,10 +69,29 @@ def warn_doc_param_spaces_in_direction : Warning< InGroup<DocumentationPedantic>, DefaultIgnore; def warn_doc_param_not_attached_to_a_function_decl : Warning< - "'\\param' command used in a comment that is not attached to " + "'%select{\\|@}0param' command used in a comment that is not attached to " "a function declaration">, InGroup<Documentation>, DefaultIgnore; +def warn_doc_function_method_decl_mismatch : Warning< + "'%select{\\|@}0%select{function|functiongroup|method|methodgroup|callback}1' " + "command should be used in a comment attached to " + "%select{a function|a function|an Objective-C method|an Objective-C method|" + "a pointer to function}2 declaration">, + InGroup<Documentation>, DefaultIgnore; + +def warn_doc_api_container_decl_mismatch : Warning< + "'%select{\\|@}0%select{class|interface|protocol|struct|union}1' " + "command should not be used in a comment attached to a " + "non-%select{class|interface|protocol|struct|union}2 declaration">, + InGroup<Documentation>, DefaultIgnore; + +def warn_doc_container_decl_mismatch : Warning< + "'%select{\\|@}0%select{classdesign|coclass|dependency|helper" + "|helperclass|helps|instancesize|ownership|performance|security|superclass}1' " + "command should not be used in a comment attached to a non-container declaration">, + InGroup<Documentation>, DefaultIgnore; + def warn_doc_param_duplicate : Warning< "parameter '%0' is already documented">, InGroup<Documentation>, DefaultIgnore; @@ -87,10 +106,10 @@ def warn_doc_param_not_found : Warning< def note_doc_param_name_suggestion : Note< "did you mean '%0'?">; -// \tparam command +// tparam command def warn_doc_tparam_not_attached_to_a_template_decl : Warning< - "'\\tparam' command used in a comment that is not attached to " + "'%select{\\|@}0tparam' command used in a comment that is not attached to " "a template declaration">, InGroup<Documentation>, DefaultIgnore; @@ -111,14 +130,14 @@ def note_doc_tparam_name_suggestion : Note< // \returns command def warn_doc_returns_not_attached_to_a_function_decl : Warning< - "'\\%0' command used in a comment that is not attached to " + "'%select{\\|@}0%1' command used in a comment that is not attached to " "a function or method declaration">, InGroup<Documentation>, DefaultIgnore; def warn_doc_returns_attached_to_a_void_function : Warning< - "'\\%0' command used in a comment that is attached to a " + "'%select{\\|@}0%1' command used in a comment that is attached to a " "%select{function returning void|constructor|destructor|" - "method returning void}1">, + "method returning void}2">, InGroup<Documentation>, DefaultIgnore; // \deprecated command @@ -134,7 +153,7 @@ def note_add_deprecation_attr : Note< // verbatim block commands def warn_verbatim_block_end_without_start : Warning< - "'\\%0' command does not terminate a verbatim text block">, + "'%select{\\|@}0%1' command does not terminate a verbatim text block">, InGroup<Documentation>, DefaultIgnore; } // end of documentation issue category diff --git a/include/clang/Basic/DiagnosticCommonKinds.td b/include/clang/Basic/DiagnosticCommonKinds.td index a6ce9d4..7ff6ae1 100644 --- a/include/clang/Basic/DiagnosticCommonKinds.td +++ b/include/clang/Basic/DiagnosticCommonKinds.td @@ -41,6 +41,9 @@ def err_expected_colon : Error<"expected ':'">; def err_expected_colon_after_setter_name : Error< "method name referenced in property setter attribute " "must end with ':'">; +def err_expected_string_literal : Error<"expected string literal " + "%select{in %1|for diagnostic message in static_assert|" + "for optional message in 'availability' attribute}0">; def err_invalid_string_udl : Error< "string literal with user-defined suffix cannot be used here">; def err_invalid_character_udl : Error< @@ -49,8 +52,6 @@ def err_invalid_numeric_udl : Error< "numeric literal with user-defined suffix cannot be used here">; // Parse && Sema -def ext_no_declarators : ExtWarn<"declaration does not declare anything">, - InGroup<MissingDeclarations>; def err_param_redefinition : Error<"redefinition of parameter %0">; def warn_method_param_redefinition : Warning<"redefinition of method parameter %0">; def warn_method_param_declaration : Warning<"redeclaration of method parameter %0">, @@ -71,11 +72,12 @@ def err_module_not_found : Error<"module '%0' not found">, DefaultFatal; def err_module_not_built : Error<"could not build module '%0'">, DefaultFatal; def err_module_cycle : Error<"cyclic dependency in module '%0': %1">, DefaultFatal; -def warn_module_build : Warning<"building module '%0' from source">, - InGroup<ModuleBuild>, DefaultIgnore; def note_pragma_entered_here : Note<"#pragma entered here">; def note_decl_hiding_tag_type : Note< "%1 %0 is hidden by a non-type declaration of %0 here">; +def err_attribute_not_type_attr : Error< + "%0 attribute cannot be applied to types">; +def err_enum_template : Error<"enumeration cannot be a template">; // Sema && Lex def ext_c99_longlong : Extension< @@ -115,4 +117,8 @@ def err_unable_to_rename_temp : Error< "unable to rename temporary '%0' to output file '%1': '%2'">; def err_unable_to_make_temp : Error< "unable to make temporary file: %0">; + +// Modules +def err_module_file_conflict : Error<"module '%0' found in both '%1' and '%2'">; + } diff --git a/include/clang/Basic/DiagnosticDriverKinds.td b/include/clang/Basic/DiagnosticDriverKinds.td index 4b43035..15b8948 100644 --- a/include/clang/Basic/DiagnosticDriverKinds.td +++ b/include/clang/Basic/DiagnosticDriverKinds.td @@ -35,6 +35,8 @@ def err_drv_use_of_Z_option : Error< "unsupported use of internal gcc -Z option '%0'">; def err_drv_output_argument_with_multiple_files : Error< "cannot specify -o when generating multiple output files">; +def err_no_external_windows_assembler : Error< + "there is no external assembler we can use on windows">; def err_drv_unable_to_remove_file : Error< "unable to remove file: %0">; def err_drv_command_failure : Error< @@ -57,6 +59,8 @@ def err_drv_no_linker_llvm_support : Error< "'%0': unable to pass LLVM bit-code files to linker">; def err_drv_no_ast_support : Error< "'%0': unable to use AST files with this tool">; +def err_drv_no_module_support : Error< + "'%0': unable to use module files with this tool">; def err_drv_clang_unsupported : Error< "the clang compiler does not support '%0'">; def err_drv_clang_unsupported_per_platform : Error< @@ -67,6 +71,8 @@ def err_drv_command_failed : Error< "%0 command failed with exit code %1 (use -v to see invocation)">; def err_drv_command_signalled : Error< "%0 command failed due to signal (use -v to see invocation)">; +def err_drv_force_crash : Error< + "failing because environment variable '%0' is set">; def err_drv_invalid_mfloat_abi : Error< "invalid float ABI '%0'">; def err_drv_invalid_libcxx_deployment : Error< @@ -108,19 +114,21 @@ def warn_c_kext : Warning< "ignoring -fapple-kext which is valid for C++ and Objective-C++ only">; def warn_drv_input_file_unused : Warning< "%0: '%1' input unused%select{ when '%3' is present|}2">, - InGroup<DiagGroup<"unused-command-line-argument">>; + InGroup<UnusedCommandLineArgument>; def warn_drv_input_file_unused_by_cpp : Warning< "%0: '%1' input unused in cpp mode">, - InGroup<DiagGroup<"unused-command-line-argument">>; + InGroup<UnusedCommandLineArgument>; def warn_drv_preprocessed_input_file_unused : Warning< "%0: previously preprocessed input%select{ unused when '%2' is present|}1">, - InGroup<DiagGroup<"unused-command-line-argument">>; + InGroup<UnusedCommandLineArgument>; def warn_drv_unused_argument : Warning< "argument unused during compilation: '%0'">, - InGroup<DiagGroup<"unused-command-line-argument">>; + InGroup<UnusedCommandLineArgument>; def warn_drv_empty_joined_argument : Warning< "joined argument expects additional value: '%0'">, - InGroup<DiagGroup<"unused-command-line-argument">>; + InGroup<UnusedCommandLineArgument>; +def warn_drv_unused_sanitizer : Warning<"'%0' is ignored in absence of '%1'">, + InGroup<UnusedSanitizeArgument>; def warn_drv_clang_unsupported : Warning< "the clang compiler does not support '%0'">; def warn_drv_deprecated_arg : Warning< @@ -136,6 +144,8 @@ def warn_drv_objc_gc_unsupported : Warning< "Objective-C garbage collection is not supported on this platform, ignoring '%0'">; def warn_drv_pch_not_first_include : Warning< "precompiled header '%0' was ignored because '%1' is not first '-include'">; +def warn_missing_sysroot : Warning<"no such sysroot directory: '%0'">, + InGroup<DiagGroup<"missing-sysroot">>; def note_drv_command_failed_diag_msg : Note< "diagnostic msg: %0">; diff --git a/include/clang/Basic/DiagnosticFrontendKinds.td b/include/clang/Basic/DiagnosticFrontendKinds.td index b7a8476..111622e 100644 --- a/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/include/clang/Basic/DiagnosticFrontendKinds.td @@ -48,8 +48,6 @@ def err_fe_unable_to_interface_with_target : Error< "unable to interface with target machine">; def err_fe_unable_to_open_output : Error< "unable to open output file '%0': '%1'">; -def err_fe_unable_to_open_logfile : Error< - "unable to open logfile file '%0': '%1'">; def err_fe_pth_file_has_no_source_header : Error< "PTH file '%0' does not designate an original source header file for -include-pth">; def warn_fe_macro_contains_embedded_newline : Warning< @@ -60,6 +58,8 @@ def warn_fe_cc_log_diagnostics_failure : Warning< "unable to open CC_LOG_DIAGNOSTICS file: %0 (using stderr)">; def err_fe_no_pch_in_dir : Error< "no suitable precompiled header file found in directory '%0'">; +def err_fe_action_not_available : Error< + "action %0 not compiled in">; def warn_fe_serialized_diag_failure : Warning< "unable to open file %0 for serializing diagnostics (%1)">, @@ -100,19 +100,19 @@ def err_relocatable_without_isysroot : Error< def warn_unknown_warning_option : Warning< "unknown warning option '%0'">, - InGroup<DiagGroup<"unknown-warning-option"> >; + InGroup<UnknownWarningOption>; def warn_unknown_negative_warning_option : Warning< "unknown warning option '%0'">, - InGroup<DiagGroup<"unknown-warning-option"> >; + InGroup<UnknownWarningOption>; def warn_unknown_warning_option_suggest : Warning< "unknown warning option '%0'; did you mean '%1'?">, - InGroup<DiagGroup<"unknown-warning-option"> >; + InGroup<UnknownWarningOption>; def warn_unknown_negative_warning_option_suggest : Warning< "unknown warning option '%0'; did you mean '%1'?">, - InGroup<DiagGroup<"unknown-warning-option"> >; + InGroup<UnknownWarningOption>; def warn_unknown_warning_specifier : Warning< "unknown %0 warning specifier: '%1'">, - InGroup<DiagGroup<"unknown-warning-option"> >; + InGroup<UnknownWarningOption>; def err_unknown_analyzer_checker : Error< "no analyzer checkers are associated with '%0'">; @@ -129,8 +129,6 @@ def err_missing_module_name : Error< DefaultFatal; def err_missing_module : Error< "no module named '%0' declared in module map file '%1'">, DefaultFatal; -def err_missing_umbrella_header : Error< - "cannot open umbrella header '%0': %1">, DefaultFatal; def err_no_submodule : Error<"no submodule named %0 in module '%1'">; def err_no_submodule_suggest : Error< "no submodule named %0 in module '%1'; did you mean '%2'?">; @@ -139,5 +137,11 @@ def warn_missing_submodule : Warning<"missing submodule '%0'">, def err_module_map_temp_file : Error< "unable to write temporary module map file '%0'">, DefaultFatal; def err_module_unavailable : Error<"module '%0' requires feature '%1'">; - +def warn_module_config_macro_undef : Warning< + "%select{definition|#undef}0 of configuration macro '%1' has no effect on " + "the import of '%2'; pass '%select{-D%1=...|-U%1}0' on the command line " + "to configure the module">, + InGroup<ConfigMacros>; +def note_module_def_undef_here : Note< + "macro was %select{defined|#undef'd}0 here">; } diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td index f9f9ec7..a12a4f9 100644 --- a/include/clang/Basic/DiagnosticGroups.td +++ b/include/clang/Basic/DiagnosticGroups.td @@ -22,6 +22,8 @@ def : DiagGroup<"address">; def AddressOfTemporary : DiagGroup<"address-of-temporary">; def : DiagGroup<"aggregate-return">; def AmbigMemberTemplate : DiagGroup<"ambiguous-member-template">; +def ArrayBounds : DiagGroup<"array-bounds">; +def ArrayBoundsPointerArithmetic : DiagGroup<"array-bounds-pointer-arithmetic">; def Availability : DiagGroup<"availability">; def Section : DiagGroup<"section">; def AutoImport : DiagGroup<"auto-import">; @@ -36,14 +38,17 @@ def NonLiteralNullConversion : DiagGroup<"non-literal-null-conversion">; def NullConversion : DiagGroup<"null-conversion">; def ImplicitConversionFloatingPointToBool : DiagGroup<"implicit-conversion-floating-point-to-bool">; +def BadArrayNewLength : DiagGroup<"bad-array-new-length">; +def BuiltinMacroRedefined : DiagGroup<"builtin-macro-redefined">; def BuiltinRequiresHeader : DiagGroup<"builtin-requires-header">; +def C99Compat : DiagGroup<"c99-compat">; def CXXCompat: DiagGroup<"c++-compat">; def CastAlign : DiagGroup<"cast-align">; def : DiagGroup<"cast-qual">; def : DiagGroup<"char-align">; def Comment : DiagGroup<"comment">; +def ConfigMacros : DiagGroup<"config-macros">; def : DiagGroup<"ctor-dtor-privacy">; -def DefaultArgSpecialMember : DiagGroup<"default-arg-special-member">; def GNUDesignator : DiagGroup<"gnu-designator">; def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor">; @@ -118,10 +123,18 @@ def BitwiseOpParentheses: DiagGroup<"bitwise-op-parentheses">; def LogicalOpParentheses: DiagGroup<"logical-op-parentheses">; def ShiftOpParentheses: DiagGroup<"shift-op-parentheses">; def DanglingElse: DiagGroup<"dangling-else">; +def DanglingField : DiagGroup<"dangling-field">; +def DistributedObjectModifiers : DiagGroup<"distributed-object-modifiers">; def IgnoredQualifiers : DiagGroup<"ignored-qualifiers">; def : DiagGroup<"import">; -def IncompatiblePointerTypes : DiagGroup<"incompatible-pointer-types">; +def IncompatiblePointerTypesDiscardsQualifiers + : DiagGroup<"incompatible-pointer-types-discards-qualifiers">; +def IncompatiblePointerTypes + : DiagGroup<"incompatible-pointer-types", + [IncompatiblePointerTypesDiscardsQualifiers]>; def IncompleteUmbrella : DiagGroup<"incomplete-umbrella">; +def InvalidNoreturn : DiagGroup<"invalid-noreturn">; +def InvalidSourceEncoding : DiagGroup<"invalid-source-encoding">; def KNRPromotedParameter : DiagGroup<"knr-promoted-parameter">; def : DiagGroup<"init-self">; def : DiagGroup<"inline">; @@ -136,19 +149,23 @@ def MissingBraces : DiagGroup<"missing-braces">; def MissingDeclarations: DiagGroup<"missing-declarations">; def : DiagGroup<"missing-format-attribute">; def : DiagGroup<"missing-include-dirs">; +def MissingNoreturn : DiagGroup<"missing-noreturn">; def MultiChar : DiagGroup<"multichar">; def : DiagGroup<"nested-externs">; def CXX11LongLong : DiagGroup<"c++11-long-long">; def LongLong : DiagGroup<"long-long", [CXX11LongLong]>; +def MethodSignatures : DiagGroup<"method-signatures">; def MismatchedParameterTypes : DiagGroup<"mismatched-parameter-types">; def MismatchedReturnTypes : DiagGroup<"mismatched-return-types">; def MismatchedTags : DiagGroup<"mismatched-tags">; def MissingFieldInitializers : DiagGroup<"missing-field-initializers">; -def ModuleBuild : DiagGroup<"module-build">; +def ModuleConflict : DiagGroup<"module-conflict">; +def NullArithmetic : DiagGroup<"null-arithmetic">; def NullCharacter : DiagGroup<"null-character">; def NullDereference : DiagGroup<"null-dereference">; def InitializerOverrides : DiagGroup<"initializer-overrides">; def NonNull : DiagGroup<"nonnull">; +def NonPODVarargs : DiagGroup<"non-pod-varargs">; def : DiagGroup<"nonportable-cfstrings">; def NonVirtualDtor : DiagGroup<"non-virtual-dtor">; def OveralignedType : DiagGroup<"over-aligned">; @@ -170,6 +187,7 @@ def ObjCMissingSuperCalls : DiagGroup<"objc-missing-super-calls">; def ObjCRetainBlockProperty : DiagGroup<"objc-noncopy-retain-block-property">; def ObjCReadonlyPropertyHasSetter : DiagGroup<"objc-readonly-with-setter-property">; def ObjCRootClass : DiagGroup<"objc-root-class">; +def DeprecatedObjCIsaUsage : DiagGroup<"deprecated-objc-isa-usage">; def Packed : DiagGroup<"packed">; def Padded : DiagGroup<"padded">; def PointerArith : DiagGroup<"pointer-arith">; @@ -179,6 +197,7 @@ def PoundPragmaMessage : DiagGroup<"#pragma-messages">, DiagCategory<"#pragma message Directive">; def : DiagGroup<"pointer-to-int-cast">; def : DiagGroup<"redundant-decls">; +def ReturnStackAddress : DiagGroup<"return-stack-address">; def ReturnTypeCLinkage : DiagGroup<"return-type-c-linkage">; def ReturnType : DiagGroup<"return-type", [ReturnTypeCLinkage]>; def BindToTemporaryCopy : DiagGroup<"bind-to-temporary-copy", @@ -188,7 +207,6 @@ def SelfAssignment : DiagGroup<"self-assign", [SelfAssignmentField]>; def SemiBeforeMethodBody : DiagGroup<"semicolon-before-method-body">; def Sentinel : DiagGroup<"sentinel">; def MissingMethodReturnType : DiagGroup<"missing-method-return-type">; -def : DiagGroup<"sequence-point">; def Shadow : DiagGroup<"shadow">; def Shorten64To32 : DiagGroup<"shorten-64-to-32">; def : DiagGroup<"sign-promo">; @@ -197,6 +215,12 @@ def : DiagGroup<"stack-protector">; def : DiagGroup<"switch-default">; def : DiagGroup<"synth">; def SizeofArrayArgument : DiagGroup<"sizeof-array-argument">; +def SizeofArrayDecay : DiagGroup<"sizeof-array-decay">; +def SizeofPointerMemaccess : DiagGroup<"sizeof-pointer-memaccess">; +def StaticInInline : DiagGroup<"static-in-inline">; +def StaticLocalInInline : DiagGroup<"static-local-in-inline">; +def GNUStaticFloatInit : DiagGroup<"gnu-static-float-init">; +def StaticFloatInit : DiagGroup<"static-float-init", [GNUStaticFloatInit]>; def StringPlusInt : DiagGroup<"string-plus-int">; def StrncatSize : DiagGroup<"strncat-size">; def TautologicalOutOfRangeCompare : DiagGroup<"tautological-constant-out-of-range-compare">; @@ -206,6 +230,10 @@ def HeaderHygiene : DiagGroup<"header-hygiene">; def DuplicateDeclSpecifier : DiagGroup<"duplicate-decl-specifier">; def CompareDistinctPointerType : DiagGroup<"compare-distinct-pointer-types">; +def Unsequenced : DiagGroup<"unsequenced">; +// GCC name for -Wunsequenced +def : DiagGroup<"sequence-point", [Unsequenced]>; + // Preprocessor warnings. def AmbiguousMacro : DiagGroup<"ambiguous-macro">; @@ -240,17 +268,25 @@ def InvalidPPToken : DiagGroup<"invalid-pp-token">; def Trigraphs : DiagGroup<"trigraphs">; def : DiagGroup<"type-limits">; +def UndefinedReinterpretCast : DiagGroup<"undefined-reinterpret-cast">; +def ReinterpretBaseClass : DiagGroup<"reinterpret-base-class">; def Unicode : DiagGroup<"unicode">; def UninitializedMaybe : DiagGroup<"conditional-uninitialized">; def UninitializedSometimes : DiagGroup<"sometimes-uninitialized">; -def Uninitialized : DiagGroup<"uninitialized", [UninitializedSometimes]>; +def UninitializedStaticSelfInit : DiagGroup<"static-self-init">; +def Uninitialized : DiagGroup<"uninitialized", [UninitializedSometimes, + UninitializedStaticSelfInit]>; def UnknownPragmas : DiagGroup<"unknown-pragmas">; +def UnknownWarningOption : DiagGroup<"unknown-warning-option">; def NSobjectAttribute : DiagGroup<"NSObject-attribute">; def UnknownAttributes : DiagGroup<"attributes">; def IgnoredAttributes : DiagGroup<"ignored-attributes">; def UnnamedTypeTemplateArgs : DiagGroup<"unnamed-type-template-args", [CXX98CompatUnnamedTypeTemplateArgs]>; def UnusedArgument : DiagGroup<"unused-argument">; +def UnusedSanitizeArgument : DiagGroup<"unused-sanitize-argument">; +def UnusedCommandLineArgument : DiagGroup<"unused-command-line-argument", + [UnusedSanitizeArgument]>; def UnusedComparison : DiagGroup<"unused-comparison">; def UnusedExceptionParameter : DiagGroup<"unused-exception-parameter">; def UnneededInternalDecl : DiagGroup<"unneeded-internal-declaration">; @@ -293,6 +329,7 @@ def VariadicMacros : DiagGroup<"variadic-macros">; def VectorConversion : DiagGroup<"vector-conversion">; // clang specific def VexingParse : DiagGroup<"vexing-parse">; def VLA : DiagGroup<"vla">; +def VLAExtension : DiagGroup<"vla-extension">; def VolatileRegisterVar : DiagGroup<"volatile-register-var">; def Visibility : DiagGroup<"visibility">; def ZeroLengthArray : DiagGroup<"zero-length-array">; @@ -379,7 +416,6 @@ def Most : DiagGroup<"most", [ DeleteNonVirtualDtor, Format, Implicit, - IntToPointerCast, MismatchedTags, MissingBraces, MultiChar, @@ -387,6 +423,7 @@ def Most : DiagGroup<"most", [ ReturnType, SelfAssignment, SizeofArrayArgument, + SizeofArrayDecay, StringPlusInt, Trigraphs, Uninitialized, @@ -407,6 +444,7 @@ def ThreadSafety : DiagGroup<"thread-safety", [ThreadSafetyAttributes, ThreadSafetyAnalysis, ThreadSafetyPrecise]>; +def ThreadSafetyBeta : DiagGroup<"thread-safety-beta">; // Note that putting warnings in -Wall will not disable them by default. If a // warning should be active _only_ when -Wall is passed in, mark it as @@ -449,7 +487,8 @@ def C11 : DiagGroup<"c11-extensions">; def C99 : DiagGroup<"c99-extensions">; // A warning group for warnings about GCC extensions. -def GNU : DiagGroup<"gnu", [GNUDesignator, VLA, ZeroLengthArray]>; +def GNU : DiagGroup<"gnu", [GNUDesignator, VLAExtension, + ZeroLengthArray, GNUStaticFloatInit]>; // A warning group for warnings about code that clang accepts but gcc doesn't. def GccCompat : DiagGroup<"gcc-compat">; @@ -460,6 +499,8 @@ def ObjCNonUnifiedException : DiagGroup<"objc-nonunified-exceptions">; def ObjCProtocolMethodImpl : DiagGroup<"objc-protocol-method-implementation">; +def ObjCNoPropertyAutoSynthesis : DiagGroup<"objc-property-synthesis">; + // ObjC API warning groups. def ObjCRedundantLiteralUse : DiagGroup<"objc-redundant-literal-use">; def ObjCRedundantAPIUse : DiagGroup<"objc-redundant-api-use", [ @@ -480,3 +521,6 @@ def ASMOperandWidths : DiagGroup<"asm-operand-widths">; def ASM : DiagGroup<"asm", [ ASMOperandWidths ]>; + +// OpenMP warnings. +def SourceUsesOpenMP : DiagGroup<"source-uses-openmp">; diff --git a/include/clang/Basic/DiagnosticIDs.h b/include/clang/Basic/DiagnosticIDs.h index 11552af..d35b907 100644 --- a/include/clang/Basic/DiagnosticIDs.h +++ b/include/clang/Basic/DiagnosticIDs.h @@ -15,13 +15,9 @@ #ifndef LLVM_CLANG_DIAGNOSTICIDS_H #define LLVM_CLANG_DIAGNOSTICIDS_H +#include "clang/Basic/LLVM.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/StringRef.h" -#include "clang/Basic/LLVM.h" - -namespace llvm { - template<typename T, unsigned> class SmallVector; -} namespace clang { class DiagnosticsEngine; @@ -128,7 +124,7 @@ public: /// \brief Return an ID for a diagnostic with the specified message and level. /// - /// If this is the first request for this diagnosic, it is registered and + /// If this is the first request for this diagnostic, it is registered and /// created, otherwise the existing ID is returned. unsigned getCustomDiagID(Level L, StringRef Message); @@ -231,10 +227,10 @@ public: /// \param Diags [out] - On return, the diagnostics in the group. /// \returns True if the given group is unknown, false otherwise. bool getDiagnosticsInGroup(StringRef Group, - llvm::SmallVectorImpl<diag::kind> &Diags) const; + SmallVectorImpl<diag::kind> &Diags) const; /// \brief Get the set of all diagnostic IDs. - void getAllDiagnostics(llvm::SmallVectorImpl<diag::kind> &Diags) const; + void getAllDiagnostics(SmallVectorImpl<diag::kind> &Diags) const; /// \brief Get the warning option with the closest edit distance to the given /// group name. @@ -245,7 +241,7 @@ private: /// /// \param Diags [out] - On return, the diagnostics in the group. void getDiagnosticsInGroup(const WarningOption *Group, - llvm::SmallVectorImpl<diag::kind> &Diags) const; + SmallVectorImpl<diag::kind> &Diags) const; /// \brief Based on the way the client configured the DiagnosticsEngine /// object, classify the specified diagnostic ID into a Level, consumable by diff --git a/include/clang/Basic/DiagnosticLexKinds.td b/include/clang/Basic/DiagnosticLexKinds.td index c6c50ab..339788b 100644 --- a/include/clang/Basic/DiagnosticLexKinds.td +++ b/include/clang/Basic/DiagnosticLexKinds.td @@ -93,26 +93,63 @@ def ext_multichar_character_literal : ExtWarn< "multi-character character constant">, InGroup<MultiChar>; def ext_four_char_character_literal : Extension< "multi-character character constant">, InGroup<FourByteMultiChar>; - -// Literal -def ext_nonstandard_escape : Extension< - "use of non-standard escape character '\\%0'">; -def ext_unknown_escape : ExtWarn<"unknown escape sequence '\\%0'">; -def err_hex_escape_no_digits : Error<"\\x used with no following hex digits">; -def err_ucn_escape_no_digits : Error<"\\u used with no following hex digits">; -def err_ucn_escape_invalid : Error<"invalid universal character">; -def err_ucn_escape_incomplete : Error<"incomplete universal character name">; + +// Unicode and UCNs +def err_invalid_utf8 : Error< + "source file is not valid UTF-8">; +def err_non_ascii : Error< + "non-ASCII characters are not allowed outside of literals and identifiers">; +def ext_unicode_whitespace : ExtWarn< + "treating Unicode character as whitespace">, + InGroup<DiagGroup<"unicode-whitespace">>; + +def err_hex_escape_no_digits : Error< + "\\%0 used with no following hex digits">; +def warn_ucn_escape_no_digits : Warning< + "\\%0 used with no following hex digits; " + "treating as '\\' followed by identifier">, InGroup<Unicode>; +def err_ucn_escape_incomplete : Error< + "incomplete universal character name">; +def warn_ucn_escape_incomplete : Warning< + "incomplete universal character name; " + "treating as '\\' followed by identifier">, InGroup<Unicode>; +def note_ucn_four_not_eight : Note<"did you mean to use '\\u'?">; + def err_ucn_escape_basic_scs : Error< "character '%0' cannot be specified by a universal character name">; def err_ucn_control_character : Error< "universal character name refers to a control character">; +def err_ucn_escape_invalid : Error<"invalid universal character">; +def warn_ucn_escape_surrogate : Warning< + "universal character name refers to a surrogate character">, + InGroup<Unicode>; + +def warn_c99_compat_unicode_id : Warning< + "%select{using this character in an identifier|starting an identifier with " + "this character}0 is incompatible with C99">, + InGroup<C99Compat>, DefaultIgnore; +def warn_cxx98_compat_unicode_id : Warning< + "using this character in an identifier is incompatible with C++98">, + InGroup<CXX98Compat>, DefaultIgnore; + def warn_cxx98_compat_literal_ucn_escape_basic_scs : Warning< "specifying character '%0' with a universal character name " "is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; def warn_cxx98_compat_literal_ucn_control_character : Warning< "universal character name referring to a control character " "is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; +def warn_ucn_not_valid_in_c89 : Warning< + "universal character names are only valid in C99 or C++; " + "treating as '\\' followed by identifier">, InGroup<Unicode>; +def warn_ucn_not_valid_in_c89_literal : ExtWarn< + "universal character names are only valid in C99 or C++">, InGroup<Unicode>; + + +// Literal +def ext_nonstandard_escape : Extension< + "use of non-standard escape character '\\%0'">; +def ext_unknown_escape : ExtWarn<"unknown escape sequence '\\%0'">; def err_invalid_decimal_digit : Error<"invalid digit '%0' in decimal constant">; def err_invalid_binary_digit : Error<"invalid digit '%0' in binary constant">; def err_invalid_octal_digit : Error<"invalid digit '%0' in octal constant">; @@ -145,8 +182,9 @@ def ext_string_too_long : Extension<"string literal of length %0 exceeds " "support">, InGroup<OverlengthStrings>; def err_character_too_large : Error< "character too large for enclosing character literal type">; -def warn_ucn_not_valid_in_c89 : ExtWarn< - "unicode escape sequences are only valid in C99 or C++">, InGroup<Unicode>; +def warn_c99_compat_unicode_literal : Warning< + "unicode literals are incompatible with C99">, + InGroup<C99Compat>, DefaultIgnore; def warn_cxx98_compat_unicode_literal : Warning< "unicode literals are incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; @@ -175,12 +213,12 @@ def err_bad_string_encoding : Error< "illegal character encoding in string literal">; def warn_bad_string_encoding : ExtWarn< "illegal character encoding in string literal">, - InGroup<DiagGroup<"invalid-source-encoding">>; + InGroup<InvalidSourceEncoding>; def err_bad_character_encoding : Error< "illegal character encoding in character literal">; def warn_bad_character_encoding : ExtWarn< "illegal character encoding in character literal">, - InGroup<DiagGroup<"invalid-source-encoding">>; + InGroup<InvalidSourceEncoding>; def err_lexing_string : Error<"failure when lexing a string">; @@ -218,9 +256,10 @@ def pp_pragma_sysheader_in_main_file : Warning< def pp_poisoning_existing_macro : Warning<"poisoning existing macro">; def pp_out_of_date_dependency : Warning< "current file is older than dependency %0">; -def pp_undef_builtin_macro : Warning<"undefining builtin macro">; -def pp_redef_builtin_macro : Warning<"redefining builtin macro">, - InGroup<DiagGroup<"builtin-macro-redefined">>; +def ext_pp_undef_builtin_macro : ExtWarn<"undefining builtin macro">, + InGroup<BuiltinMacroRedefined>; +def ext_pp_redef_builtin_macro : ExtWarn<"redefining builtin macro">, + InGroup<BuiltinMacroRedefined>; def pp_disabled_macro_expansion : Warning< "disabled expansion of recursive macro">, DefaultIgnore, InGroup<DiagGroup<"disabled-macro-expansion">>; @@ -284,7 +323,12 @@ def warn_cxx98_compat_empty_fnmacro_arg : Warning< InGroup<CXX98CompatPedantic>, DefaultIgnore; def note_macro_here : Note<"macro %0 defined here">; +def err_pp_opencl_variadic_macros : + Error<"variadic macros not supported in OpenCL">; + def err_pp_invalid_directive : Error<"invalid preprocessing directive">; +def err_pp_directive_required : Error< + "%0 must be used within a preprocessing directive">; def err_pp_file_not_found : Error<"'%0' file not found">, DefaultFatal; def err_pp_file_not_found_not_fatal : Error< "'%0' file not found with <angled> include; use \"quotes\" instead">; @@ -486,6 +530,16 @@ def err_mmap_umbrella_clash : Error< "umbrella for module '%0' already covers this directory">; def err_mmap_export_module_id : Error< "expected an exported module name or '*'">; +def err_mmap_expected_library_name : Error< + "expected %select{library|framework}0 name as a string">; +def err_mmap_config_macro_submodule : Error< + "configuration macros are only allowed on top-level modules">; +def err_mmap_expected_config_macro : Error< + "expected configuration macro name after ','">; +def err_mmap_expected_conflicts_comma : Error< + "expected ',' after conflicting module name">; +def err_mmap_expected_conflicts_message : Error< + "expected a message describing the conflict with '%0'">; def err_mmap_missing_module_unqualified : Error< "no module named '%0' visible from '%1'">; def err_mmap_missing_module_qualified : Error< @@ -521,7 +575,8 @@ def warn_auto_module_import : Warning< "treating #%select{include|import|include_next|__include_macros}0 as an " "import of module '%1'">, InGroup<AutoImport>, DefaultIgnore; def warn_uncovered_module_header : Warning< - "umbrella header does not include header '%0'">, InGroup<IncompleteUmbrella>; + "umbrella header for module '%0' does not include header '%1'">, + InGroup<IncompleteUmbrella>; def err_expected_id_building_module : Error< "expected a module name in '__building_module' expression">; diff --git a/include/clang/Basic/DiagnosticOptions.def b/include/clang/Basic/DiagnosticOptions.def index 476ac1e..8e5562c 100644 --- a/include/clang/Basic/DiagnosticOptions.def +++ b/include/clang/Basic/DiagnosticOptions.def @@ -54,6 +54,7 @@ DIAGOPT(ShowCarets, 1, 1) /// Show carets in diagnostics. DIAGOPT(ShowFixits, 1, 1) /// Show fixit information. DIAGOPT(ShowSourceRanges, 1, 0) /// Show source ranges in numeric form. DIAGOPT(ShowParseableFixits, 1, 0) /// Show machine parseable fix-its. +DIAGOPT(ShowPresumedLoc, 1, 0) /// Show presumed location for diagnostics. DIAGOPT(ShowOptionNames, 1, 0) /// Show the option name for mappable /// diagnostics. DIAGOPT(ShowNoteIncludeStack, 1, 0) /// Show include stacks for notes. @@ -71,6 +72,7 @@ DIAGOPT(VerifyDiagnostics, 1, 0) /// Check that diagnostics match the expected DIAGOPT(ElideType, 1, 0) /// Elide identical types in template diffing DIAGOPT(ShowTemplateTree, 1, 0) /// Print a template tree when diffing +DIAGOPT(WarnOnSpellCheck, 1, 0) /// -fwarn-on-spellcheck VALUE_DIAGOPT(ErrorLimit, 32, 0) /// Limit # errors emitted. /// Limit depth of macro expansion backtrace. diff --git a/include/clang/Basic/DiagnosticOptions.h b/include/clang/Basic/DiagnosticOptions.h index b75cb0c..2fba384 100644 --- a/include/clang/Basic/DiagnosticOptions.h +++ b/include/clang/Basic/DiagnosticOptions.h @@ -10,8 +10,8 @@ #ifndef LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H #define LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H +#include "clang/Basic/LLVM.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" - #include <string> #include <vector> @@ -24,9 +24,8 @@ enum OverloadsShown { Ovl_Best ///< Show just the "best" overload candidates. }; -/// DiagnosticOptions - Options for controlling the compiler diagnostics -/// engine. -class DiagnosticOptions : public llvm::RefCountedBase<DiagnosticOptions>{ +/// \brief Options for controlling the compiler diagnostics engine. +class DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{ public: enum TextDiagnosticFormat { Clang, Msvc, Vi }; @@ -49,14 +48,10 @@ protected: #include "clang/Basic/DiagnosticOptions.def" public: - /// If non-empty, a file to log extended build information to, for development - /// testing and analysis. - std::string DumpBuildInformation; - - /// The file to log diagnostic output to. + /// \brief The file to log diagnostic output to. std::string DiagnosticLogFile; - /// The file to serialize diagnostics to (non-appending). + /// \brief The file to serialize diagnostics to (non-appending). std::string DiagnosticSerializationFile; /// The list of -W... options used to alter the diagnostic mappings, with the diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td index 21eeccb..04a433c 100644 --- a/include/clang/Basic/DiagnosticParseKinds.td +++ b/include/clang/Basic/DiagnosticParseKinds.td @@ -18,9 +18,6 @@ def w_asm_qualifier_ignored : Warning<"ignored %0 qualifier on asm">, def warn_file_asm_volatile : Warning< "meaningless 'volatile' on asm outside function">, CatInlineAsm; -def warn_unsupported_msasm : Warning< - "MS-style inline assembly is not supported">, InGroup<Microsoft>; - let CategoryName = "Parse Issue" in { def ext_empty_translation_unit : Extension< @@ -98,6 +95,8 @@ def warn_cxx98_compat_enum_fixed_underlying_type : Warning< def warn_cxx98_compat_alignof : Warning< "alignof expressions are incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; +def ext_alignof_expr : ExtWarn< + "%0 applied to an expression is a GNU extension">, InGroup<GNU>; def warn_microsoft_dependent_exists : Warning< "dependent %select{__if_not_exists|__if_exists}0 declarations are ignored">, @@ -113,6 +112,9 @@ def note_previous_default_assoc : Note< def ext_c11_alignment : Extension< "%0 is a C11-specific feature">, InGroup<C11>; +def ext_c11_noreturn : Extension< + "_Noreturn functions are a C11-specific feature">, InGroup<C11>; + def ext_gnu_indirect_goto : Extension< "use of GNU indirect-goto extension">, InGroup<GNU>; def ext_gnu_address_of_label : Extension< @@ -225,13 +227,10 @@ def note_missing_selector_name : Note< def note_force_empty_selector_name : Note< "or insert whitespace before ':' to use %0 as parameter name " "and have an empty entry in the selector">; -def note_missing_argument_name : Note< - "did you mean to use %0 as the selector name instead of %1">; def err_label_end_of_compound_statement : Error< "label at end of compound statement: expected statement">; def err_address_of_label_outside_fn : Error< "use of address-of-label extension outside of a function body">; -def err_expected_string_literal : Error<"expected string literal">; def err_asm_operand_wide_string_literal : Error< "cannot use %select{unicode|wide}0 string literal in 'asm'">; def err_expected_selector_for_method : Error< @@ -364,7 +363,7 @@ def note_objc_container_start : Note< "%select{class|protocol|category|class extension|implementation" "|category implementation}0 started here">; def warn_objc_protocol_qualifier_missing_id : Warning< - "protocol qualifiers without 'id' is archaic">; + "protocol has no object type specified; defaults to qualified 'id'">; def err_objc_unknown_at : Error<"expected an Objective-C directive after '@'">; def err_illegal_super_cast : Error< "cannot cast 'super' (it isn't an expression)">; @@ -400,6 +399,11 @@ def err_objc_properties_require_objc2 : Error< "properties are an Objective-C 2 feature">; def err_objc_unexpected_attr : Error< "prefix attribute must be followed by an interface or protocol">; +def err_objc_postfix_attribute : Error < + "postfix attributes are not allowed on Objective-C directives">; +def err_objc_postfix_attribute_hint : Error < + "postfix attributes are not allowed on Objective-C directives, place" + " them in front of '%select{@interface|@protocol}0'">; def err_objc_directive_only_in_protocol : Error< "directive may only be specified in protocols only">; def err_missing_catch_finally : Error< @@ -407,6 +411,8 @@ def err_missing_catch_finally : Error< def err_objc_concat_string : Error<"unexpected token after Objective-C string">; def err_expected_objc_container : Error< "'@end' must appear in an Objective-C context">; +def err_objc_unexpected_atend : Error< + "'@end' appears where closing brace '}' is expected">; def error_property_ivar_decl : Error< "property synthesize requires specification of an ivar">; def err_synthesized_property_name : Error< @@ -425,6 +431,8 @@ def err_declaration_does_not_declare_param : Error< def err_no_matching_param : Error<"parameter named %0 is missing">; /// C++ parser diagnostics +def err_invalid_operator_on_type : Error< + "cannot use %select{dot|arrow}0 operator on a type">; def err_expected_unqualified_id : Error< "expected %select{identifier|unqualified-id}0">; def err_func_def_no_params : Error< @@ -464,11 +472,16 @@ def err_destructor_template_id : Error< "destructor name %0 does not refer to a template">; def err_default_arg_unparsed : Error< "unexpected end of default argument expression">; -def err_parser_impl_limit_overflow : Error< - "parser recursion limit reached, program too complex">, DefaultFatal; +def err_bracket_depth_exceeded : Error< + "bracket nesting level exceeded maximum of %0">, DefaultFatal; +def note_bracket_depth : Note< + "use -fbracket-depth=N to increase maximum nesting level">; def err_misplaced_ellipsis_in_declaration : Error< "'...' must %select{immediately precede declared identifier|" "be innermost component of anonymous pack declaration}0">; +def ext_abstract_pack_declarator_parens : ExtWarn< + "ISO C++11 requires a parenthesized pack declaration to have a name">, + InGroup<DiagGroup<"anonymous-pack-parens">>; // C++ derived classes def err_dup_virtual : Error<"duplicate 'virtual' in base specifier">; @@ -504,12 +517,12 @@ def err_cxx11_attribute_forbids_arguments : Error< "attribute '%0' cannot have an argument list">; def err_cxx11_attribute_forbids_ellipsis : Error< "attribute '%0' cannot be used as an attribute pack">; +def err_cxx11_attribute_repeated : Error< + "attribute %0 cannot appear multiple times in an attribute specifier">; def err_attributes_not_allowed : Error<"an attribute list cannot appear here">; def err_l_square_l_square_not_attribute : Error< "C++11 only allows consecutive left square brackets when " "introducing an attribute">; -def err_alignas_pack_exp_unsupported : Error< - "pack expansions in alignment specifiers are not supported yet">; def err_ms_declspec_type : Error< "__declspec attributes must be an identifier or string literal">; def warn_ms_declspec_unknown : Warning< @@ -548,7 +561,6 @@ def err_explicit_instantiation_with_definition : Error< "explicit template instantiation cannot have a definition; if this " "definition is meant to be an explicit specialization, add '<>' after the " "'template' keyword">; -def err_enum_template : Error<"enumeration cannot be a template">; def err_explicit_instantiation_enum : Error< "enumerations cannot be explicitly instantiated">; def err_expected_template_parameter : Error<"expected template parameter">; @@ -764,14 +776,25 @@ def err_seh___except_filter : Error< def err_seh___finally_block : Error< "%0 only allowed in __finally block">; - + +// OpenMP support. +def warn_pragma_omp_ignored : Warning < + "unexpected '#pragma omp ...' in program">, InGroup<SourceUsesOpenMP>, DefaultIgnore; +def warn_omp_extra_tokens_at_eol : Warning < + "extra tokens at end of '#pragma omp %0' are ignored">, + InGroup<ExtraTokens>; +def err_omp_unknown_directive : Error < + "expected an OpenMP directive">; +def err_omp_unexpected_directive : Error < + "unexpected OpenMP directive '#pragma omp %0'">; + } // end of Parse Issue category. let CategoryName = "Modules Issue" in { def err_module_expected_ident : Error< "expected a module name after module import">; def err_module_expected_semi : Error< - "expected a semicolon name after module name">; + "expected ';' after module name">; } } // end of Parser diagnostics diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 0d64bf3..c4815cd 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -20,6 +20,11 @@ def warn_variables_not_in_loop_body : Warning< "used in loop condition not modified in loop body">, InGroup<DiagGroup<"loop-analysis">>, DefaultIgnore; +def warn_duplicate_enum_values : Warning< + "element %0 has been implicitly assigned %1 which another element has " + "been assigned">, InGroup<DiagGroup<"duplicate-enum">>, DefaultIgnore; +def note_duplicate_element : Note<"element %0 also has value %1">; + // Constant expressions def err_expr_not_ice : Error< "expression is not an %select{integer|integral}0 constant expression">; @@ -70,7 +75,9 @@ def warn_double_const_requires_fp64 : Warning< // C99 variable-length arrays def ext_vla : Extension<"variable length arrays are a C99 feature">, - InGroup<VLA>; + InGroup<VLAExtension>; +def warn_vla_used : Warning<"variable length array used">, + InGroup<VLA>, DefaultIgnore; def err_vla_non_pod : Error<"variable length array of non-POD element type %0">; def err_vla_in_sfinae : Error< "variable length array cannot be formed during template argument deduction">; @@ -209,6 +216,8 @@ def warn_use_out_of_scope_declaration : Warning< "use of out-of-scope declaration of %0">; def err_inline_non_function : Error< "'inline' can only appear on functions">; +def err_noreturn_non_function : Error< + "'_Noreturn' can only appear on functions">; def warn_qual_return_type : Warning< "'%0' type qualifier%s1 on return type %plural{1:has|:have}1 no effect">, InGroup<IgnoredQualifiers>, DefaultIgnore; @@ -245,19 +254,20 @@ def note_using_decl_constructor_conflict_previous_ctor : Note< "previous constructor">; def note_using_decl_constructor_conflict_previous_using : Note< "previously inherited here">; +def warn_using_decl_constructor_ellipsis : Warning< + "inheriting constructor does not inherit ellipsis">, + InGroup<DiagGroup<"inherited-variadic-ctor">>; +def note_using_decl_constructor_ellipsis : Note< + "constructor declared with ellipsis here">; def err_using_decl_can_not_refer_to_class_member : Error< "using declaration can not refer to class member">; def err_using_decl_can_not_refer_to_namespace : Error< "using declaration can not refer to namespace">; def err_using_decl_constructor : Error< "using declaration can not refer to a constructor">; -def err_using_decl_constructor_unsupported : Error< - "inheriting constructors are not supported">; -// FIXME: Replace the above error with this warning if support for -// inheriting constructors is implemented. -//def warn_cxx98_compat_using_decl_constructor : Warning< -// "inheriting constructors are incompatible with C++98">, -// InGroup<CXX98Compat>, DefaultIgnore; +def warn_cxx98_compat_using_decl_constructor : Warning< + "inheriting constructors are incompatible with C++98">, + InGroup<CXX98Compat>, DefaultIgnore; def err_using_decl_destructor : Error< "using declaration can not refer to a destructor">; def err_using_decl_template_id : Error< @@ -304,10 +314,10 @@ def err_falloff_nonvoid_block : Error< "control reaches end of non-void block">; def warn_suggest_noreturn_function : Warning< "%select{function|method}0 %1 could be declared with attribute 'noreturn'">, - InGroup<DiagGroup<"missing-noreturn">>, DefaultIgnore; + InGroup<MissingNoreturn>, DefaultIgnore; def warn_suggest_noreturn_block : Warning< "block could be declared with attribute 'noreturn'">, - InGroup<DiagGroup<"missing-noreturn">>, DefaultIgnore; + InGroup<MissingNoreturn>, DefaultIgnore; def warn_unreachable : Warning<"will never be executed">, InGroup<DiagGroup<"unreachable-code">>, DefaultIgnore; @@ -331,7 +341,8 @@ def warn_implicit_decl_requires_ucontext : Warning< "<ucontext.h>">, InGroup<BuiltinRequiresHeader>; def warn_redecl_library_builtin : Warning< - "incompatible redeclaration of library function %0">; + "incompatible redeclaration of library function %0">, + InGroup<DiagGroup<"incompatible-library-redeclaration">>; def err_builtin_definition : Error<"definition of builtin function %0">; def err_types_compatible_p_in_cplusplus : Error< "__builtin_types_compatible_p is not valid in C++">; @@ -347,7 +358,7 @@ def note_bad_memaccess_silence : Note< def warn_sizeof_pointer_expr_memaccess : Warning< "'%0' call operates on objects of type %1 while the size is based on a " "different type %2">, - InGroup<DiagGroup<"sizeof-pointer-memaccess">>; + InGroup<SizeofPointerMemaccess>; def warn_sizeof_pointer_expr_memaccess_note : Note< "did you mean to %select{dereference the argument to 'sizeof' (and multiply " "it by the number of elements)|remove the addressof in the argument to " @@ -356,7 +367,7 @@ def warn_sizeof_pointer_expr_memaccess_note : Note< def warn_sizeof_pointer_type_memaccess : Warning< "argument to 'sizeof' in %0 call is the same pointer type %1 as the " "%select{destination|source}2; expected %3 or an explicit length">, - InGroup<DiagGroup<"sizeof-pointer-memaccess">>; + InGroup<SizeofPointerMemaccess>; def warn_strlcpycat_wrong_size : Warning< "size argument in %0 call appears to be size of the source; expected the size of " "the destination">, @@ -376,17 +387,21 @@ def note_strncat_wrong_size : Note< "the terminating null byte">; /// main() -// static/inline main() are not errors in C, just in C++. +// static main() is not an error in C, just in C++. def warn_static_main : Warning<"'main' should not be declared static">, InGroup<Main>; def err_static_main : Error<"'main' is not allowed to be declared static">; def err_inline_main : Error<"'main' is not allowed to be declared inline">; +def ext_noreturn_main : ExtWarn< + "'main' is not allowed to be declared _Noreturn">, InGroup<Main>; +def note_main_remove_noreturn : Note<"remove '_Noreturn'">; def err_constexpr_main : Error< "'main' is not allowed to be declared constexpr">; def err_main_template_decl : Error<"'main' cannot be a template">; def err_main_returns_nonint : Error<"'main' must return 'int'">; def ext_main_returns_nonint : ExtWarn<"return type of 'main' is not 'int'">, InGroup<MainReturnType>; +def note_main_change_return_type : Note<"change return type to 'int'">; def err_main_surplus_args : Error<"too many parameters (%0) for 'main': " "must be 0, 2, or 3">; def warn_main_one_arg : Warning<"only one parameter on 'main' declaration">, @@ -396,6 +411,8 @@ def err_main_arg_wrong : Error<"%select{first|second|third|fourth}0 " "platform-specific data}0) must be of type %1">; /// parser diagnostics +def ext_no_declarators : ExtWarn<"declaration does not declare anything">, + InGroup<MissingDeclarations>; def ext_typedef_without_a_name : ExtWarn<"typedef requires a name">, InGroup<MissingDeclarations>; def err_typedef_not_identifier : Error<"typedef name must be an identifier">; @@ -406,6 +423,15 @@ def err_object_cannot_be_passed_returned_by_value : Error< "; did you forget * in %1?">; def err_parameters_retval_cannot_have_fp16_type : Error< "%select{parameters|function return value}0 cannot have __fp16 type; did you forget * ?">; +def err_opencl_half_load_store : Error< + "%select{loading directly from|assigning directly to}0 pointer to type %1 is not allowed">; +def err_opencl_cast_to_half : Error<"casting to type %0 is not allowed">; +def err_opencl_half_declaration : Error< + "declaring variable of type %0 is not allowed">; +def err_opencl_half_argument : Error< + "declaring function argument of type %0 is not allowed; did you forget * ?">; +def err_opencl_half_return : Error< + "declaring function return value of type %0 is not allowed; did you forget * ?">; def warn_enum_value_overflow : Warning<"overflow in enumeration value">; def warn_pragma_options_align_reset_failed : Warning< "#pragma options align=reset failed: %0">; @@ -456,7 +482,7 @@ def warn_readonly_property : Warning< "'readwrite' of property inherited from %1">; def warn_property_attribute : Warning< - "property %0 '%1' attribute does not match the property inherited from %2">; + "'%1' attribute on property %0 does not match the property inherited from %2">; def warn_property_types_are_incompatible : Warning< "property type %0 is incompatible with type %1 inherited from %2">; def err_undef_interface : Error<"cannot find interface declaration for %0">; @@ -499,9 +525,8 @@ def err_conflicting_ivar_name : Error< "conflicting instance variable names: %0 vs %1">; def err_inconsistant_ivar_count : Error< "inconsistent number of instance variables specified">; -def warn_incomplete_impl : Warning<"incomplete implementation">, +def warn_undef_method_impl : Warning<"method definition for %0 not found">, InGroup<DiagGroup<"incomplete-implementation">>; -def note_undef_method_impl : Note<"method definition for %0 not found">; def note_required_for_protocol_at : Note<"required for direct or indirect protocol %0">; @@ -523,7 +548,7 @@ def warn_conflicting_overriding_ret_type_modifiers : Warning< def warn_conflicting_ret_type_modifiers : Warning< "conflicting distributed object modifiers on return type " "in implementation of %0">, - InGroup<DiagGroup<"distributed-object-modifiers">>; + InGroup<DistributedObjectModifiers>; def warn_non_covariant_overriding_ret_types : Warning< "conflicting return type in " @@ -533,7 +558,7 @@ def warn_non_covariant_overriding_ret_types : Warning< def warn_non_covariant_ret_types : Warning< "conflicting return type in " "implementation of %0: %1 vs %2">, - InGroup<DiagGroup<"method-signatures">>, DefaultIgnore; + InGroup<MethodSignatures>, DefaultIgnore; def warn_conflicting_overriding_param_types : Warning< "conflicting parameter types in " @@ -548,7 +573,7 @@ def warn_conflicting_param_types : Warning< def warn_conflicting_param_modifiers : Warning< "conflicting distributed object modifiers on parameter type " "in implementation of %0">, - InGroup<DiagGroup<"distributed-object-modifiers">>; + InGroup<DistributedObjectModifiers>; def warn_conflicting_overriding_param_modifiers : Warning< "conflicting distributed object modifiers on parameter type " @@ -563,7 +588,7 @@ def warn_non_contravariant_overriding_param_types : Warning< def warn_non_contravariant_param_types : Warning< "conflicting parameter types in " "implementation of %0: %1 vs %2">, - InGroup<DiagGroup<"method-signatures">>, DefaultIgnore; + InGroup<MethodSignatures>, DefaultIgnore; def warn_conflicting_overriding_variadic :Warning< "conflicting variadic declaration of method and its " @@ -609,9 +634,11 @@ def warn_objc_property_no_assignment_attribute : Warning< "'assign' is assumed">, InGroup<ObjCPropertyNoAttribute>; def warn_objc_isa_use : Warning< - "direct access to objective-c's isa is deprecated " - "in favor of object_setClass() and object_getClass()">, - InGroup<DiagGroup<"deprecated-objc-isa-usage">>; + "direct access to Objective-C's isa is deprecated in favor of " + "object_getClass()">, InGroup<DeprecatedObjCIsaUsage>; +def warn_objc_isa_assign : Warning< + "assignment to Objective-C's isa is deprecated in favor of " + "object_setClass()">, InGroup<DeprecatedObjCIsaUsage>; def warn_objc_property_default_assign_on_object : Warning< "default property attribute 'assign' not appropriate for non-GC object">, InGroup<ObjCPropertyNoAttribute>; @@ -643,6 +670,15 @@ def warn_auto_synthesizing_protocol_property :Warning< "auto property synthesis will not synthesize property" " declared in a protocol">, InGroup<DiagGroup<"objc-protocol-property-synthesis">>; +def warn_no_autosynthesis_shared_ivar_property : Warning < + "auto property synthesis will not synthesize property " + "'%0' because it cannot share an ivar with another synthesized property">, + InGroup<ObjCNoPropertyAutoSynthesis>; +def warn_no_autosynthesis_property : Warning< + "auto property synthesis will not synthesize property " + "'%0' because it is 'readwrite' but it will be synthesized 'readonly' " + "via another property">, + InGroup<ObjCNoPropertyAutoSynthesis>; def warn_autosynthesis_property_ivar_match :Warning< "autosynthesized property %0 will use %select{|synthesized}1 instance variable " "%2, not existing instance variable %3">, @@ -684,6 +720,8 @@ def error_category_property : Error< "class implementation">; def note_property_declare : Note< "property declared here">; +def note_property_synthesize : Note< + "property synthesized here">; def error_synthesize_category_decl : Error< "@synthesize not allowed in a category's implementation">; def error_reference_property : Error< @@ -762,9 +800,9 @@ def warn_undeclared_selector : Warning< def warn_implicit_atomic_property : Warning< "property is assumed atomic by default">, InGroup<ImplicitAtomic>, DefaultIgnore; def note_auto_readonly_iboutlet_fixup_suggest : Note< - "readonly IBOutlet property should be changed to be readwrite">; + "property should be changed to be readwrite">; def warn_auto_readonly_iboutlet_property : Warning< - "readonly IBOutlet property when auto-synthesized may " + "readonly IBOutlet property '%0' when auto-synthesized may " "not work correctly with 'nib' loader">, InGroup<DiagGroup<"readonly-iboutlet-property">>; def warn_auto_implicit_atomic_property : Warning< @@ -829,6 +867,8 @@ def err_friend_def_in_local_class : Error< "friend function cannot be defined in a local class">; def err_friend_not_first_in_declaration : Error< "'friend' must appear first in a non-function declaration">; +def err_using_decl_friend : Error< + "cannot befriend target of using declaration">; def err_invalid_member_in_interface : Error< "%select{data member |non-public member function |static member function |" @@ -892,6 +932,8 @@ def err_distant_exception_spec : Error< def err_incomplete_in_exception_spec : Error< "%select{|pointer to |reference to }0incomplete type %1 is not allowed " "in exception specification">; +def err_rref_in_exception_spec : Error< + "rvalue reference type %0 is not allowed in exception specification">; def err_mismatched_exception_spec : Error< "exception specification in declaration does not match previous declaration">; def warn_mismatched_exception_spec : ExtWarn< @@ -1063,14 +1105,18 @@ def note_field_decl : Note<"member is declared here">; def note_ivar_decl : Note<"instance variable is declared here">; def note_bitfield_decl : Note<"bit-field is declared here">; def note_previous_decl : Note<"%0 declared here">; +def note_implicit_param_decl : Note<"%0 is an implicit parameter">; def note_member_synthesized_at : Note< "implicit default %select{constructor|copy constructor|move constructor|copy " "assignment operator|move assignment operator|destructor}0 for %1 first " "required here">; +def note_inhctor_synthesized_at : Note< + "inheriting constructor for %0 first required here">; def err_missing_default_ctor : Error< - "%select{|implicit default }0constructor for %1 must explicitly initialize " - "the %select{base class|member}2 %3 which does not have a default " + "%select{|implicit default |inheriting }0constructor for %1 must explicitly " + "initialize the %select{base class|member}2 %3 which does not have a default " "constructor">; + def err_illegal_union_or_anon_struct_member : Error< "%select{anonymous struct|union}0 member %1 has a non-trivial " "%select{constructor|copy constructor|move constructor|copy assignment " @@ -1080,16 +1126,38 @@ def warn_cxx98_compat_nontrivial_union_or_anon_struct_member : Warning< "%select{constructor|copy constructor|move constructor|copy assignment " "operator|move assignment operator|destructor}2 is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; + +def note_nontrivial_virtual_dtor : Note< + "destructor for %0 is not trivial because it is virtual">; def note_nontrivial_has_virtual : Note< "because type %0 has a virtual %select{member function|base class}1">; -def note_nontrivial_has_nontrivial : Note< - "because type %0 has a %select{member|base class}1 with a non-trivial " - "%select{constructor|copy constructor|move constructor|copy assignment " - "operator|move assignment operator|destructor}2">; -def note_nontrivial_user_defined : Note< - "because type %0 has a user-declared %select{constructor|copy constructor|" - "move constructor|copy assignment operator|move assignment operator|" - "destructor}1">; +def note_nontrivial_no_def_ctor : Note< + "because %select{base class of |field of |}0type %1 has no " + "default constructor">; +def note_user_declared_ctor : Note< + "implicit default constructor suppressed by user-declared constructor">; +def note_nontrivial_no_copy : Note< + "because no %select{<<ERROR>>|constructor|constructor|assignment operator|" + "assignment operator|<<ERROR>>}2 can be used to " + "%select{<<ERROR>>|copy|move|copy|move|<<ERROR>>}2 " + "%select{base class|field|an object}0 of type %3">; +def note_nontrivial_user_provided : Note< + "because %select{base class of |field of |}0type %1 has a user-provided " + "%select{default constructor|copy constructor|move constructor|" + "copy assignment operator|move assignment operator|destructor}2">; +def note_nontrivial_in_class_init : Note< + "because field %0 has an initializer">; +def note_nontrivial_param_type : Note< + "because its parameter is %diff{of type $, not $|of the wrong type}2,3">; +def note_nontrivial_default_arg : Note<"because it has a default argument">; +def note_nontrivial_variadic : Note<"because it is a variadic function">; +def note_nontrivial_subobject : Note< + "because the function selected to %select{construct|copy|move|copy|move|" + "destroy}2 %select{base class|field}0 of type %1 is not trivial">; +def note_nontrivial_objc_ownership : Note< + "because type %0 has a member with %select{no|no|__strong|__weak|" + "__autoreleasing}1 ownership">; + def err_static_data_member_not_allowed_in_anon_struct : Error< "static data member %0 not allowed in anonymous struct">; def ext_static_data_member_in_union : ExtWarn< @@ -1100,14 +1168,17 @@ def warn_cxx98_compat_static_data_member_in_union : Warning< def err_union_member_of_reference_type : Error< "union member %0 has reference type %1">; def ext_anonymous_struct_union_qualified : Extension< - "anonymous %select{struct|union}0 cannot be '%select{const|volatile|" - "restrict}1'">; + "anonymous %select{struct|union}0 cannot be '%1'">; def err_different_return_type_for_overriding_virtual_function : Error< "virtual function %0 has a different return type " "%diff{($) than the function it overrides (which has return type $)|" "than the function it overrides}1,2">; def note_overridden_virtual_function : Note< "overridden virtual function is here">; +def err_conflicting_overriding_cc_attributes : Error< + "virtual function %0 has different calling convention attributes " + "%diff{($) than the function it overrides (which has calling convention $)|" + "than the function it overrides}1,2">; def err_covariant_return_inaccessible_base : Error< "invalid covariant return for virtual function: %1 is a " @@ -1236,6 +1307,8 @@ def err_reference_var_requires_init : Error< "declaration of reference variable %0 requires an initializer">; def err_reference_without_init : Error< "reference to type %0 requires an initializer">; +def note_value_initialization_here : Note< + "in value-initialization of type %0 here">; def err_reference_has_multiple_inits : Error< "reference cannot be initialized with multiple values">; def err_init_non_aggr_init_list : Error< @@ -1249,6 +1322,9 @@ def warn_field_is_uninit : Warning<"field %0 is uninitialized when used here">, def warn_reference_field_is_uninit : Warning< "reference %0 is not yet bound to a value when used here">, InGroup<Uninitialized>; +def warn_static_self_reference_in_init : Warning< + "static variable %0 is suspiciously used within its own initialization">, + InGroup<UninitializedStaticSelfInit>; def warn_uninit_self_reference_in_init : Warning< "variable %0 is uninitialized when used within its own initialization">, InGroup<Uninitialized>; @@ -1284,6 +1360,11 @@ def note_uninit_fixit_remove_cond : Note< "is always %select{false|true}2">; def err_init_incomplete_type : Error<"initialization of incomplete type %0">; +def warn_unsequenced_mod_mod : Warning< + "multiple unsequenced modifications to %0">, InGroup<Unsequenced>; +def warn_unsequenced_mod_use : Warning< + "unsequenced modification and access to %0">, InGroup<Unsequenced>; + def err_temp_copy_no_viable : Error< "no viable constructor %select{copying variable|copying parameter|" "returning object|throwing object|copying member subobject|copying array " @@ -1469,6 +1550,8 @@ def warn_cxx98_compat_constexpr : Warning< def err_invalid_constexpr : Error< "%select{function parameter|typedef|non-static data member}0 " "cannot be constexpr">; +def err_invalid_constexpr_member : Error<"non-static data member cannot be " + "constexpr%select{; did you intend to make it %select{const|static}0?|}1">; def err_constexpr_tag : Error< "%select{class|struct|interface|union|enum}0 cannot be marked constexpr">; def err_constexpr_dtor : Error<"destructor cannot be marked constexpr">; @@ -1509,7 +1592,7 @@ def err_constexpr_vla : Error< "%select{function|constructor}1">; def err_constexpr_var_declaration : Error< "variables cannot be declared in a constexpr %select{function|constructor}0">; -def err_constexpr_function_never_constant_expr : ExtWarn< +def ext_constexpr_function_never_constant_expr : ExtWarn< "constexpr %select{function|constructor}0 never produces a " "constant expression">, InGroup<DiagGroup<"invalid-constexpr">>, DefaultError; def err_constexpr_body_no_return : Error< @@ -1584,8 +1667,19 @@ def err_attribute_argument_not_int : Error< "'%0' attribute requires integer constant">; def err_aligned_attribute_argument_not_int : Error< "'aligned' attribute requires integer constant">; -def err_attribute_argument_not_class : Error< - "%0 attribute requires arguments that are class type or point to class type">; +def err_alignas_attribute_wrong_decl_type : Error< + "'%select{alignas|_Alignas}0' attribute cannot be applied to a %select{" + "function parameter|variable with 'register' storage class|" + "'catch' variable|bit-field}1">; +def err_alignas_missing_on_definition : Error< + "'%select{alignas|_Alignas}0' must be specified on definition if it is " + "specified on any declaration">; +def note_alignas_on_declaration : Note< + "declared with '%select{alignas|_Alignas}0' attribute here">; +def err_alignas_mismatch : Error< + "redeclaration has different alignment requirement (%1 vs %0)">; +def err_alignas_underaligned : Error< + "requested alignment is less than minimum alignment of %1 for type %0">; def err_attribute_first_argument_not_int_or_bool : Error< "%0 attribute first argument must be of int or bool type">; def err_attribute_argument_outof_range : Error< @@ -1594,6 +1688,8 @@ def err_attribute_argument_outof_range : Error< def err_init_priority_object_attr : Error< "can only use 'init_priority' attribute on file-scope definitions " "of objects of class type">; +def err_attribute_argument_vec_type_hint : Error< + "invalid attribute argument %0 - expecting a vector or vectorizable scalar type">; def err_attribute_argument_n_not_int : Error< "'%0' attribute requires parameter %1 to be an integer constant">; def err_attribute_argument_n_not_string : Error< @@ -1651,6 +1747,8 @@ def err_as_qualified_auto_decl : Error< "automatic variable qualified with an address space">; def err_arg_with_address_space : Error< "parameter may not be qualified with an address space">; +def err_field_with_address_space : Error< + "field may not be qualified with an address space">; def err_attr_objc_ownership_redundant : Error< "the type %0 is already explicitly ownership-qualified">; def err_attribute_not_string : Error< @@ -1725,12 +1823,14 @@ def warn_attribute_after_definition_ignored : Warning< InGroup<IgnoredAttributes>; def warn_unknown_attribute_ignored : Warning< "unknown attribute %0 ignored">, InGroup<UnknownAttributes>; +def warn_cxx11_gnu_attribute_on_type : Warning< + "attribute %0 ignored, because it cannot be applied to a type">, + InGroup<IgnoredAttributes>; def warn_unhandled_ms_attribute_ignored : Warning< "__declspec attribute %0 is not supported">, InGroup<IgnoredAttributes>; -def warn_attribute_invalid_on_stmt : Warning< - "attribute %0 cannot be specified on a statement">, - InGroup<IgnoredAttributes>; +def err_attribute_invalid_on_stmt : Error< + "%0 attribute cannot be applied to a statement">; def warn_declspec_attribute_ignored : Warning< "attribute %0 is ignored, place it after " "\"%select{class|struct|union|interface|enum}1\" to apply attribute to " @@ -1773,17 +1873,22 @@ def err_alias_not_supported_on_darwin : Error < def warn_attribute_wrong_decl_type : Warning< "%0 attribute only applies to %select{functions|unions|" "variables and functions|functions and methods|parameters|" - "functions, methods and blocks|functions, methods, and parameters|" - "classes|variables|methods|variables, functions and labels|" - "fields and global variables|structs|" - "variables, functions and tag types|thread-local variables}1">, + "functions, methods and blocks|functions, methods, and classes|" + "functions, methods, and parameters|classes|variables|methods|" + "variables, functions and labels|fields and global variables|structs|" + "variables, functions and tag types|thread-local variables|" + "variables and fields|variables, data members and tag types|" + "types and namespaces}1">, InGroup<IgnoredAttributes>; def err_attribute_wrong_decl_type : Error< "%0 attribute only applies to %select{functions|unions|" "variables and functions|functions and methods|parameters|" - "functions, methods and blocks|functions, methods, and parameters|" - "classes|variables|methods|variables, functions and labels|" - "fields and global variables|structs|thread-local variables}1">; + "functions, methods and blocks|functions, methods, and classes|" + "functions, methods, and parameters|classes|variables|methods|" + "variables, functions and labels|fields and global variables|structs|" + "variables, functions and tag types|thread-local variables|" + "variables and fields|variables, data members and tag types|" + "types and namespaces}1">; def warn_function_attribute_wrong_type : Warning< "'%0' only applies to function types; type here is %1">, InGroup<IgnoredAttributes>; @@ -1813,7 +1918,7 @@ def err_cconv_knr : Error< "function with no prototype cannot use %0 calling convention">; def err_cconv_varargs : Error< "variadic function cannot use %0 calling convention">; -def err_regparm_mismatch : Error<"function declared with with regparm(%0) " +def err_regparm_mismatch : Error<"function declared with regparm(%0) " "attribute was previously declared " "%plural{0:without the regparm|:with the regparm(%1)}1 attribute">; def err_returns_retained_mismatch : Error< @@ -1824,11 +1929,13 @@ def err_objc_precise_lifetime_bad_type : Error< def warn_objc_precise_lifetime_meaningless : Error< "objc_precise_lifetime is not meaningful for " "%select{__unsafe_unretained|__autoreleasing}0 objects">; -def err_invalid_pcs : Error<"Invalid PCS type">; +def err_invalid_pcs : Error<"invalid PCS type">; def err_attribute_can_be_applied_only_to_value_decl : Error< "%0 attribute can only be applied to value declarations">; -def warn_attribute_not_on_decl : Error< - "%0 attribute ignored when parsing type">; +def warn_attribute_not_on_decl : Warning< + "%0 attribute ignored when parsing type">, InGroup<IgnoredAttributes>; +def err_base_specifier_attribute : Error< + "%0 attribute cannot be applied to a base specifier">; // Availability attribute def warn_availability_unknown_platform : Warning< @@ -1839,6 +1946,16 @@ def warn_availability_version_ordering : Warning< "attribute ignored">, InGroup<Availability>; def warn_mismatched_availability: Warning< "availability does not match previous declaration">, InGroup<Availability>; +def warn_mismatched_availability_override : Warning< + "overriding method %select{introduced after|" + "deprecated before|obsoleted before}0 overridden method on %1 (%2 vs. %3)">, + InGroup<Availability>; +def warn_mismatched_availability_override_unavail : Warning< + "overriding method cannot be unavailable on %0 when its overridden method is " + "available">, + InGroup<Availability>; +def note_overridden_method : Note< + "overridden method is here">; // Thread Safety Attributes def warn_thread_attribute_ignored : Warning< @@ -1938,18 +2055,22 @@ def warn_fun_requires_lock_precise : Warning< InGroup<ThreadSafetyPrecise>, DefaultIgnore; def note_found_mutex_near_match : Note<"found near match '%0'">; +// Dummy warning that will trigger "beta" warnings from the analysis if enabled. +def warn_thread_safety_beta : Warning< + "Thread safety beta warning.">, InGroup<ThreadSafetyBeta>, DefaultIgnore; + def warn_impcast_vector_scalar : Warning< "implicit conversion turns vector to scalar: %0 to %1">, - InGroup<DiagGroup<"conversion">>, DefaultIgnore; + InGroup<Conversion>, DefaultIgnore; def warn_impcast_complex_scalar : Warning< "implicit conversion discards imaginary component: %0 to %1">, - InGroup<DiagGroup<"conversion">>, DefaultIgnore; + InGroup<Conversion>, DefaultIgnore; def warn_impcast_float_precision : Warning< "implicit conversion loses floating-point precision: %0 to %1">, - InGroup<DiagGroup<"conversion">>, DefaultIgnore; + InGroup<Conversion>, DefaultIgnore; def warn_impcast_float_integer : Warning< "implicit conversion turns floating-point number into integer: %0 to %1">, - InGroup<DiagGroup<"conversion">>, DefaultIgnore; + InGroup<Conversion>, DefaultIgnore; def warn_impcast_integer_sign : Warning< "implicit conversion changes signedness: %0 to %1">, InGroup<SignConversion>, DefaultIgnore; @@ -1958,7 +2079,7 @@ def warn_impcast_integer_sign_conditional : Warning< InGroup<SignConversion>, DefaultIgnore; def warn_impcast_integer_precision : Warning< "implicit conversion loses integer precision: %0 to %1">, - InGroup<DiagGroup<"conversion">>, DefaultIgnore; + InGroup<Conversion>, DefaultIgnore; def warn_impcast_integer_64_32 : Warning< "implicit conversion loses integer precision: %0 to %1">, InGroup<Shorten64To32>, DefaultIgnore; @@ -2036,6 +2157,8 @@ def warn_attribute_protected_visibility : Warning<"target does not support 'protected' visibility; using 'default'">, InGroup<DiagGroup<"unsupported-visibility">>; def err_mismatched_visibility: Error<"visibility does not match previous declaration">; +def warn_attribute_unknown_endian : Warning<"unknown endian '%0'">, + InGroup<IgnoredAttributes>; def note_previous_attribute : Note<"previous attribute is here">; def err_unknown_machine_mode : Error<"unknown machine mode %0">; def err_unsupported_machine_mode : Error<"unsupported machine mode %0">; @@ -2158,15 +2281,11 @@ def err_uninitialized_member_for_assign : Error< "non-static %select{reference|const}1 member %2 can't use default " "assignment operator">; def err_uninitialized_member_in_ctor : Error< - "%select{|implicit default }0constructor for %1 must explicitly initialize " - "the %select{reference|const}2 member %3">; -def warn_default_arg_makes_ctor_special : Warning< + "%select{|implicit default |inheriting }0constructor for %1 must explicitly " + "initialize the %select{reference|const}2 member %3">; +def err_default_arg_makes_ctor_special : Error< "addition of default argument on redeclaration makes this constructor a " - "%select{default|copy|move}0 constructor">, InGroup<DefaultArgSpecialMember>; -def note_previous_declaration_special : Note< - // The ERRORs are in hopes that if they occur, they'll get reported. - "previous declaration was %select{*ERROR*|a copy constructor|a move " - "constructor|*ERROR*|*ERROR*|*ERROR*|not a special member function}0">; + "%select{default|copy|move}0 constructor">; def err_use_of_default_argument_to_function_declared_later : Error< "use of default argument to function %0 that is declared later in class %1">; @@ -2246,6 +2365,11 @@ def note_ovl_candidate_substitution_failure : Note< "candidate template ignored: substitution failure%0%1">; def note_ovl_candidate_disabled_by_enable_if : Note< "candidate template ignored: disabled by %0%1">; +def note_ovl_candidate_failed_overload_resolution : Note< + "candidate template ignored: couldn't resolve reference to overloaded " + "function %0">; +def note_ovl_candidate_non_deduced_mismatch : Note< + "candidate template ignored: could not match %diff{$ against $|types}0,1">; // Note that we don't treat templates differently for this diagnostic. def note_ovl_candidate_arity : Note<"candidate " @@ -2473,9 +2597,10 @@ def err_ovl_no_viable_oper : Error<"no viable overloaded '%0'">; def err_ovl_deleted_oper : Error< "overload resolution selected %select{unavailable|deleted}0 operator '%1'%2">; def err_ovl_deleted_special_oper : Error< - "overload resolution selected implicitly-deleted %select{default constructor|" - "copy constructor|move constructor|copy assignment operator|move assignment " - "operator|destructor|'%1'}0%2">; + "object of type %0 cannot be %select{constructed|copied|moved|assigned|" + "assigned|destroyed}1 because its %select{default constructor|" + "copy constructor|move constructor|copy assignment operator|" + "move assignment operator|destructor}1 is implicitly deleted">; def err_ovl_no_viable_subscript : Error<"no viable overloaded operator[] for type %0">; def err_ovl_no_oper : @@ -2597,7 +2722,7 @@ def err_template_arg_must_be_type_suggest : Error< def err_template_arg_must_be_expr : Error< "template argument for non-type template parameter must be an expression">; def err_template_arg_nontype_ambig : Error< - "template argument for non-type template parameter is treated as type %0">; + "template argument for non-type template parameter is treated as function type %0">; def err_template_arg_must_be_template : Error< "template argument for template template parameter must be a class template%select{| or type alias template}0">; def ext_template_arg_local_type : ExtWarn< @@ -3021,9 +3146,9 @@ def warn_cxx98_compat_template_outside_of_template : Warning< InGroup<CXX98Compat>, DefaultIgnore; def err_non_type_template_in_nested_name_specifier : Error< - "qualified name refers into a specialization of function template '%0'">; + "qualified name refers into a specialization of function template %0">; def err_template_id_not_a_type : Error< - "template name refers to non-type template '%0'">; + "template name refers to non-type template %0">; def note_template_declared_here : Note< "%select{function template|class template|type alias template|template template parameter}0 " "%1 declared here">; @@ -3142,6 +3267,8 @@ def note_sentinel_here : Note< def warn_missing_prototype : Warning< "no previous prototype for function %0">, InGroup<DiagGroup<"missing-prototypes">>, DefaultIgnore; +def note_declaration_not_a_prototype : Note< + "this declaration is not a prototype; add 'void' to make it a prototype for a zero-parameter function">; def warn_missing_variable_declarations : Warning< "no previous extern declaration for non-static variable %0">, InGroup<DiagGroup<"missing-variable-declarations">>, DefaultIgnore; @@ -3189,18 +3316,23 @@ def note_deleted_assign_field : Note< "%select{copy|move}0 assignment operator of %1 is implicitly deleted " "because field %2 is of %select{reference|const-qualified}4 type %3">; -// This should eventually be an error. +// These should be errors. def warn_undefined_internal : Warning< "%select{function|variable}0 %q1 has internal linkage but is not defined">, - DiagGroup<"undefined-internal">; + InGroup<DiagGroup<"undefined-internal">>; +def warn_undefined_inline : Warning<"inline function %q0 is not defined">, + InGroup<DiagGroup<"undefined-inline">>; def note_used_here : Note<"used here">; def warn_internal_in_extern_inline : ExtWarn< "static %select{function|variable}0 %1 is used in an inline function with " - "external linkage">, InGroup<DiagGroup<"static-in-inline"> >; + "external linkage">, InGroup<StaticInInline>; def ext_internal_in_extern_inline : Extension< "static %select{function|variable}0 %1 is used in an inline function with " - "external linkage">, InGroup<DiagGroup<"static-in-inline"> >; + "external linkage">, InGroup<StaticInInline>; +def warn_static_local_in_extern_inline : Warning< + "non-constant static local variable in inline function may be different " + "in different files">, InGroup<StaticLocalInInline>; def note_convert_inline_to_static : Note< "use 'static' to give inline function %0 internal linkage">; def note_internal_decl_declared_here : Note< @@ -3216,6 +3348,8 @@ def err_inline_declaration_block_scope : Error< "inline declaration of %0 not allowed in block scope">; def err_static_non_static : Error< "static declaration of %0 follows non-static declaration">; +def err_different_language_linkage : Error< + "declaration of %0 has a different language linkage">; def warn_weak_import : Warning < "an already-declared variable is made a weak_import declaration %0">; def warn_static_non_static : ExtWarn< @@ -3304,7 +3438,7 @@ def err_array_too_large : Error< "array is too large (%0 elements)">; def warn_array_new_too_large : Warning<"array is too large (%0 elements)">, // FIXME PR11644: ", will throw std::bad_array_new_length at runtime" - InGroup<DiagGroup<"bad-array-new-length">>; + InGroup<BadArrayNewLength>; // -Wpadded, -Wpacked def warn_padded_struct_field : Warning< @@ -3324,7 +3458,7 @@ def warn_unnecessary_packed : Warning< def err_typecheck_negative_array_size : Error<"array size is negative">; def warn_typecheck_negative_array_new_size : Warning<"array size is negative">, // FIXME PR11644: ", will throw std::bad_array_new_length at runtime" - InGroup<DiagGroup<"bad-array-new-length">>; + InGroup<BadArrayNewLength>; def warn_typecheck_function_qualifiers : Warning< "qualifier on function type %0 has unspecified behavior">; def err_typecheck_invalid_restrict_not_pointer : Error< @@ -3339,7 +3473,7 @@ def err_typecheck_zero_array_size : Error< "zero-length arrays are not permitted in C++">; def warn_typecheck_zero_static_array_size : Warning< "'static' has no effect on zero-length arrays">, - InGroup<DiagGroup<"array-bounds">>; + InGroup<ArrayBounds>; def err_array_size_non_int : Error<"size of array has non-integer type %0">; def err_init_element_not_constant : Error< "initializer element is not a compile-time constant">; @@ -3610,8 +3744,9 @@ def err_arc_mismatched_cast : Error< " to %3 is disallowed with ARC">; def err_arc_nolifetime_behavior : Error< "explicit ownership qualifier on cast result has no effect">; -def err_arc_objc_object_in_struct : Error< - "ARC forbids %select{Objective-C objects|blocks}0 in structs or unions">; +def err_arc_objc_object_in_tag : Error< + "ARC forbids %select{Objective-C objects|blocks}0 in " + "%select{struct|interface|union|<<ERROR>>|enum}1">; def err_arc_objc_property_default_assign_on_object : Error< "ARC forbids synthesizing a property of an Objective-C object " "with unspecified ownership or storage attribute">; @@ -3653,6 +3788,11 @@ def warn_arc_retained_property_assign : Warning< "assigning retained object to unsafe property" "; object will be released after assignment">, InGroup<ARCUnsafeRetainedAssign>; +def warn_arc_literal_assign : Warning< + "assigning %select{array literal|dictionary literal|numeric literal|boxed expression|<should not happen>|block literal}0" + " to a weak %select{property|variable}1" + "; object will be released after assignment">, + InGroup<ARCUnsafeRetainedAssign>; def err_arc_new_array_without_ownership : Error< "'new' cannot allocate an array of %0 with no explicit ownership">; def err_arc_autoreleasing_var : Error< @@ -3691,6 +3831,10 @@ def err_arc_collection_forward : Error< def err_arc_multiple_method_decl : Error< "multiple methods named %0 found with mismatched result, " "parameter type or attributes">; +def warn_arc_lifetime_result_type : Warning< + "ARC %select{unused|__unsafe_unretained|__strong|__weak|__autoreleasing}0 " + "lifetime qualifier on return type is ignored">, + InGroup<IgnoredQualifiers>; let CategoryName = "ARC Retain Cycle" in { @@ -3703,9 +3847,6 @@ def note_arc_retain_cycle_owner : Note< } // end "ARC Retain Cycle" category -def note_nontrivial_objc_ownership : Note< - "because type %0 has %select{no|no|__strong|__weak|__autoreleasing}1 " - "ownership">; def warn_arc_object_memaccess : Warning< "%select{destination for|source of}0 this %1 call is a pointer to " "ownership-qualified type %2">, InGroup<ARCNonPodMemAccess>; @@ -3743,12 +3884,20 @@ def err_arc_cast_requires_bridge : Error< "requires a bridged cast">; def note_arc_bridge : Note< "use __bridge to convert directly (no change in ownership)">; +def note_arc_cstyle_bridge : Note< + "use __bridge with C-style cast to convert directly (no change in ownership)">; def note_arc_bridge_transfer : Note< "use %select{__bridge_transfer|CFBridgingRelease call}1 to transfer " "ownership of a +1 %0 into ARC">; +def note_arc_cstyle_bridge_transfer : Note< + "use __bridge_transfer with C-style cast to transfer " + "ownership of a +1 %0 into ARC">; def note_arc_bridge_retained : Note< "use %select{__bridge_retained|CFBridgingRetain call}1 to make an " "ARC object available as a +1 %0">; +def note_arc_cstyle_bridge_retained : Note< + "use __bridge_retained with C-style cast to make an " + "ARC object available as a +1 %0">; } // ARC Casting category @@ -3796,16 +3945,17 @@ def err_atomic_specifier_bad_type : Error< "%1 %select{||||||which is not trivially copyable}0">; // Expressions. -def ext_sizeof_function_type : Extension< - "invalid application of 'sizeof' to a function type">, InGroup<PointerArith>; -def ext_sizeof_void_type : Extension< - "invalid application of '%select{sizeof|__alignof|vec_step}0' to a void " +def ext_sizeof_alignof_function_type : Extension< + "invalid application of '%select{sizeof|alignof|vec_step}0' to a " + "function type">, InGroup<PointerArith>; +def ext_sizeof_alignof_void_type : Extension< + "invalid application of '%select{sizeof|alignof|vec_step}0' to a void " "type">, InGroup<PointerArith>; def err_sizeof_alignof_incomplete_type : Error< - "invalid application of '%select{sizeof|__alignof|vec_step}0' to an " + "invalid application of '%select{sizeof|alignof|vec_step}0' to an " "incomplete type %1">; def err_sizeof_alignof_bitfield : Error< - "invalid application of '%select{sizeof|__alignof}0' to bit-field">; + "invalid application of '%select{sizeof|alignof}0' to bit-field">; def err_vecstep_non_scalar_vector_type : Error< "'vec_step' requires built-in scalar or vector type, %0 invalid">; def err_offsetof_incomplete_type : Error< @@ -3888,6 +4038,10 @@ def warn_sizeof_array_param : Warning< "sizeof on array function parameter will return size of %0 instead of %1">, InGroup<SizeofArrayArgument>; +def warn_sizeof_array_decay : Warning< + "sizeof on pointer operation will return size of %0 instead of %1">, + InGroup<SizeofArrayDecay>; + def err_sizeof_nonfragile_interface : Error< "application of '%select{alignof|sizeof}1' to interface %0 is " "not supported on this architecture and platform">; @@ -3912,6 +4066,8 @@ def err_subscript_function_type : Error< "subscript of pointer to function type %0">; def err_subscript_incomplete_type : Error< "subscript of pointer to incomplete type %0">; +def err_dereference_incomplete_type : Error< + "dereference of pointer to incomplete type %0">; def ext_gnu_subscript_void_type : Extension< "subscript of a pointer to void is a GNU extension">, InGroup<PointerArith>; def err_typecheck_member_reference_struct_union : Error< @@ -4038,7 +4194,13 @@ def err_typecheck_sclass_fscope : Error< "illegal storage class on file-scoped variable">; def err_unsupported_global_register : Error< "global register variables are not supported">; -def warn_standalone_specifier : Warning<"'%0' ignored on this declaration">; +def warn_standalone_specifier : Warning<"'%0' ignored on this declaration">, + InGroup<MissingDeclarations>; +def ext_standalone_specifier : ExtWarn<"'%0' is not permitted on a declaration " + "of a type">, InGroup<MissingDeclarations>; +def err_standalone_class_nested_name_specifier : Error< + "forward declaration of %select{class|struct|interface|union|enum}0 cannot " + "have a nested name specifier">; def err_typecheck_sclass_func : Error<"illegal storage class on function">; def err_static_block_func : Error< "function declared in block scope cannot have 'static' storage class">; @@ -4052,12 +4214,14 @@ def err_invalid_form_pointer_member_function : Error< "cannot create a non-constant pointer to member function">; def err_parens_pointer_member_function : Error< "cannot parenthesize the name of a method when forming a member pointer">; +def err_typecheck_invalid_lvalue_addrof_addrof_function : Error< + "extra '&' taking address of overloaded function">; def err_typecheck_invalid_lvalue_addrof : Error< - "address expression must be an lvalue or a function designator">; -def ext_typecheck_addrof_class_temporary : ExtWarn< + "cannot take the address of an rvalue of type %0">; +def ext_typecheck_addrof_temporary : ExtWarn< "taking the address of a temporary object of type %0">, InGroup<DiagGroup<"address-of-temporary">>, DefaultError; -def err_typecheck_addrof_class_temporary : Error< +def err_typecheck_addrof_temporary : Error< "taking the address of a temporary object of type %0">; def err_typecheck_unary_expr : Error< "invalid argument type %0 to unary expression">; @@ -4070,7 +4234,7 @@ def note_indirection_through_null : Note< def warn_pointer_indirection_from_incompatible_type : Warning< "dereference of type %1 that was reinterpret_cast from type %0 has undefined " "behavior">, - InGroup<DiagGroup<"undefined-reinterpret-cast">>, DefaultIgnore; + InGroup<UndefinedReinterpretCast>, DefaultIgnore; def err_objc_object_assignment : Error< "cannot assign to class object (%0 invalid)">; @@ -4127,11 +4291,11 @@ def warn_comparison_of_mixed_enum_types : Warning< InGroup<DiagGroup<"enum-compare">>; def warn_null_in_arithmetic_operation : Warning< "use of NULL in arithmetic operation">, - InGroup<DiagGroup<"null-arithmetic">>; + InGroup<NullArithmetic>; def warn_null_in_comparison_operation : Warning< "comparison between NULL and non-pointer " "%select{(%1 and NULL)|(NULL and %1)}0">, - InGroup<DiagGroup<"null-arithmetic">>; + InGroup<NullArithmetic>; def err_invalid_this_use : Error< "invalid use of 'this' outside of a non-static member function">; @@ -4178,6 +4342,9 @@ def err_unexpected_interface : Error< def err_ref_non_value : Error<"%0 does not refer to a value">; def err_ref_vm_type : Error< "cannot refer to declaration with a variably modified type inside block">; +def err_ref_flexarray_type : Error< + "cannot refer to declaration of structure variable with flexible array member " + "inside block">; def err_ref_array_type : Error< "cannot refer to declaration with an array type inside block">; def err_property_not_found : Error< @@ -4185,7 +4352,7 @@ def err_property_not_found : Error< def err_invalid_property_name : Error< "%0 is not a valid property name (accessing an object of type %1)">; def err_getter_not_found : Error< - "expected getter method not found on object of type %0">; + "no getter method for read from property">; def err_objc_subscript_method_not_found : Error< "expected method to %select{read|write}1 %select{dictionary|array}2 element not " "found on object of type %0">; @@ -4276,8 +4443,6 @@ def error_no_super_class_message : Error< "no @interface declaration found in class messaging of %0">; def error_root_class_cannot_use_super : Error< "%0 cannot use 'super' because it is a root class">; -def err_invalid_receiver_to_message : Error< - "invalid receiver to message expression">; def err_invalid_receiver_to_message_super : Error< "'super' is only valid in a method body">; def err_invalid_receiver_class_message : Error< @@ -4337,6 +4502,14 @@ def note_parameter_here : Note< def err_bad_reinterpret_cast_overload : Error< "reinterpret_cast cannot resolve overloaded function %0 to type %1">; +def warn_reinterpret_different_from_static : Warning< + "'reinterpret_cast' %select{from|to}3 class %0 %select{to|from}3 its " + "%select{virtual base|base at non-zero offset}2 %1 behaves differently from " + "'static_cast'">, InGroup<ReinterpretBaseClass>; +def note_reinterpret_updowncast_use_static: Note< + "use 'static_cast' to adjust the pointer correctly while " + "%select{upcasting|downcasting}0">; + def err_bad_static_cast_overload : Error< "address of overloaded function %0 cannot be static_cast to type %1">; @@ -4386,7 +4559,7 @@ def err_bad_reinterpret_cast_reference : Error< "reinterpret_cast of a %0 to %1 needs its address which is not allowed">; def warn_undefined_reinterpret_cast : Warning< "reinterpret_cast from %0 to %1 has undefined behavior">, - InGroup<DiagGroup<"undefined-reinterpret-cast">>, DefaultIgnore; + InGroup<UndefinedReinterpretCast>, DefaultIgnore; // These messages don't adhere to the pattern. // FIXME: Display the path somehow better. @@ -4464,7 +4637,7 @@ def ext_delete_void_ptr_operand : ExtWarn< def err_ambiguous_delete_operand : Error<"ambiguous conversion of delete " "expression of type %0 to a pointer">; def warn_delete_incomplete : Warning< - "deleting pointer to incomplete type %0 may cause undefined behaviour">, + "deleting pointer to incomplete type %0 may cause undefined behavior">, InGroup<DiagGroup<"delete-incomplete">>; def err_delete_incomplete_class_type : Error< "deleting incomplete class type %0; no conversions to pointer type">; @@ -4563,6 +4736,9 @@ let CategoryName = "Lambda Issue" in { def err_lambda_capture_vm_type : Error< "variable %0 with variably modified type cannot be captured in " "a lambda expression">; + def err_lambda_capture_flexarray_type : Error< + "variable %0 with flexible array member cannot be captured in " + "a lambda expression">; def err_lambda_impcap : Error< "variable %0 cannot be implicitly captured in a lambda with no " "capture-default specified">; @@ -4573,8 +4749,6 @@ let CategoryName = "Lambda Issue" in { "cannot deduce lambda return type from initializer list">; def err_lambda_capture_default_arg : Error< "lambda expression in default argument cannot capture any entity">; - def err_lambda_unexpanded_pack : Error< - "unexpanded function parameter pack capture is unsupported">; def err_lambda_incomplete_result : Error< "incomplete result type %0 in lambda expression">; def err_lambda_objc_object_result : Error< @@ -4823,7 +4997,7 @@ def ext_typecheck_convert_discards_qualifiers : ExtWarn< "sending to parameter of different type}0,1" "|%diff{casting $ to type $|casting between types}0,1}2" " discards qualifiers">, - InGroup<IncompatiblePointerTypes>; + InGroup<IncompatiblePointerTypesDiscardsQualifiers>; def ext_nested_pointer_qualifier_mismatch : ExtWarn< "%select{%diff{assigning to $ from $|assigning to different types}0,1" "|%diff{passing $ to parameter of type $|" @@ -4837,7 +5011,7 @@ def ext_nested_pointer_qualifier_mismatch : ExtWarn< "sending to parameter of different type}0,1" "|%diff{casting $ to type $|casting between types}0,1}2" " discards qualifiers in nested pointer types">, - InGroup<IncompatiblePointerTypes>; + InGroup<IncompatiblePointerTypesDiscardsQualifiers>; def warn_incompatible_vectors : Warning< "incompatible vector types " "%select{%diff{assigning to $ from $|assigning to different types}0,1" @@ -5015,7 +5189,7 @@ def err_ref_bad_target : Error< def warn_non_pod_vararg_with_format_string : Warning< "cannot pass %select{non-POD|non-trivial}0 object of type %1 to variadic " "%select{function|block|method|constructor}2; expected type from format " - "string was %3">, InGroup<DiagGroup<"non-pod-varargs">>, DefaultError; + "string was %3">, InGroup<NonPODVarargs>, DefaultError; // The arguments to this diagnostic should match the warning above. def err_cannot_pass_objc_interface_to_vararg_format : Error< "cannot pass object with interface type %1 by value to variadic " @@ -5028,7 +5202,7 @@ def err_cannot_pass_objc_interface_to_vararg : Error< def warn_cannot_pass_non_pod_arg_to_vararg : Warning< "cannot pass object of %select{non-POD|non-trivial}0 type %1 through variadic" " %select{function|block|method|constructor}2; call will abort at runtime">, - InGroup<DiagGroup<"non-pod-varargs">>, DefaultError; + InGroup<NonPODVarargs>, DefaultError; def warn_cxx98_compat_pass_non_pod_arg_to_vararg : Warning< "passing object of trivial but non-POD type %0 through variadic" " %select{function|block|method|constructor}1 is incompatible with C++98">, @@ -5141,10 +5315,14 @@ let CategoryName = "Inline Assembly Issue" in { "%diff{$ matching output with type $|}0,1">; def err_asm_unknown_register_name : Error<"unknown register name '%0' in asm">; def err_asm_empty : Error<"__asm used with no assembly instructions">; + def err_asm_invalid_input_size : Error< + "invalid input size for constraint '%0'">; def err_invalid_asm_cast_lvalue : Error< "invalid use of a cast in a inline asm context requiring an l-value: " "remove the cast or build with -fheinous-gnu-extensions">; def err_inline_ms_asm_parsing : Error<"%0">; + def err_msasm_unsupported_arch : Error< + "Unsupported architecture '%0' for MS-style inline assembly">; def warn_asm_label_on_auto_decl : Warning< "ignored asm label '%0' on automatic variable">; @@ -5153,7 +5331,8 @@ let CategoryName = "Inline Assembly Issue" in { "accepted due to -fheinous-gnu-extensions, but clang may remove support " "for this in the future">; def warn_asm_mismatched_size_modifier : Warning< - "the size being stored is truncated, use a modifier to specify the size">, + "the value is truncated when put into register, " + "use a modifier to specify the size">, InGroup<ASMOperandWidths>; } @@ -5205,9 +5384,11 @@ def err_in_class_initializer_bad_type : Error< "static data member of type %0 must be initialized out of line">; def ext_in_class_initializer_float_type : ExtWarn< "in-class initializer for static data member of type %0 is a GNU extension">, - InGroup<GNU>; -def note_in_class_initializer_float_type_constexpr : Note< - "use 'constexpr' specifier to silence this warning">; + InGroup<GNUStaticFloatInit>; +def ext_in_class_initializer_float_type_cxx11 : ExtWarn< + "in-class initializer for static data member of type %0 requires " + "'constexpr' specifier">, InGroup<StaticFloatInit>, DefaultError; +def note_in_class_initializer_float_type_cxx11 : Note<"add 'constexpr'">; def err_in_class_initializer_literal_type : Error< "in-class initializer for static data member of type %0 requires " "'constexpr' specifier">; @@ -5244,6 +5425,9 @@ def err_anonymous_record_with_type : Error< def ext_anonymous_record_with_type : Extension< "types declared in an anonymous %select{struct|union}0 are a Microsoft " "extension">, InGroup<Microsoft>; +def ext_anonymous_record_with_anonymous_type : Extension< + "anonymous types declared in an anonymous %select{struct|union}0 " + "are an extension">, InGroup<DiagGroup<"nested-anon-types">>; def err_anonymous_record_with_function : Error< "functions cannot be declared in an anonymous %select{struct|union}0">; def err_anonymous_record_with_static : Error< @@ -5403,6 +5587,9 @@ def warn_cxx98_compat_explicit_conversion_functions : Warning< def err_defaulted_special_member_params : Error< "an explicitly-defaulted %select{|copy |move }0constructor cannot " "have default arguments">; +def err_defaulted_special_member_variadic : Error< + "an explicitly-defaulted %select{|copy |move }0constructor cannot " + "be variadic">; def err_defaulted_special_member_return_type : Error< "explicitly-defaulted %select{copy|move}0 assignment operator must " "return %1">; @@ -5420,10 +5607,6 @@ def err_defaulted_special_member_copy_const_param : Error< "the parameter for this explicitly-defaulted copy " "%select{constructor|assignment operator}0 is const, but a member or base " "requires it to be non-const">; -def err_defaulted_special_member_copy_non_const_param : Error< - "explicitly-defaulted copy %select{constructor|assignment operator}0 with " - "a non-const parameter must be defaulted outside the class, unless a base or " - "member requires the parameter to be non-const">; def err_defaulted_copy_assign_not_ref : Error< "the parameter for an explicitly-defaulted copy assignment operator must be an " "lvalue reference type">; @@ -5446,17 +5629,17 @@ def ext_implicit_exception_spec_mismatch : ExtWarn< def warn_ptr_arith_precedes_bounds : Warning< "the pointer decremented by %0 refers before the beginning of the array">, - InGroup<DiagGroup<"array-bounds-pointer-arithmetic">>, DefaultIgnore; + InGroup<ArrayBoundsPointerArithmetic>, DefaultIgnore; def warn_ptr_arith_exceeds_bounds : Warning< "the pointer incremented by %0 refers past the end of the array (that " "contains %1 element%s2)">, - InGroup<DiagGroup<"array-bounds-pointer-arithmetic">>, DefaultIgnore; + InGroup<ArrayBoundsPointerArithmetic>, DefaultIgnore; def warn_array_index_precedes_bounds : Warning< "array index %0 is before the beginning of the array">, - InGroup<DiagGroup<"array-bounds">>; + InGroup<ArrayBounds>; def warn_array_index_exceeds_bounds : Warning< "array index %0 is past the end of the array (which contains %1 " - "element%s2)">, InGroup<DiagGroup<"array-bounds">>; + "element%s2)">, InGroup<ArrayBounds>; def note_array_index_out_of_bounds : Note< "array %0 declared here">; @@ -5494,7 +5677,7 @@ def warn_format_mix_positional_nonpositional_args : Warning< InGroup<Format>; def warn_static_array_too_small : Warning< "array argument is too small; contains %0 elements, callee requires at least %1">, - InGroup<DiagGroup<"array-bounds">>; + InGroup<ArrayBounds>; def note_callee_static_array : Note< "callee declares array parameter as static here">; def warn_empty_format_string : Warning< @@ -5543,19 +5726,19 @@ def warn_null_arg : Warning< // CHECK: returning address/reference of stack memory def warn_ret_stack_addr : Warning< "address of stack memory associated with local variable %0 returned">, - InGroup<DiagGroup<"return-stack-address">>; + InGroup<ReturnStackAddress>; def warn_ret_stack_ref : Warning< "reference to stack memory associated with local variable %0 returned">, - InGroup<DiagGroup<"return-stack-address">>; + InGroup<ReturnStackAddress>; def warn_ret_local_temp_addr : Warning< "returning address of local temporary object">, - InGroup<DiagGroup<"return-stack-address">>; + InGroup<ReturnStackAddress>; def warn_ret_local_temp_ref : Warning< "returning reference to local temporary object">, - InGroup<DiagGroup<"return-stack-address">>; + InGroup<ReturnStackAddress>; def warn_ret_addr_label : Warning< "returning address of label, which is local">, - InGroup<DiagGroup<"return-stack-address">>; + InGroup<ReturnStackAddress>; def err_ret_local_block : Error< "returning block that lives on the local stack">; def note_ref_var_local_bind : Note< @@ -5565,13 +5748,13 @@ def note_ref_var_local_bind : Note< // a constructor parameter. def warn_bind_ref_member_to_parameter : Warning< "binding reference member %0 to stack allocated parameter %1">, - InGroup<DiagGroup<"dangling-field">>; + InGroup<DanglingField>; def warn_init_ptr_member_to_parameter_addr : Warning< "initializing pointer member %0 with the stack address of parameter %1">, - InGroup<DiagGroup<"dangling-field">>; + InGroup<DanglingField>; def warn_bind_ref_member_to_temporary : Warning< "binding reference member %0 to a temporary value">, - InGroup<DiagGroup<"dangling-field">>; + InGroup<DanglingField>; def note_ref_or_ptr_member_declared_here : Note< "%select{reference|pointer}0 member declared here">; @@ -5657,7 +5840,7 @@ def warn_bool_switch_condition : Warning< "switch condition has boolean value">; def warn_case_value_overflow : Warning< "overflow converting case value to switch condition type (%0 to %1)">, - InGroup<DiagGroup<"switch">>; + InGroup<Switch>; def err_duplicate_case : Error<"duplicate case value '%0'">; def err_duplicate_case_differing_expr : Error< "duplicate case value: '%0' and '%1' both equal '%2'">; @@ -5760,10 +5943,10 @@ def err_second_parameter_to_va_arg_abstract: Error< "second argument to 'va_arg' is of abstract type %0">; def warn_second_parameter_to_va_arg_not_pod : Warning< "second argument to 'va_arg' is of non-POD type %0">, - InGroup<DiagGroup<"non-pod-varargs">>, DefaultError; + InGroup<NonPODVarargs>, DefaultError; def warn_second_parameter_to_va_arg_ownership_qualified : Warning< "second argument to 'va_arg' is of ARC ownership-qualified type %0">, - InGroup<DiagGroup<"non-pod-varargs">>, DefaultError; + InGroup<NonPODVarargs>, DefaultError; def warn_second_parameter_to_va_arg_never_compatible : Warning< "second argument to 'va_arg' is of promotable type %0; this va_arg has " "undefined behavior because arguments will be promoted to %1">; @@ -5785,12 +5968,24 @@ def err_return_init_list : Error< "must not return a value">; def warn_noreturn_function_has_return_expr : Warning< "function %0 declared 'noreturn' should not return">, - InGroup<DiagGroup<"invalid-noreturn">>; + InGroup<InvalidNoreturn>; def warn_falloff_noreturn_function : Warning< "function declared 'noreturn' should not return">, - InGroup<DiagGroup<"invalid-noreturn">>; + InGroup<InvalidNoreturn>; def err_noreturn_block_has_return_expr : Error< "block declared 'noreturn' should not return">; +def err_noreturn_missing_on_first_decl : Error< + "function declared '[[noreturn]]' after its first declaration">; +def note_noreturn_missing_first_decl : Note< + "declaration missing '[[noreturn]]' attribute is here">; +def err_carries_dependency_missing_on_first_decl : Error< + "%select{function|parameter}0 declared '[[carries_dependency]]' " + "after its first declaration">; +def note_carries_dependency_missing_first_decl : Note< + "declaration missing '[[carries_dependency]]' attribute is here">; +def err_carries_dependency_param_not_function_decl : Error< + "'[[carries_dependency]]' attribute only allowed on parameter in a function " + "declaration or lambda">; def err_block_on_nonlocal : Error< "__block attribute not allowed, only allowed on local variables">; def err_block_on_vm : Error< @@ -5870,6 +6065,8 @@ def err_c99_array_usage_cxx : Error< "feature, not permitted in C++">; def err_double_requires_fp64 : Error< "use of type 'double' requires cl_khr_fp64 extension to be enabled">; +def err_int128_unsupported : Error< + "__int128 is not supported on this target">; def err_nsconsumed_attribute_mismatch : Error< "overriding method has mismatched ns_consumed attribute on its" " parameter">; @@ -5986,8 +6183,44 @@ def err_invalid_astype_of_different_size : Error< "invalid reinterpretation: sizes of %0 and %1 must match">; def err_static_kernel : Error< "kernel functions cannot be declared static">; +def err_opencl_ptrptr_kernel_arg : Error< + "kernel argument cannot be declared as a pointer to a pointer">; def err_static_function_scope : Error< "variables in function scope cannot be declared static">; +def err_opencl_bitfields : Error< + "bitfields are not supported in OpenCL">; +def err_opencl_vla : Error< + "variable length arrays are not supported in OpenCL">; +def err_event_t_kernel_arg : Error< + "the event_t type cannot be used to declare a kernel function argument">; +def err_event_t_global_var : Error< + "the event_t type cannot be used to declare a program scope variable">; +def err_event_t_struct_field : Error< + "the event_t type cannot be used to declare a structure or union field">; +def err_event_t_addr_space_qual : Error< + "the event_t type can only be used with __private address space qualifier">; +def err_expected_kernel_void_return_type : Error< + "kernel must have void return type">; +def err_sampler_argument_required : Error< + "sampler_t variable required - got %0">; +def err_wrong_sampler_addressspace: Error< + "sampler type cannot be used with the __local and __global address space qualifiers">; + +// OpenMP support. +def err_omp_expected_var_arg_suggest : Error< + "%0 is not a global variable, static local variable or static data member%select{|; did you mean %2?}1">; +def err_omp_global_var_arg : Error< + "arguments of '#pragma omp %0' must have %select{global storage|static storage duration}1">; +def err_omp_ref_type_arg : Error< + "arguments of '#pragma omp %0' cannot be of reference type %1">; +def err_omp_var_scope : Error< + "'#pragma omp %0' must appear in the scope of the %1 variable declaration">; +def err_omp_var_used : Error< + "'#pragma omp %0' must precede all references to variable %1">; +def err_omp_var_thread_local : Error< + "variable %0 cannot be threadprivate because it is thread-local">; +def err_omp_incomplete_type : Error< + "a threadprivate variable must not have incomplete type %0">; } // end of sema category @@ -6000,15 +6233,19 @@ def warn_related_result_type_compatibility_class : Warning< def warn_related_result_type_compatibility_protocol : Warning< "protocol method is expected to return an instance of the implementing " "class, but is declared to return %0">; -def note_related_result_type_overridden_family : Note< - "overridden method is part of the '%select{|alloc|copy|init|mutableCopy|" - "new|autorelease|dealloc|finalize|release|retain|retainCount|self}0' method " - "family">; +def note_related_result_type_family : Note< + "%select{overridden|current}0 method is part of the '%select{|alloc|copy|init|" + "mutableCopy|new|autorelease|dealloc|finalize|release|retain|retainCount|" + "self}1' method family%select{| and is expected to return an instance of its " + "class type}0">; def note_related_result_type_overridden : Note< "overridden method returns an instance of its class type">; def note_related_result_type_inferred : Note< "%select{class|instance}0 method %1 is assumed to return an instance of " "its receiver type (%2)">; +def note_related_result_type_explicit : Note< + "%select{overridden|current}0 method is explicitly declared 'instancetype'" + "%select{| and is expected to return an instance of its class type}0">; } @@ -6023,7 +6260,7 @@ def err_module_private_local_class : Error< "local %select{struct|interface|union|class|enum}0 cannot be declared " "__module_private__">; def err_module_private_definition : Error< - "definition of %0 must be imported before it is required">; + "definition of %0 must be imported from module '%1' before it is required">; } let CategoryName = "Documentation Issue" in { diff --git a/include/clang/Basic/DiagnosticSerializationKinds.td b/include/clang/Basic/DiagnosticSerializationKinds.td index e9df09d..7137404 100644 --- a/include/clang/Basic/DiagnosticSerializationKinds.td +++ b/include/clang/Basic/DiagnosticSerializationKinds.td @@ -17,10 +17,8 @@ def err_fe_pch_malformed : Error< "malformed or corrupted PCH file: '%0'">, DefaultFatal; def err_fe_pch_malformed_block : Error< "malformed block record in PCH file: '%0'">, DefaultFatal; -def err_fe_pch_error_at_end_block : Error< - "error at end of module block in PCH file: '%0'">, DefaultFatal; def err_fe_pch_file_modified : Error< - "file '%0' has been modified since the precompiled header was built">, + "file '%0' has been modified since the precompiled header '%1' was built">, DefaultFatal; def err_fe_pch_file_overridden : Error< "file '%0' from the precompiled header has been overridden">; @@ -46,19 +44,16 @@ def warn_pch_different_branch : Error< def err_pch_with_compiler_errors : Error< "PCH file contains compiler errors">; - +def warn_module_conflict : Warning< + "module '%0' conflicts with already-imported module '%1': %2">, + InGroup<ModuleConflict>; + def err_pch_macro_def_undef : Error< "macro '%0' was %select{defined|undef'd}1 in the precompiled header but " "%select{undef'd|defined}1 on the command line">; def err_pch_macro_def_conflict : Error< "definition of macro '%0' differs between the precompiled header ('%1') " "and the command line ('%2')">; -def err_pch_include_opt_missing : Error< - "precompiled header depends on '%select{-include|-imacros}0 %1' option " - "that is missing from the command line">; -def err_pch_include_opt_conflict : Error< - "precompiled header option '%select{-include|-imacros}0 %1' conflicts with " - "corresponding option '%select{-include|-imacros}0 %2' on command line">; def err_pch_undef : Error< "%select{command line contains|precompiled header was built with}0 " "'-undef' but %select{precompiled header was not built with it|" diff --git a/include/clang/Basic/FileManager.h b/include/clang/Basic/FileManager.h index b2f578d..6d9e53b 100644 --- a/include/clang/Basic/FileManager.h +++ b/include/clang/Basic/FileManager.h @@ -17,11 +17,12 @@ #include "clang/Basic/FileSystemOptions.h" #include "clang/Basic/LLVM.h" +#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" +#include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" -#include "llvm/ADT/OwningPtr.h" #include "llvm/Support/Allocator.h" // FIXME: Enhance libsystem to support inode and other fields in stat. #include <sys/types.h> @@ -152,6 +153,12 @@ class FileManager : public RefCountedBase<FileManager> { /// \see SeenDirEntries llvm::StringMap<FileEntry*, llvm::BumpPtrAllocator> SeenFileEntries; + /// \brief The canonical names of directories. + llvm::DenseMap<const DirectoryEntry *, llvm::StringRef> CanonicalDirNames; + + /// \brief Storage for canonical names that we have computed. + llvm::BumpPtrAllocator CanonicalNameStorage; + /// \brief Each FileEntry we create is assigned a unique ID #. /// unsigned NextFileUID; @@ -164,7 +171,7 @@ class FileManager : public RefCountedBase<FileManager> { OwningPtr<FileSystemStatCache> StatCache; bool getStatValue(const char *Path, struct stat &StatBuf, - int *FileDescriptor); + bool isFile, int *FileDescriptor); /// Add all ancestors of the given path (pointing to either a file /// or a directory) as virtual directories. @@ -257,6 +264,13 @@ public: static void modifyFileEntry(FileEntry *File, off_t Size, time_t ModificationTime); + /// \brief Retrieve the canonical name for a given directory. + /// + /// This is a very expensive operation, despite its results being cached, + /// and should only be used when the physical layout of the file system is + /// required, which is (almost) never. + StringRef getCanonicalName(const DirectoryEntry *Dir); + void PrintStats() const; }; diff --git a/include/clang/Basic/FileSystemStatCache.h b/include/clang/Basic/FileSystemStatCache.h index a802c7c..ff70373 100644 --- a/include/clang/Basic/FileSystemStatCache.h +++ b/include/clang/Basic/FileSystemStatCache.h @@ -18,8 +18,8 @@ #include "clang/Basic/LLVM.h" #include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/StringMap.h" -#include <sys/types.h> #include <sys/stat.h> +#include <sys/types.h> namespace clang { @@ -44,13 +44,13 @@ public: /// /// \returns \c true if the path does not exist or \c false if it exists. /// - /// If FileDescriptor is non-null, then this lookup should only return success - /// for files (not directories). If it is null this lookup should only return + /// If isFile is true, then this lookup should only return success for files + /// (not directories). If it is false this lookup should only return /// success for directories (not files). On a successful file lookup, the /// implementation can optionally fill in FileDescriptor with a valid /// descriptor and the client guarantees that it will close it. - static bool get(const char *Path, struct stat &StatBuf, int *FileDescriptor, - FileSystemStatCache *Cache); + static bool get(const char *Path, struct stat &StatBuf, + bool isFile, int *FileDescriptor, FileSystemStatCache *Cache); /// \brief Sets the next stat call cache in the chain of stat caches. @@ -69,16 +69,17 @@ public: protected: virtual LookupResult getStat(const char *Path, struct stat &StatBuf, - int *FileDescriptor) = 0; + bool isFile, int *FileDescriptor) = 0; LookupResult statChained(const char *Path, struct stat &StatBuf, - int *FileDescriptor) { + bool isFile, int *FileDescriptor) { if (FileSystemStatCache *Next = getNextStatCache()) - return Next->getStat(Path, StatBuf, FileDescriptor); + return Next->getStat(Path, StatBuf, isFile, FileDescriptor); // If we hit the end of the list of stat caches to try, just compute and // return it without a cache. - return get(Path, StatBuf, FileDescriptor, 0) ? CacheMissing : CacheExists; + return get(Path, StatBuf, + isFile, FileDescriptor, 0) ? CacheMissing : CacheExists; } }; @@ -97,7 +98,7 @@ public: iterator end() const { return StatCalls.end(); } virtual LookupResult getStat(const char *Path, struct stat &StatBuf, - int *FileDescriptor); + bool isFile, int *FileDescriptor); }; } // end namespace clang diff --git a/include/clang/Basic/IdentifierTable.h b/include/clang/Basic/IdentifierTable.h index 76242ec..c04a893 100644 --- a/include/clang/Basic/IdentifierTable.h +++ b/include/clang/Basic/IdentifierTable.h @@ -16,9 +16,9 @@ #ifndef LLVM_CLANG_BASIC_IDENTIFIERTABLE_H #define LLVM_CLANG_BASIC_IDENTIFIERTABLE_H +#include "clang/Basic/LLVM.h" #include "clang/Basic/OperatorKinds.h" #include "clang/Basic/TokenKinds.h" -#include "clang/Basic/LLVM.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/Support/PointerLikeTypeTraits.h" @@ -146,9 +146,6 @@ public: bool hadMacroDefinition() const { return HadMacro; } - void setHadMacroDefinition(bool Val) { - HadMacro = Val; - } /// getTokenID - If this is a source-language token (e.g. 'for'), this API /// can be used to cause the lexer to map identifiers to source-language @@ -297,11 +294,11 @@ public: } /// \brief Determine whether this is the contextual keyword - /// '__experimental_modules_import'. + /// 'import'. bool isModulesImport() const { return IsModulesImport; } /// \brief Set whether this identifier is the contextual keyword - /// '__experimental_modules_import'. + /// 'import'. void setModulesImport(bool I) { IsModulesImport = I; if (I) diff --git a/include/clang/Basic/LLVM.h b/include/clang/Basic/LLVM.h index 13c5b44..306c75e 100644 --- a/include/clang/Basic/LLVM.h +++ b/include/clang/Basic/LLVM.h @@ -16,19 +16,24 @@ #ifndef CLANG_BASIC_LLVM_H #define CLANG_BASIC_LLVM_H -// This should be the only #include, force #includes of all the others on -// clients. +// Do not proliferate #includes here, require clients to #include their +// dependencies. +// Casting.h has complex templates that cannot be easily forward declared. #include "llvm/Support/Casting.h" +// None.h includes an enumerator that is desired & cannot be forward declared +// without a definition of NoneType. +#include "llvm/ADT/None.h" namespace llvm { // ADT's. class StringRef; class Twine; template<typename T> class ArrayRef; - template<class T> class OwningPtr; + template<typename T> class OwningPtr; template<unsigned InternalLen> class SmallString; template<typename T, unsigned N> class SmallVector; template<typename T> class SmallVectorImpl; + template<typename T> class Optional; template<typename T> struct SaveAndRestore; @@ -53,6 +58,8 @@ namespace clang { using llvm::cast_or_null; // ADT's. + using llvm::None; + using llvm::Optional; using llvm::StringRef; using llvm::Twine; using llvm::ArrayRef; diff --git a/include/clang/Basic/LangOptions.def b/include/clang/Basic/LangOptions.def index dbc08c7..3de0107 100644 --- a/include/clang/Basic/LangOptions.def +++ b/include/clang/Basic/LangOptions.def @@ -45,9 +45,10 @@ LANGOPT(C99 , 1, 0, "C99") LANGOPT(C11 , 1, 0, "C11") LANGOPT(MicrosoftExt , 1, 0, "Microsoft extensions") LANGOPT(MicrosoftMode , 1, 0, "Microsoft compatibility mode") +LANGOPT(AsmBlocks , 1, 0, "Microsoft inline asm blocks") LANGOPT(Borland , 1, 0, "Borland extensions") LANGOPT(CPlusPlus , 1, 0, "C++") -LANGOPT(CPlusPlus0x , 1, 0, "C++0x") +LANGOPT(CPlusPlus11 , 1, 0, "C++0x") LANGOPT(CPlusPlus1y , 1, 0, "C++1y") LANGOPT(ObjC1 , 1, 0, "Objective-C 1") LANGOPT(ObjC2 , 1, 0, "Objective-C 2") @@ -115,7 +116,9 @@ LANGOPT(ShortEnums , 1, 0, "short enum types") LANGOPT(OpenCL , 1, 0, "OpenCL") LANGOPT(OpenCLVersion , 32, 0, "OpenCL version") +LANGOPT(NativeHalfType , 1, 0, "Native half type support") LANGOPT(CUDA , 1, 0, "CUDA") +LANGOPT(OpenMP , 1, 0, "OpenMP support") LANGOPT(AssumeSaneOperatorNew , 1, 1, "implicit __attribute__((malloc)) for C++'s new operators") BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision") @@ -144,18 +147,21 @@ BENIGN_LANGOPT(DelayedTemplateParsing , 1, 0, "delayed template parsing") LANGOPT(BlocksRuntimeOptional , 1, 0, "optional blocks runtime") ENUM_LANGOPT(GC, GCMode, 2, NonGC, "Objective-C Garbage Collection mode") -ENUM_LANGOPT(VisibilityMode, Visibility, 3, DefaultVisibility, - "symbol visibility") +ENUM_LANGOPT(ValueVisibilityMode, Visibility, 3, DefaultVisibility, + "value symbol visibility") +ENUM_LANGOPT(TypeVisibilityMode, Visibility, 3, DefaultVisibility, + "type symbol visibility") ENUM_LANGOPT(StackProtector, StackProtectorMode, 2, SSPOff, "stack protector mode") ENUM_LANGOPT(SignedOverflowBehavior, SignedOverflowBehaviorTy, 2, SOB_Undefined, "signed integer overflow handling") -ENUM_LANGOPT(FPContractMode, FPContractModeKind, 2, FPC_On, "FP_CONTRACT mode") BENIGN_LANGOPT(InstantiationDepth, 32, 512, "maximum template instantiation depth") BENIGN_LANGOPT(ConstexprCallDepth, 32, 512, "maximum constexpr call depth") +BENIGN_LANGOPT(BracketDepth, 32, 256, + "maximum bracket nesting depth") BENIGN_LANGOPT(NumLargeByValueCopy, 32, 0, "if non-zero, warn about parameter or return Warn if parameter/return value is larger in bytes than this setting. 0 is no check.") VALUE_LANGOPT(MSCVersion, 32, 0, @@ -163,17 +169,8 @@ VALUE_LANGOPT(MSCVersion, 32, 0, LANGOPT(ApplePragmaPack, 1, 0, "Apple gcc-compatible #pragma pack handling") -BENIGN_LANGOPT(EmitMicrosoftInlineAsm , 1, 0, - "Enable emission of MS-style inline assembly.") - - BENIGN_LANGOPT(RetainCommentsFromSystemHeaders, 1, 0, "retain documentation comments from system headers in the AST") -/// Runtime sanitizers. -#define SANITIZER(NAME, ID) \ -BENIGN_LANGOPT(Sanitize##ID, 1, 0, NAME " sanitizer") -#include "clang/Basic/Sanitizers.def" - #undef LANGOPT #undef VALUE_LANGOPT #undef BENIGN_LANGOPT diff --git a/include/clang/Basic/LangOptions.h b/include/clang/Basic/LangOptions.h index fbb014e..21ca7eb 100644 --- a/include/clang/Basic/LangOptions.h +++ b/include/clang/Basic/LangOptions.h @@ -15,14 +15,23 @@ #ifndef LLVM_CLANG_LANGOPTIONS_H #define LLVM_CLANG_LANGOPTIONS_H -#include <string> +#include "clang/Basic/CommentOptions.h" #include "clang/Basic/LLVM.h" #include "clang/Basic/ObjCRuntime.h" #include "clang/Basic/Visibility.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" +#include <string> namespace clang { +struct SanitizerOptions { +#define SANITIZER(NAME, ID) unsigned ID : 1; +#include "clang/Basic/Sanitizers.def" + + /// \brief Cached set of sanitizer options with all sanitizers disabled. + static const SanitizerOptions Disabled; +}; + /// Bitfields of LangOptions, split out from LangOptions in order to ensure that /// this large collection of bitfields is a trivial class type. class LangOptionsBase { @@ -32,6 +41,7 @@ public: #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) #include "clang/Basic/LangOptions.def" + SanitizerOptions Sanitize; protected: // Define language options of enumeration type. These are private, and will // have accessors (below). @@ -56,12 +66,6 @@ public: SOB_Trapping // -ftrapv }; - enum FPContractModeKind { - FPC_Off, // Form fused FP ops only where result will not be affected. - FPC_On, // Form fused FP ops according to FP_CONTRACT rules. - FPC_Fast // Aggressively fuse FP ops (E.g. FMA). - }; - public: clang::ObjCRuntime ObjCRuntime; @@ -75,6 +79,9 @@ public: /// \brief The name of the current module. std::string CurrentModule; + + /// \brief Options for parsing comments. + CommentOptions CommentOpts; LangOptions(); diff --git a/include/clang/Basic/Linkage.h b/include/clang/Basic/Linkage.h index 6bc1f5d..01b8db1 100644 --- a/include/clang/Basic/Linkage.h +++ b/include/clang/Basic/Linkage.h @@ -42,6 +42,14 @@ enum Linkage { ExternalLinkage }; +/// \brief Describes the different kinds of language linkage +/// (C++ [dcl.link]) that an entity may have. +enum LanguageLinkage { + CLanguageLinkage, + CXXLanguageLinkage, + NoLanguageLinkage +}; + /// \brief A more specific kind of linkage than enum Linkage. /// /// This is relevant to CodeGen and AST file reading. diff --git a/include/clang/Basic/MacroBuilder.h b/include/clang/Basic/MacroBuilder.h index 6df3a38..9a9eaa2 100644 --- a/include/clang/Basic/MacroBuilder.h +++ b/include/clang/Basic/MacroBuilder.h @@ -15,6 +15,7 @@ #ifndef LLVM_CLANG_BASIC_MACROBUILDER_H #define LLVM_CLANG_BASIC_MACROBUILDER_H +#include "clang/Basic/LLVM.h" #include "llvm/ADT/Twine.h" #include "llvm/Support/raw_ostream.h" diff --git a/include/clang/Basic/Module.h b/include/clang/Basic/Module.h index b6b088c..d2a43f0 100644 --- a/include/clang/Basic/Module.h +++ b/include/clang/Basic/Module.h @@ -18,10 +18,10 @@ #include "clang/Basic/SourceLocation.h" #include "llvm/ADT/PointerIntPair.h" #include "llvm/ADT/PointerUnion.h" +#include "llvm/ADT/SetVector.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" -#include "llvm/ADT/SetVector.h" #include <string> #include <utility> #include <vector> @@ -34,12 +34,12 @@ namespace clang { class DirectoryEntry; class FileEntry; +class FileManager; class LangOptions; class TargetInfo; /// \brief Describes the name of a module. -typedef llvm::SmallVector<std::pair<std::string, SourceLocation>, 2> - ModuleId; +typedef SmallVector<std::pair<std::string, SourceLocation>, 2> ModuleId; /// \brief Describes a module or submodule. class Module { @@ -68,23 +68,26 @@ private: /// \brief The AST file if this is a top-level module which has a /// corresponding serialized AST file, or null otherwise. const FileEntry *ASTFile; - + + /// \brief The top-level headers associated with this module. + llvm::SmallSetVector<const FileEntry *, 2> TopHeaders; + + /// \brief top-level header filenames that aren't resolved to FileEntries yet. + std::vector<std::string> TopHeaderNames; + public: /// \brief The headers that are part of this module. - llvm::SmallVector<const FileEntry *, 2> Headers; + SmallVector<const FileEntry *, 2> Headers; /// \brief The headers that are explicitly excluded from this module. - llvm::SmallVector<const FileEntry *, 2> ExcludedHeaders; - - /// \brief The top-level headers associated with this module. - llvm::SmallSetVector<const FileEntry *, 2> TopHeaders; + SmallVector<const FileEntry *, 2> ExcludedHeaders; /// \brief The set of language features required to use this module. /// /// If any of these features is not present, the \c IsAvailable bit /// will be false to indicate that this (sub)module is not /// available. - llvm::SmallVector<std::string, 2> Requires; + SmallVector<std::string, 2> Requires; /// \brief Whether this module is available in the current /// translation unit. @@ -116,7 +119,14 @@ public: /// \brief Whether, when inferring submodules, the inferr submodules should /// export all modules they import (e.g., the equivalent of "export *"). unsigned InferExportWildcard : 1; - + + /// \brief Whether the set of configuration macros is exhaustive. + /// + /// When the set of configuration macros is exhaustive, meaning + /// that no identifier not in this list should affect how the module is + /// built. + unsigned ConfigMacrosExhaustive : 1; + /// \brief Describes the visibility of the various names within a /// particular module. enum NameVisibilityKind { @@ -137,7 +147,7 @@ public: /// \brief The set of modules imported by this module, and on which this /// module depends. - llvm::SmallVector<Module *, 2> Imports; + SmallVector<Module *, 2> Imports; /// \brief Describes an exported module. /// @@ -146,7 +156,7 @@ public: typedef llvm::PointerIntPair<Module *, 1, bool> ExportDecl; /// \brief The set of export declarations. - llvm::SmallVector<ExportDecl, 2> Exports; + SmallVector<ExportDecl, 2> Exports; /// \brief Describes an exported module that has not yet been resolved /// (perhaps because the module it refers to has not yet been loaded). @@ -164,8 +174,58 @@ public: }; /// \brief The set of export declarations that have yet to be resolved. - llvm::SmallVector<UnresolvedExportDecl, 2> UnresolvedExports; - + SmallVector<UnresolvedExportDecl, 2> UnresolvedExports; + + /// \brief A library or framework to link against when an entity from this + /// module is used. + struct LinkLibrary { + LinkLibrary() : IsFramework(false) { } + LinkLibrary(const std::string &Library, bool IsFramework) + : Library(Library), IsFramework(IsFramework) { } + + /// \brief The library to link against. + /// + /// This will typically be a library or framework name, but can also + /// be an absolute path to the library or framework. + std::string Library; + + /// \brief Whether this is a framework rather than a library. + bool IsFramework; + }; + + /// \brief The set of libraries or frameworks to link against when + /// an entity from this module is used. + llvm::SmallVector<LinkLibrary, 2> LinkLibraries; + + /// \brief The set of "configuration macros", which are macros that + /// (intentionally) change how this module is built. + std::vector<std::string> ConfigMacros; + + /// \brief An unresolved conflict with another module. + struct UnresolvedConflict { + /// \brief The (unresolved) module id. + ModuleId Id; + + /// \brief The message provided to the user when there is a conflict. + std::string Message; + }; + + /// \brief The list of conflicts for which the module-id has not yet been + /// resolved. + std::vector<UnresolvedConflict> UnresolvedConflicts; + + /// \brief A conflict between two modules. + struct Conflict { + /// \brief The module that this module conflicts with. + Module *Other; + + /// \brief The message provided to the user when there is a conflict. + std::string Message; + }; + + /// \brief The list of conflicts. + std::vector<Conflict> Conflicts; + /// \brief Construct a top-level module. explicit Module(StringRef Name, SourceLocation DefinitionLoc, bool IsFramework) @@ -173,7 +233,8 @@ public: IsAvailable(true), IsFromModuleFile(false), IsFramework(IsFramework), IsExplicit(false), IsSystem(false), InferSubmodules(false), InferExplicitSubmodules(false), - InferExportWildcard(false), NameVisibility(Hidden) { } + InferExportWildcard(false), ConfigMacrosExhaustive(false), + NameVisibility(Hidden) { } /// \brief Construct a new module or submodule. Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent, @@ -217,7 +278,13 @@ public: return false; } - + + /// \brief Determine whether this module is a subframework of another + /// framework. + bool isSubFramework() const { + return IsFramework && Parent && Parent->isPartOfFramework(); + } + /// \brief Retrieve the full name of this module, including the path from /// its top-level module. std::string getFullModuleName() const; @@ -266,6 +333,20 @@ public: return Umbrella && Umbrella.is<const DirectoryEntry *>(); } + /// \brief Add a top-level header associated with this module. + void addTopHeader(const FileEntry *File) { + assert(File); + TopHeaders.insert(File); + } + + /// \brief Add a top-level header filename associated with this module. + void addTopHeaderFilename(StringRef Filename) { + TopHeaderNames.push_back(Filename); + } + + /// \brief The top-level headers associated with this module. + ArrayRef<const FileEntry *> getTopHeaders(FileManager &FileMgr); + /// \brief Add the given feature requirement to the list of features /// required by this module. /// @@ -284,7 +365,7 @@ public: /// /// \returns The submodule if found, or NULL otherwise. Module *findSubmodule(StringRef Name) const; - + typedef std::vector<Module *>::iterator submodule_iterator; typedef std::vector<Module *>::const_iterator submodule_const_iterator; @@ -292,14 +373,17 @@ public: submodule_const_iterator submodule_begin() const {return SubModules.begin();} submodule_iterator submodule_end() { return SubModules.end(); } submodule_const_iterator submodule_end() const { return SubModules.end(); } - + + /// \brief Returns the exported modules based on the wildcard restrictions. + void getExportedModules(SmallVectorImpl<Module *> &Exported) const; + static StringRef getModuleInputBufferName() { return "<module-includes>"; } /// \brief Print the module map for this module to the given stream. /// - void print(llvm::raw_ostream &OS, unsigned Indent = 0) const; + void print(raw_ostream &OS, unsigned Indent = 0) const; /// \brief Dump the contents of this module to the given output stream. void dump() const; diff --git a/include/clang/Basic/ObjCRuntime.h b/include/clang/Basic/ObjCRuntime.h index d543b76..18ef64a 100644 --- a/include/clang/Basic/ObjCRuntime.h +++ b/include/clang/Basic/ObjCRuntime.h @@ -104,7 +104,7 @@ public: return true; } - /// \brief Is this runtime basically of the GNUstep family of runtimes? + /// \brief Is this runtime basically of the GNU family of runtimes? bool isGNUFamily() const { switch (getKind()) { case FragileMacOSX: @@ -164,6 +164,8 @@ public: return getVersion() >= VersionTuple(10, 8); case iOS: return (getVersion() >= VersionTuple(6)); + case GNUstep: + return getVersion() >= VersionTuple(1, 7); default: return false; @@ -272,6 +274,18 @@ public: llvm_unreachable("bad kind"); } + bool hasAtomicCopyHelper() const { + switch (getKind()) { + case FragileMacOSX: + case MacOSX: + case iOS: + return true; + case GNUstep: + return getVersion() >= VersionTuple(1, 7); + default: return false; + } + } + /// \brief Try to parse an Objective-C runtime specification from the given /// string. /// diff --git a/include/clang/Basic/OnDiskHashTable.h b/include/clang/Basic/OnDiskHashTable.h index cc9ca9f..06cb143 100644 --- a/include/clang/Basic/OnDiskHashTable.h +++ b/include/clang/Basic/OnDiskHashTable.h @@ -14,11 +14,12 @@ #ifndef LLVM_CLANG_BASIC_ON_DISK_HASH_TABLE_H #define LLVM_CLANG_BASIC_ON_DISK_HASH_TABLE_H +#include "clang/Basic/LLVM.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/DataTypes.h" +#include "llvm/Support/Host.h" #include "llvm/Support/MathExtras.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/Support/Host.h" #include <cassert> #include <cstdlib> diff --git a/include/clang/Basic/OpenMPKinds.def b/include/clang/Basic/OpenMPKinds.def new file mode 100644 index 0000000..f968977 --- /dev/null +++ b/include/clang/Basic/OpenMPKinds.def @@ -0,0 +1,23 @@ +//===--- OpenMPKinds.def - OpenMP directives and clauses list ---*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// \file +/// \brief This file defines the list of supported OpenMP directives and +/// clauses. +/// +//===----------------------------------------------------------------------===// + +#ifndef OPENMP_DIRECTIVE +# define OPENMP_DIRECTIVE(Name) +#endif + +// OpenMP directives. +OPENMP_DIRECTIVE(threadprivate) +OPENMP_DIRECTIVE(parallel) + +#undef OPENMP_DIRECTIVE diff --git a/include/clang/Basic/OpenMPKinds.h b/include/clang/Basic/OpenMPKinds.h new file mode 100644 index 0000000..c90e9a0 --- /dev/null +++ b/include/clang/Basic/OpenMPKinds.h @@ -0,0 +1,37 @@ +//===--- OpenMPKinds.h - OpenMP enums ---------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief Defines some OpenMP-specific enums and functions. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_OPENMPKINDS_H +#define LLVM_CLANG_BASIC_OPENMPKINDS_H + +#include "llvm/ADT/StringRef.h" + +namespace clang { + +/// \brief OpenMP directives. +enum OpenMPDirectiveKind { + OMPD_unknown = 0, +#define OPENMP_DIRECTIVE(Name) \ + OMPD_##Name, +#include "clang/Basic/OpenMPKinds.def" + NUM_OPENMP_DIRECTIVES +}; + +OpenMPDirectiveKind getOpenMPDirectiveKind(llvm::StringRef Str); +const char *getOpenMPDirectiveName(OpenMPDirectiveKind Kind); + +} + +#endif + diff --git a/include/clang/Basic/OperatorPrecedence.h b/include/clang/Basic/OperatorPrecedence.h new file mode 100644 index 0000000..b68d577 --- /dev/null +++ b/include/clang/Basic/OperatorPrecedence.h @@ -0,0 +1,52 @@ +//===--- OperatorPrecedence.h - Operator precedence levels ------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief Defines and computes precedence levels for binary/ternary operators. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_OPERATOR_PRECEDENCE_H +#define LLVM_CLANG_OPERATOR_PRECEDENCE_H + +#include "clang/Basic/TokenKinds.h" + +namespace clang { + +/// PrecedenceLevels - These are precedences for the binary/ternary +/// operators in the C99 grammar. These have been named to relate +/// with the C99 grammar productions. Low precedences numbers bind +/// more weakly than high numbers. +namespace prec { + enum Level { + Unknown = 0, // Not binary operator. + Comma = 1, // , + Assignment = 2, // =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |= + Conditional = 3, // ? + LogicalOr = 4, // || + LogicalAnd = 5, // && + InclusiveOr = 6, // | + ExclusiveOr = 7, // ^ + And = 8, // & + Equality = 9, // ==, != + Relational = 10, // >=, <=, >, < + Shift = 11, // <<, >> + Additive = 12, // -, + + Multiplicative = 13, // *, /, % + PointerToMember = 14 // .*, ->* + }; +} + +/// \brief Return the precedence of the specified binary operator token. +prec::Level getBinOpPrecedence(tok::TokenKind Kind, bool GreaterThanIsOperator, + bool CPlusPlus11); + +} // end namespace clang + +#endif // LLVM_CLANG_OPERATOR_PRECEDENCE_H diff --git a/include/clang/Basic/PartialDiagnostic.h b/include/clang/Basic/PartialDiagnostic.h index 3f4626e..3f68160 100644 --- a/include/clang/Basic/PartialDiagnostic.h +++ b/include/clang/Basic/PartialDiagnostic.h @@ -19,6 +19,7 @@ #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceLocation.h" #include "llvm/ADT/STLExtras.h" +#include "llvm/Support/Compiler.h" #include "llvm/Support/DataTypes.h" #include <cassert> @@ -200,6 +201,14 @@ public: } } +#if LLVM_HAS_RVALUE_REFERENCES + PartialDiagnostic(PartialDiagnostic &&Other) + : DiagID(Other.DiagID), DiagStorage(Other.DiagStorage), + Allocator(Other.Allocator) { + Other.DiagStorage = 0; + } +#endif + PartialDiagnostic(const PartialDiagnostic &Other, Storage *DiagStorage) : DiagID(Other.DiagID), DiagStorage(DiagStorage), Allocator(reinterpret_cast<StorageAllocator *>(~uintptr_t(0))) @@ -242,6 +251,19 @@ public: return *this; } +#if LLVM_HAS_RVALUE_REFERENCES + PartialDiagnostic &operator=(PartialDiagnostic &&Other) { + freeStorage(); + + DiagID = Other.DiagID; + DiagStorage = Other.DiagStorage; + Allocator = Other.Allocator; + + Other.DiagStorage = 0; + return *this; + } +#endif + ~PartialDiagnostic() { freeStorage(); } @@ -299,7 +321,7 @@ public: } void EmitToString(DiagnosticsEngine &Diags, - llvm::SmallVectorImpl<char> &Buf) const { + SmallVectorImpl<char> &Buf) const { // FIXME: It should be possible to render a diagnostic to a string without // messing with the state of the diagnostics engine. DiagnosticBuilder DB(Diags.Report(getDiagID())); diff --git a/include/clang/Basic/Sanitizers.def b/include/clang/Basic/Sanitizers.def index 085ca16..709ec8d 100644 --- a/include/clang/Basic/Sanitizers.def +++ b/include/clang/Basic/Sanitizers.def @@ -40,30 +40,61 @@ // AddressSanitizer SANITIZER("address", Address) +// More features of AddressSanitizer that should be turned on explicitly. +SANITIZER("init-order", InitOrder) +SANITIZER("use-after-return", UseAfterReturn) +SANITIZER("use-after-scope", UseAfterScope) + +SANITIZER_GROUP("address-full", AddressFull, + Address | InitOrder | UseAfterReturn | UseAfterScope) + +// MemorySanitizer +SANITIZER("memory", Memory) // ThreadSanitizer SANITIZER("thread", Thread) // UndefinedBehaviorSanitizer -SANITIZER("signed-integer-overflow", SignedIntegerOverflow) -SANITIZER("divide-by-zero", DivideByZero) +SANITIZER("alignment", Alignment) +SANITIZER("bool", Bool) +SANITIZER("bounds", Bounds) +SANITIZER("enum", Enum) +SANITIZER("float-cast-overflow", FloatCastOverflow) +SANITIZER("float-divide-by-zero", FloatDivideByZero) +SANITIZER("integer-divide-by-zero", IntegerDivideByZero) +SANITIZER("null", Null) +SANITIZER("object-size", ObjectSize) +SANITIZER("return", Return) SANITIZER("shift", Shift) +SANITIZER("signed-integer-overflow", SignedIntegerOverflow) SANITIZER("unreachable", Unreachable) -SANITIZER("return", Return) SANITIZER("vla-bound", VLABound) -SANITIZER("alignment", Alignment) -SANITIZER("null", Null) SANITIZER("vptr", Vptr) -SANITIZER("object-size", ObjectSize) -SANITIZER("float-cast-overflow", FloatCastOverflow) -// -fsanitize=undefined (and its alias -fcatch-undefined-behavior). This should -// include all the sanitizers which have low overhead, no ABI or address space -// layout implications, and only catch undefined behavior. +// IntegerSanitizer +SANITIZER("unsigned-integer-overflow", UnsignedIntegerOverflow) + +// -fsanitize=undefined includes all the sanitizers which have low overhead, no +// ABI or address space layout implications, and only catch undefined behavior. SANITIZER_GROUP("undefined", Undefined, - SignedIntegerOverflow | DivideByZero | Shift | Unreachable | - Return | VLABound | Alignment | Null | Vptr | ObjectSize | - FloatCastOverflow) + Alignment | Bool | Bounds | Enum | FloatCastOverflow | + FloatDivideByZero | IntegerDivideByZero | Null | ObjectSize | + Return | Shift | SignedIntegerOverflow | Unreachable | + VLABound | Vptr) + +// -fsanitize=undefined-trap (and its alias -fcatch-undefined-behavior) includes +// all sanitizers included by -fsanitize=undefined, except those that require +// runtime support. This group is generally used in conjunction with the +// -fsanitize-undefined-trap-on-error flag. +SANITIZER_GROUP("undefined-trap", UndefinedTrap, + Alignment | Bool | Bounds | Enum | FloatCastOverflow | + FloatDivideByZero | IntegerDivideByZero | Null | ObjectSize | + Return | Shift | SignedIntegerOverflow | Unreachable | + VLABound) + +SANITIZER_GROUP("integer", Integer, + SignedIntegerOverflow | UnsignedIntegerOverflow | Shift | + IntegerDivideByZero) #undef SANITIZER #undef SANITIZER_GROUP diff --git a/include/clang/Basic/SourceLocation.h b/include/clang/Basic/SourceLocation.h index cfcf468..143beb6 100644 --- a/include/clang/Basic/SourceLocation.h +++ b/include/clang/Basic/SourceLocation.h @@ -16,12 +16,12 @@ #define LLVM_CLANG_SOURCELOCATION_H #include "clang/Basic/LLVM.h" -#include "llvm/Support/PointerLikeTypeTraits.h" #include "llvm/Support/Compiler.h" -#include <utility> -#include <functional> +#include "llvm/Support/PointerLikeTypeTraits.h" #include <cassert> +#include <functional> #include <string> +#include <utility> namespace llvm { class MemoryBuffer; @@ -165,7 +165,7 @@ public: return (void*)(uintptr_t)getRawEncoding(); } - /// getFromPtrEncoding - Turn a pointer encoding of a SourceLocation object + /// \brief Turn a pointer encoding of a SourceLocation object back /// into a real SourceLocation. static SourceLocation getFromPtrEncoding(const void *Encoding) { return getFromRawEncoding((unsigned)(uintptr_t)Encoding); @@ -218,7 +218,7 @@ public: /// \brief Represents a character-granular source range. /// /// The underlying SourceRange can either specify the starting/ending character -/// of the range, or it can specify the start or the range and the start of the +/// of the range, or it can specify the start of the range and the start of the /// last token of the range (a "token range"). In the token range case, the /// size of the last token must be measured to determine the actual end of the /// range. @@ -227,20 +227,14 @@ class CharSourceRange { bool IsTokenRange; public: CharSourceRange() : IsTokenRange(false) {} - CharSourceRange(SourceRange R, bool ITR) : Range(R),IsTokenRange(ITR){} + CharSourceRange(SourceRange R, bool ITR) : Range(R), IsTokenRange(ITR) {} static CharSourceRange getTokenRange(SourceRange R) { - CharSourceRange Result; - Result.Range = R; - Result.IsTokenRange = true; - return Result; + return CharSourceRange(R, true); } static CharSourceRange getCharRange(SourceRange R) { - CharSourceRange Result; - Result.Range = R; - Result.IsTokenRange = false; - return Result; + return CharSourceRange(R, false); } static CharSourceRange getTokenRange(SourceLocation B, SourceLocation E) { diff --git a/include/clang/Basic/SourceManager.h b/include/clang/Basic/SourceManager.h index db6bfd2..00c96c3 100644 --- a/include/clang/Basic/SourceManager.h +++ b/include/clang/Basic/SourceManager.h @@ -10,7 +10,7 @@ /// \file /// \brief Defines the SourceManager interface. /// -/// There are three different types of locations in a file: a spelling +/// There are three different types of locations in a %file: a spelling /// location, an expansion location, and a presumed location. /// /// Given an example of: @@ -35,21 +35,22 @@ #ifndef LLVM_CLANG_SOURCEMANAGER_H #define LLVM_CLANG_SOURCEMANAGER_H -#include "clang/Basic/LLVM.h" #include "clang/Basic/FileManager.h" +#include "clang/Basic/LLVM.h" #include "clang/Basic/SourceLocation.h" -#include "llvm/Support/Allocator.h" -#include "llvm/Support/DataTypes.h" -#include "llvm/ADT/PointerIntPair.h" -#include "llvm/ADT/PointerUnion.h" -#include "llvm/ADT/IntrusiveRefCntPtr.h" -#include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseSet.h" +#include "llvm/ADT/IntrusiveRefCntPtr.h" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/PointerIntPair.h" +#include "llvm/ADT/PointerUnion.h" +#include "llvm/Support/Allocator.h" +#include "llvm/Support/DataTypes.h" #include "llvm/Support/MemoryBuffer.h" +#include <cassert> #include <map> #include <vector> -#include <cassert> namespace clang { @@ -78,7 +79,7 @@ namespace SrcMgr { }; /// \brief One instance of this struct is kept for every file loaded or used. - //// + /// /// This object owns the MemoryBuffer object. class ContentCache { enum CCFlags { @@ -270,7 +271,7 @@ namespace SrcMgr { return SourceLocation::getFromRawEncoding(IncludeLoc); } const ContentCache* getContentCache() const { - return reinterpret_cast<const ContentCache*>(Data & ~7UL); + return reinterpret_cast<const ContentCache*>(Data & ~uintptr_t(7)); } /// \brief Return whether this is a system header or not. @@ -328,6 +329,11 @@ namespace SrcMgr { SourceLocation::getFromRawEncoding(ExpansionLocEnd).isInvalid(); } + bool isMacroBodyExpansion() const { + return getExpansionLocStart().isValid() && + SourceLocation::getFromRawEncoding(ExpansionLocEnd).isValid(); + } + bool isFunctionMacroExpansion() const { return getExpansionLocStart().isValid() && getExpansionLocStart() != getExpansionLocEnd(); @@ -429,6 +435,11 @@ public: /// \returns true if an error occurred that prevented the source-location /// entry from being loaded. virtual bool ReadSLocEntry(int ID) = 0; + + /// \brief Retrieve the module import location and name for the given ID, if + /// in fact it was loaded from a module (rather than, say, a precompiled + /// header). + virtual std::pair<SourceLocation, StringRef> getModuleImportLoc(int ID) = 0; }; @@ -436,7 +447,7 @@ public: /// /// The cache structure is complex enough to be worth breaking out of /// SourceManager. -class IsBeforeInTranslationUnitCache { +class InBeforeInTUCacheEntry { /// \brief The FileID's of the cached query. /// /// If these match up with a subsequent query, the result can be reused. @@ -458,7 +469,6 @@ class IsBeforeInTranslationUnitCache { /// random token in the parent. unsigned LCommonOffset, RCommonOffset; public: - /// \brief Return true if the currently cached values match up with /// the specified LHS/RHS query. /// @@ -508,6 +518,11 @@ public: }; +/// \brief The stack used when building modules on demand, which is used +/// to provide a link between the source managers of the different compiler +/// instances. +typedef ArrayRef<std::pair<std::string, FullSourceLoc> > ModuleBuildStack; + /// \brief This class handles loading and caching of source files into memory. /// /// This object owns the MemoryBuffer objects for all of the loaded @@ -572,13 +587,13 @@ class SourceManager : public RefCountedBase<SourceManager> { /// /// Positive FileIDs are indexes into this table. Entry 0 indicates an invalid /// expansion. - std::vector<SrcMgr::SLocEntry> LocalSLocEntryTable; + SmallVector<SrcMgr::SLocEntry, 0> LocalSLocEntryTable; /// \brief The table of SLocEntries that are loaded from other modules. /// /// Negative FileIDs are indexes into this table. To get from ID to an index, /// use (-ID - 2). - mutable std::vector<SrcMgr::SLocEntry> LoadedSLocEntryTable; + mutable SmallVector<SrcMgr::SLocEntry, 0> LoadedSLocEntryTable; /// \brief The starting offset of the next local SLocEntry. /// @@ -631,8 +646,21 @@ class SourceManager : public RefCountedBase<SourceManager> { // Statistics for -print-stats. mutable unsigned NumLinearScans, NumBinaryProbes; - // Cache results for the isBeforeInTranslationUnit method. - mutable IsBeforeInTranslationUnitCache IsBeforeInTUCache; + /// The key value into the IsBeforeInTUCache table. + typedef std::pair<FileID, FileID> IsBeforeInTUCacheKey; + + /// The IsBeforeInTranslationUnitCache is a mapping from FileID pairs + /// to cache results. + typedef llvm::DenseMap<IsBeforeInTUCacheKey, InBeforeInTUCacheEntry> + InBeforeInTUCache; + + /// Cache results for the isBeforeInTranslationUnit method. + mutable InBeforeInTUCache IBTUCache; + mutable InBeforeInTUCacheEntry IBTUCacheOverflow; + + /// Return the cache entry for comparing the given file IDs + /// for isBeforeInTranslationUnit. + InBeforeInTUCacheEntry &getInBeforeInTUCache(FileID LFID, FileID RFID) const; // Cache for the "fake" buffer used for error-recovery purposes. mutable llvm::MemoryBuffer *FakeBufferForRecovery; @@ -645,6 +673,15 @@ class SourceManager : public RefCountedBase<SourceManager> { mutable llvm::DenseMap<FileID, MacroArgsMap *> MacroArgsCacheMap; + /// \brief The stack of modules being built, which is used to detect + /// cycles in the module dependency graph as modules are being built, as + /// well as to describe why we're rebuilding a particular module. + /// + /// There is no way to set this value from the command line. If we ever need + /// to do so (e.g., if on-demand module construction moves out-of-process), + /// we can add a cc1-level option to do so. + SmallVector<std::pair<std::string, FullSourceLoc>, 2> StoredModuleBuildStack; + // SourceManager doesn't support copy construction. explicit SourceManager(const SourceManager&) LLVM_DELETED_FUNCTION; void operator=(const SourceManager&) LLVM_DELETED_FUNCTION; @@ -669,6 +706,22 @@ public: /// (likely to change while trying to use them). bool userFilesAreVolatile() const { return UserFilesAreVolatile; } + /// \brief Retrieve the module build stack. + ModuleBuildStack getModuleBuildStack() const { + return StoredModuleBuildStack; + } + + /// \brief Set the module build stack. + void setModuleBuildStack(ModuleBuildStack stack) { + StoredModuleBuildStack.clear(); + StoredModuleBuildStack.append(stack.begin(), stack.end()); + } + + /// \brief Push an entry to the module build stack. + void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc) { + StoredModuleBuildStack.push_back(std::make_pair(moduleName.str(),importLoc)); + } + /// \brief Create the FileID for a memory buffer that will represent the /// FileID for the main source. /// @@ -959,6 +1012,21 @@ public: return Entry.getFile().getIncludeLoc(); } + // \brief Returns the import location if the given source location is + // located within a module, or an invalid location if the source location + // is within the current translation unit. + std::pair<SourceLocation, StringRef> + getModuleImportLoc(SourceLocation Loc) const { + FileID FID = getFileID(Loc); + + // Positive file IDs are in the current translation unit, and -1 is a + // placeholder. + if (FID.ID >= -1) + return std::make_pair(SourceLocation(), ""); + + return ExternalSLocEntries->getModuleImportLoc(FID.ID); + } + /// \brief Given a SourceLocation object \p Loc, return the expansion /// location referenced by the ID. SourceLocation getExpansionLoc(SourceLocation Loc) const { @@ -1075,6 +1143,13 @@ public: /// expanded. bool isMacroArgExpansion(SourceLocation Loc) const; + /// \brief Tests whether the given source location represents the expansion of + /// a macro body. + /// + /// This is equivalent to testing whether the location is part of a macro + /// expansion but not the expansion of an argument to a function-like macro. + bool isMacroBodyExpansion(SourceLocation Loc) const; + /// \brief Returns true if \p Loc is inside the [\p Start, +\p Length) /// chunk of the source location address space. /// @@ -1187,7 +1262,8 @@ public: /// presumed location cannot be calculate (e.g., because \p Loc is invalid /// or the file containing \p Loc has changed on disk), returns an invalid /// presumed location. - PresumedLoc getPresumedLoc(SourceLocation Loc) const; + PresumedLoc getPresumedLoc(SourceLocation Loc, + bool UseLineDirectives = true) const; /// \brief Returns true if both SourceLocations correspond to the same file. bool isFromSameFile(SourceLocation Loc1, SourceLocation Loc2) const { @@ -1421,40 +1497,13 @@ public: return !isLoadedFileID(FID); } - /// Get a presumed location suitable for displaying in a diagnostic message, - /// taking into account macro arguments and expansions. - PresumedLoc getPresumedLocForDisplay(SourceLocation Loc) const { - // This is a condensed form of the algorithm used by emitCaretDiagnostic to - // walk to the top of the macro call stack. - while (Loc.isMacroID()) { - Loc = skipToMacroArgExpansion(Loc); - Loc = getImmediateMacroCallerLoc(Loc); - } - - return getPresumedLoc(Loc); - } - - /// Look through spelling locations for a macro argument expansion, and if - /// found skip to it so that we can trace the argument rather than the macros - /// in which that argument is used. If no macro argument expansion is found, - /// don't skip anything and return the starting location. - SourceLocation skipToMacroArgExpansion(SourceLocation StartLoc) const { - for (SourceLocation L = StartLoc; L.isMacroID(); - L = getImmediateSpellingLoc(L)) { - if (isMacroArgExpansion(L)) - return L; - } - // Otherwise just return initial location, there's nothing to skip. - return StartLoc; - } - /// Gets the location of the immediate macro caller, one level up the stack /// toward the initial macro typed into the source. SourceLocation getImmediateMacroCallerLoc(SourceLocation Loc) const { if (!Loc.isMacroID()) return Loc; // When we have the location of (part of) an expanded parameter, its - // spelling location points to the argument as typed into the macro call, + // spelling location points to the argument as expanded in the macro call, // and therefore is used to locate the macro caller. if (isMacroArgExpansion(Loc)) return getImmediateSpellingLoc(Loc); @@ -1464,22 +1513,6 @@ public: return getImmediateExpansionRange(Loc).first; } - /// Gets the location of the immediate macro callee, one level down the stack - /// toward the leaf macro. - SourceLocation getImmediateMacroCalleeLoc(SourceLocation Loc) const { - if (!Loc.isMacroID()) return Loc; - - // When we have the location of (part of) an expanded parameter, its - // expansion location points to the unexpanded parameter reference within - // the macro definition (or callee). - if (isMacroArgExpansion(Loc)) - return getImmediateExpansionRange(Loc).first; - - // Otherwise, the callee of the macro is located where this location was - // spelled inside the macro definition. - return getImmediateSpellingLoc(Loc); - } - private: const llvm::MemoryBuffer *getFakeBufferForRecovery() const; const SrcMgr::ContentCache *getFakeContentCacheForRecovery() const; @@ -1599,4 +1632,5 @@ public: } // end namespace clang + #endif diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h index c82b8cb..8706179 100644 --- a/include/clang/Basic/Specifiers.h +++ b/include/clang/Basic/Specifiers.h @@ -62,13 +62,21 @@ namespace clang { TST_auto, // C++0x auto TST_unknown_anytype, // __unknown_anytype extension TST_atomic, // C11 _Atomic + TST_image1d_t, // OpenCL image1d_t + TST_image1d_array_t, // OpenCL image1d_array_t + TST_image1d_buffer_t, // OpenCL image1d_buffer_t + TST_image2d_t, // OpenCL image2d_t + TST_image2d_array_t, // OpenCL image2d_array_t + TST_image3d_t, // OpenCL image3d_t + TST_sampler_t, // OpenCL sampler_t + TST_event_t, // OpenCL event_t TST_error // erroneous type }; /// \brief Structure that packs information about the type specifiers that /// were written in a particular type specifier sequence. struct WrittenBuiltinSpecs { - /*DeclSpec::TST*/ unsigned Type : 5; + /*DeclSpec::TST*/ unsigned Type : 6; /*DeclSpec::TSS*/ unsigned Sign : 2; /*DeclSpec::TSW*/ unsigned Width : 2; bool ModeAttr : 1; @@ -186,7 +194,8 @@ namespace clang { CC_X86Pascal, // __attribute__((pascal)) CC_AAPCS, // __attribute__((pcs("aapcs"))) CC_AAPCS_VFP, // __attribute__((pcs("aapcs-vfp"))) - CC_PnaclCall // __attribute__((pnaclcall)) + CC_PnaclCall, // __attribute__((pnaclcall)) + CC_IntelOclBicc // __attribute__((intel_ocl_bicc)) }; } // end namespace clang diff --git a/include/clang/Basic/TargetCXXABI.h b/include/clang/Basic/TargetCXXABI.h new file mode 100644 index 0000000..c9d28f8 --- /dev/null +++ b/include/clang/Basic/TargetCXXABI.h @@ -0,0 +1,261 @@ +//===--- TargetCXXABI.h - C++ ABI Target Configuration ----------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief Defines the TargetCXXABI class, which abstracts details of the +/// C++ ABI that we're targeting. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_TARGETCXXABI_H +#define LLVM_CLANG_TARGETCXXABI_H + +#include "llvm/ADT/Triple.h" +#include "llvm/Support/ErrorHandling.h" + +namespace clang { + +/// \brief The basic abstraction for the target C++ ABI. +class TargetCXXABI { +public: + /// \brief The basic C++ ABI kind. + enum Kind { + /// The generic Itanium ABI is the standard ABI of most open-source + /// and Unix-like platforms. It is the primary ABI targeted by + /// many compilers, including Clang and GCC. + /// + /// It is documented here: + /// http://www.codesourcery.com/public/cxx-abi/ + GenericItanium, + + /// The generic ARM ABI is a modified version of the Itanium ABI + /// proposed by ARM for use on ARM-based platforms. + /// + /// These changes include: + /// - the representation of member function pointers is adjusted + /// to not conflict with the 'thumb' bit of ARM function pointers; + /// - constructors and destructors return 'this'; + /// - guard variables are smaller; + /// - inline functions are never key functions; + /// - array cookies have a slightly different layout; + /// - additional convenience functions are specified; + /// - and more! + /// + /// It is documented here: + /// http://infocenter.arm.com + /// /help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf + GenericARM, + + /// The iOS ABI is a partial implementation of the ARM ABI. + /// Several of the features of the ARM ABI were not fully implemented + /// in the compilers that iOS was launched with. + /// + /// Essentially, the iOS ABI includes the ARM changes to: + /// - member function pointers, + /// - guard variables, + /// - array cookies, and + /// - constructor/destructor signatures. + iOS, + + /// The generic AArch64 ABI is also a modified version of the Itanium ABI, + /// but it has fewer divergences than the 32-bit ARM ABI. + /// + /// The relevant changes from the generic ABI in this case are: + /// - representation of member function pointers adjusted as in ARM. + /// - guard variables are smaller. + GenericAArch64, + + /// The Microsoft ABI is the ABI used by Microsoft Visual Studio (and + /// compatible compilers). + /// + /// FIXME: should this be split into Win32 and Win64 variants? + /// + /// Only scattered and incomplete official documentation exists. + Microsoft + }; + +private: + // Right now, this class is passed around as a cheap value type. + // If you add more members, especially non-POD members, please + // audit the users to pass it by reference instead. + Kind TheKind; + +public: + /// A bogus initialization of the platform ABI. + TargetCXXABI() : TheKind(GenericItanium) {} + + TargetCXXABI(Kind kind) : TheKind(kind) {} + + void set(Kind kind) { + TheKind = kind; + } + + Kind getKind() const { return TheKind; } + + /// \brief Does this ABI generally fall into the Itanium family of ABIs? + bool isItaniumFamily() const { + switch (getKind()) { + case GenericAArch64: + case GenericItanium: + case GenericARM: + case iOS: + return true; + + case Microsoft: + return false; + } + llvm_unreachable("bad ABI kind"); + } + + /// \brief Is this ABI an MSVC-compatible ABI? + bool isMicrosoft() const { + switch (getKind()) { + case GenericAArch64: + case GenericItanium: + case GenericARM: + case iOS: + return false; + + case Microsoft: + return true; + } + llvm_unreachable("bad ABI kind"); + } + + /// \brief Is the default C++ member function calling convention + /// the same as the default calling convention? + bool isMemberFunctionCCDefault() const { + // Right now, this is always true for Microsoft. + return !isMicrosoft(); + } + + /// \brief Does this ABI have different entrypoints for complete-object + /// and base-subobject constructors? + bool hasConstructorVariants() const { + return isItaniumFamily(); + } + + /// \brief Does this ABI have different entrypoints for complete-object + /// and base-subobject destructors? + bool hasDestructorVariants() const { + return isItaniumFamily(); + } + + /// \brief Does this ABI allow virtual bases to be primary base classes? + bool hasPrimaryVBases() const { + return isItaniumFamily(); + } + + /// \brief Can an out-of-line inline function serve as a key function? + /// + /// This flag is only useful in ABIs where type data (for example, + /// v-tables and type_info objects) are emitted only after processing + /// the definition of a special "key" virtual function. (This is safe + /// because the ODR requires that every virtual function be defined + /// somewhere in a program.) This usually permits such data to be + /// emitted in only a single object file, as opposed to redundantly + /// in every object file that requires it. + /// + /// One simple and common definition of "key function" is the first + /// virtual function in the class definition which is not defined there. + /// This rule works very well when that function has a non-inline + /// definition in some non-header file. Unfortunately, when that + /// function is defined inline, this rule requires the type data + /// to be emitted weakly, as if there were no key function. + /// + /// The ARM ABI observes that the ODR provides an additional guarantee: + /// a virtual function is always ODR-used, so if it is defined inline, + /// that definition must appear in every translation unit that defines + /// the class. Therefore, there is no reason to allow such functions + /// to serve as key functions. + /// + /// Because this changes the rules for emitting type data, + /// it can cause type data to be emitted with both weak and strong + /// linkage, which is not allowed on all platforms. Therefore, + /// exploiting this observation requires an ABI break and cannot be + /// done on a generic Itanium platform. + bool canKeyFunctionBeInline() const { + switch (getKind()) { + case GenericARM: + return false; + + case GenericAArch64: + case GenericItanium: + case iOS: // old iOS compilers did not follow this rule + case Microsoft: + return true; + } + llvm_unreachable("bad ABI kind"); + } + + /// When is record layout allowed to allocate objects in the tail + /// padding of a base class? + /// + /// This decision cannot be changed without breaking platform ABI + /// compatibility, and yet it is tied to language guarantees which + /// the committee has so far seen fit to strengthen no less than + /// three separate times: + /// - originally, there were no restrictions at all; + /// - C++98 declared that objects could not be allocated in the + /// tail padding of a POD type; + /// - C++03 extended the definition of POD to include classes + /// containing member pointers; and + /// - C++11 greatly broadened the definition of POD to include + /// all trivial standard-layout classes. + /// Each of these changes technically took several existing + /// platforms and made them permanently non-conformant. + enum TailPaddingUseRules { + /// The tail-padding of a base class is always theoretically + /// available, even if it's POD. This is not strictly conforming + /// in any language mode. + AlwaysUseTailPadding, + + /// Only allocate objects in the tail padding of a base class if + /// the base class is not POD according to the rules of C++ TR1. + /// This is non strictly conforming in C++11 mode. + UseTailPaddingUnlessPOD03, + + /// Only allocate objects in the tail padding of a base class if + /// the base class is not POD according to the rules of C++11. + UseTailPaddingUnlessPOD11 + }; + TailPaddingUseRules getTailPaddingUseRules() const { + switch (getKind()) { + // To preserve binary compatibility, the generic Itanium ABI has + // permanently locked the definition of POD to the rules of C++ TR1, + // and that trickles down to all the derived ABIs. + case GenericItanium: + case GenericAArch64: + case GenericARM: + case iOS: + return UseTailPaddingUnlessPOD03; + + // MSVC always allocates fields in the tail-padding of a base class + // subobject, even if they're POD. + case Microsoft: + return AlwaysUseTailPadding; + } + llvm_unreachable("bad ABI kind"); + } + + /// Try to parse an ABI name, returning false on error. + bool tryParse(llvm::StringRef name); + + friend bool operator==(const TargetCXXABI &left, const TargetCXXABI &right) { + return left.getKind() == right.getKind(); + } + + friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right) { + return !(left == right); + } +}; + +} // end namespace clang + +#endif diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h index 2d26783..c05f062 100644 --- a/include/clang/Basic/TargetInfo.h +++ b/include/clang/Basic/TargetInfo.h @@ -15,20 +15,21 @@ #ifndef LLVM_CLANG_BASIC_TARGETINFO_H #define LLVM_CLANG_BASIC_TARGETINFO_H +#include "clang/Basic/AddressSpaces.h" +#include "clang/Basic/TargetCXXABI.h" #include "clang/Basic/LLVM.h" +#include "clang/Basic/Specifiers.h" +#include "clang/Basic/TargetOptions.h" +#include "clang/Basic/VersionTuple.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/ADT/Triple.h" #include "llvm/Support/DataTypes.h" -#include "clang/Basic/AddressSpaces.h" -#include "clang/Basic/TargetOptions.h" -#include "clang/Basic/VersionTuple.h" -#include "clang/Basic/Specifiers.h" #include <cassert> -#include <vector> #include <string> +#include <vector> namespace llvm { struct fltSemantics; @@ -43,26 +44,10 @@ class SourceManager; namespace Builtin { struct Info; } -/// \brief The types of C++ ABIs for which we can generate code. -enum TargetCXXABI { - /// The generic ("Itanium") C++ ABI, documented at: - /// http://www.codesourcery.com/public/cxx-abi/ - CXXABI_Itanium, - - /// The ARM C++ ABI, based largely on the Itanium ABI but with - /// significant differences. - /// http://infocenter.arm.com - /// /help/topic/com.arm.doc.ihi0041c/IHI0041C_cppabi.pdf - CXXABI_ARM, - - /// The Visual Studio ABI. Only scattered official documentation exists. - CXXABI_Microsoft -}; - /// \brief Exposes information about the current target. /// class TargetInfo : public RefCountedBase<TargetInfo> { - llvm::IntrusiveRefCntPtr<TargetOptions> TargetOpts; + IntrusiveRefCntPtr<TargetOptions> TargetOpts; llvm::Triple Triple; protected: // Target values set by the ctor of the actual target implementation. Default @@ -89,7 +74,7 @@ protected: const llvm::fltSemantics *HalfFormat, *FloatFormat, *DoubleFormat, *LongDoubleFormat; unsigned char RegParmMax, SSERegParmMax; - TargetCXXABI CXXABI; + TargetCXXABI TheCXXABI; const LangAS::Map *AddrSpaceMap; mutable StringRef PlatformName; @@ -109,7 +94,7 @@ public: /// modify the options to canonicalize the target feature information to match /// what the backend expects. static TargetInfo* CreateTargetInfo(DiagnosticsEngine &Diags, - TargetOptions &Opts); + TargetOptions *Opts); virtual ~TargetInfo(); @@ -119,8 +104,8 @@ public: return *TargetOpts; } - void setTargetOpts(TargetOptions &TargetOpts) { - this->TargetOpts = &TargetOpts; + void setTargetOpts(TargetOptions *TargetOpts) { + this->TargetOpts = TargetOpts; } ///===---- Target Data Type Query Methods -------------------------------===// @@ -151,6 +136,10 @@ public: /// typedef void* __builtin_va_list; VoidPtrBuiltinVaList, + /// __builtin_va_list as defind by the AArch64 ABI + /// http://infocenter.arm.com/help/topic/com.arm.doc.ihi0055a/IHI0055A_aapcs64.pdf + AArch64ABIBuiltinVaList, + /// __builtin_va_list as defined by the PNaCl ABI: /// http://www.chromium.org/nativeclient/pnacl/bitcode-abi#TOC-Machine-Types PNaClABIBuiltinVaList, @@ -270,6 +259,9 @@ public: unsigned getLongLongWidth() const { return LongLongWidth; } unsigned getLongLongAlign() const { return LongLongAlign; } + /// \brief Determine whether the __int128 type is supported on this target. + bool hasInt128Type() const { return getPointerWidth(0) >= 64; } // FIXME + /// \brief Return the alignment that is suitable for storing any /// object with a fundamental alignment requirement. unsigned getSuitableAlign() const { return SuitableAlign; } @@ -335,6 +327,9 @@ public: return getTypeWidth(IntMaxType); } + // Return the size of unwind_word for this target. + unsigned getUnwindWordWidth() const { return getPointerWidth(0); } + /// \brief Return the "preferred" register width on this target. uint64_t getRegisterWidth() const { // Currently we assume the register width on the target matches the pointer @@ -518,6 +513,10 @@ public: bool validateInputConstraint(ConstraintInfo *OutputConstraints, unsigned NumOutputs, ConstraintInfo &info) const; + virtual bool validateInputSize(StringRef /*Constraint*/, + unsigned /*Size*/) const { + return true; + } virtual bool validateConstraintModifier(StringRef /*Constraint*/, const char /*Modifier*/, unsigned /*Size*/) const { @@ -572,8 +571,6 @@ public: /// either; the entire thing is pretty badly mangled. virtual bool hasProtectedVisibility() const { return true; } - virtual bool useGlobalsForAutomaticVariables() const { return false; } - /// \brief Return the section to use for CFString literals, or 0 if no /// special section is used. virtual const char *getCFStringSection() const { @@ -624,8 +621,8 @@ public: } /// \brief Get the C++ ABI currently in use. - virtual TargetCXXABI getCXXABI() const { - return CXXABI; + TargetCXXABI getCXXABI() const { + return TheCXXABI; } /// \brief Target the specified CPU. @@ -645,14 +642,9 @@ public: /// \brief Use this specified C++ ABI. /// /// \return False on error (invalid C++ ABI name). - bool setCXXABI(const std::string &Name) { - static const TargetCXXABI Unknown = static_cast<TargetCXXABI>(-1); - TargetCXXABI ABI = llvm::StringSwitch<TargetCXXABI>(Name) - .Case("arm", CXXABI_ARM) - .Case("itanium", CXXABI_Itanium) - .Case("microsoft", CXXABI_Microsoft) - .Default(Unknown); - if (ABI == Unknown) return false; + bool setCXXABI(llvm::StringRef name) { + TargetCXXABI ABI; + if (!ABI.tryParse(name)) return false; return setCXXABI(ABI); } @@ -660,7 +652,7 @@ public: /// /// \return False on error (ABI not valid on this target) virtual bool setCXXABI(TargetCXXABI ABI) { - CXXABI = ABI; + TheCXXABI = ABI; return true; } @@ -735,13 +727,19 @@ public: bool isBigEndian() const { return BigEndian; } + enum CallingConvMethodType { + CCMT_Unknown, + CCMT_Member, + CCMT_NonMember + }; + /// \brief Gets the default calling convention for the given target and /// declaration context. - virtual CallingConv getDefaultCallingConv() const { + virtual CallingConv getDefaultCallingConv(CallingConvMethodType MT) const { // Not all targets will specify an explicit calling convention that we can // express. This will always do the right thing, even though it's not // an explicit calling convention. - return CC_Default; + return CC_C; } enum CallingConvCheckResult { diff --git a/include/clang/Basic/TargetOptions.h b/include/clang/Basic/TargetOptions.h index d6deb02..c2183fd 100644 --- a/include/clang/Basic/TargetOptions.h +++ b/include/clang/Basic/TargetOptions.h @@ -15,6 +15,7 @@ #ifndef LLVM_CLANG_FRONTEND_TARGETOPTIONS_H #define LLVM_CLANG_FRONTEND_TARGETOPTIONS_H +#include "clang/Basic/LLVM.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" #include <string> #include <vector> diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def index 25e8d5a..a254fae 100644 --- a/include/clang/Basic/TokenKinds.def +++ b/include/clang/Basic/TokenKinds.def @@ -121,7 +121,7 @@ TOK(numeric_constant) // 0x123 TOK(char_constant) // 'a' TOK(wide_char_constant) // L'b' -// C++0x Character Constants +// C++11 Character Constants TOK(utf16_char_constant) // u'a' TOK(utf32_char_constant) // U'a' @@ -130,7 +130,7 @@ TOK(string_literal) // "foo" TOK(wide_string_literal) // L"foo" TOK(angle_string_literal)// <foo> -// C++0x String Literals. +// C++11 String Literals. TOK(utf8_string_literal) // u8"foo" TOK(utf16_string_literal)// u"foo" TOK(utf32_string_literal)// U"foo" @@ -208,7 +208,7 @@ PUNCTUATOR(greatergreatergreater, ">>>") // KEYCXX - This is a C++ keyword, or a C++-specific keyword in the // implementation namespace // KEYNOCXX - This is a keyword in every non-C++ dialect. -// KEYCXX0X - This is a C++ keyword introduced to C++ in C++0x +// KEYCXX11 - This is a C++ keyword introduced to C++ in C++11 // KEYGNU - This is a keyword if GNU extensions are enabled // KEYMS - This is a keyword if Microsoft extensions are enabled // KEYNOMS - This is a keyword that must never be enabled under @@ -260,6 +260,7 @@ KEYWORD(_Bool , KEYNOCXX) KEYWORD(_Complex , KEYALL) KEYWORD(_Generic , KEYALL) KEYWORD(_Imaginary , KEYALL) +KEYWORD(_Noreturn , KEYALL) KEYWORD(_Static_assert , KEYALL) KEYWORD(__func__ , KEYALL) KEYWORD(__objc_yes , KEYALL) @@ -311,17 +312,17 @@ CXX_KEYWORD_OPERATOR(or_eq , pipeequal) CXX_KEYWORD_OPERATOR(xor , caret) CXX_KEYWORD_OPERATOR(xor_eq , caretequal) -// C++0x keywords -KEYWORD(alignas , KEYCXX0X) -KEYWORD(alignof , KEYCXX0X) -KEYWORD(char16_t , KEYCXX0X|KEYNOMS) -KEYWORD(char32_t , KEYCXX0X|KEYNOMS) -KEYWORD(constexpr , KEYCXX0X) -KEYWORD(decltype , KEYCXX0X) -KEYWORD(noexcept , KEYCXX0X) -KEYWORD(nullptr , KEYCXX0X) -KEYWORD(static_assert , KEYCXX0X) -KEYWORD(thread_local , KEYCXX0X) +// C++11 keywords +KEYWORD(alignas , KEYCXX11) +KEYWORD(alignof , KEYCXX11) +KEYWORD(char16_t , KEYCXX11|KEYNOMS) +KEYWORD(char32_t , KEYCXX11|KEYNOMS) +KEYWORD(constexpr , KEYCXX11) +KEYWORD(decltype , KEYCXX11) +KEYWORD(noexcept , KEYCXX11) +KEYWORD(nullptr , KEYCXX11) +KEYWORD(static_assert , KEYCXX11) +KEYWORD(thread_local , KEYCXX11) // GNU Extensions (in impl-reserved namespace) KEYWORD(_Decimal32 , KEYALL) @@ -350,31 +351,34 @@ KEYWORD(typeof , KEYGNU) KEYWORD(L__FUNCTION__ , KEYMS) // GNU and MS Type Traits -KEYWORD(__has_nothrow_assign , KEYCXX) -KEYWORD(__has_nothrow_copy , KEYCXX) -KEYWORD(__has_nothrow_constructor , KEYCXX) -KEYWORD(__has_trivial_assign , KEYCXX) -KEYWORD(__has_trivial_copy , KEYCXX) -KEYWORD(__has_trivial_constructor , KEYCXX) -KEYWORD(__has_trivial_destructor , KEYCXX) -KEYWORD(__has_virtual_destructor , KEYCXX) -KEYWORD(__is_abstract , KEYCXX) -KEYWORD(__is_base_of , KEYCXX) -KEYWORD(__is_class , KEYCXX) -KEYWORD(__is_convertible_to , KEYCXX) -KEYWORD(__is_empty , KEYCXX) -KEYWORD(__is_enum , KEYCXX) -KEYWORD(__is_final , KEYCXX) -KEYWORD(__is_interface_class , KEYCXX) +KEYWORD(__has_nothrow_assign , KEYCXX) +KEYWORD(__has_nothrow_move_assign , KEYCXX) +KEYWORD(__has_nothrow_copy , KEYCXX) +KEYWORD(__has_nothrow_constructor , KEYCXX) +KEYWORD(__has_trivial_assign , KEYCXX) +KEYWORD(__has_trivial_move_assign , KEYCXX) +KEYWORD(__has_trivial_copy , KEYCXX) +KEYWORD(__has_trivial_constructor , KEYCXX) +KEYWORD(__has_trivial_move_constructor, KEYCXX) +KEYWORD(__has_trivial_destructor , KEYCXX) +KEYWORD(__has_virtual_destructor , KEYCXX) +KEYWORD(__is_abstract , KEYCXX) +KEYWORD(__is_base_of , KEYCXX) +KEYWORD(__is_class , KEYCXX) +KEYWORD(__is_convertible_to , KEYCXX) +KEYWORD(__is_empty , KEYCXX) +KEYWORD(__is_enum , KEYCXX) +KEYWORD(__is_final , KEYCXX) +KEYWORD(__is_interface_class , KEYCXX) // Tentative name - there's no implementation of std::is_literal_type yet. -KEYWORD(__is_literal , KEYCXX) +KEYWORD(__is_literal , KEYCXX) // Name for GCC 4.6 compatibility - people have already written libraries using // this name unfortunately. -KEYWORD(__is_literal_type , KEYCXX) -KEYWORD(__is_pod , KEYCXX) -KEYWORD(__is_polymorphic , KEYCXX) -KEYWORD(__is_trivial , KEYCXX) -KEYWORD(__is_union , KEYCXX) +KEYWORD(__is_literal_type , KEYCXX) +KEYWORD(__is_pod , KEYCXX) +KEYWORD(__is_polymorphic , KEYCXX) +KEYWORD(__is_trivial , KEYCXX) +KEYWORD(__is_union , KEYCXX) // Clang-only C++ Type Traits KEYWORD(__is_trivially_constructible, KEYCXX) @@ -448,6 +452,14 @@ ALIAS("read_only", __read_only , KEYOPENCL) ALIAS("write_only", __write_only , KEYOPENCL) ALIAS("read_write", __read_write , KEYOPENCL) KEYWORD(__builtin_astype , KEYOPENCL) +KEYWORD(image1d_t , KEYOPENCL) +KEYWORD(image1d_array_t , KEYOPENCL) +KEYWORD(image1d_buffer_t , KEYOPENCL) +KEYWORD(image2d_t , KEYOPENCL) +KEYWORD(image2d_array_t , KEYOPENCL) +KEYWORD(image3d_t , KEYOPENCL) +KEYWORD(sampler_t , KEYOPENCL) +KEYWORD(event_t , KEYOPENCL) // Borland Extensions. KEYWORD(__pascal , KEYALL) @@ -566,7 +578,7 @@ OBJC2_AT_KEYWORD(required) OBJC2_AT_KEYWORD(optional) OBJC2_AT_KEYWORD(synthesize) OBJC2_AT_KEYWORD(dynamic) -OBJC2_AT_KEYWORD(__experimental_modules_import) +OBJC2_AT_KEYWORD(import) // TODO: What to do about context-sensitive keywords like: // bycopy/byref/in/inout/oneway/out? @@ -637,6 +649,12 @@ ANNOTATION(pragma_fp_contract) // handles them. ANNOTATION(pragma_opencl_extension) +// Annotations for OpenMP pragma directives - #pragma omp ... +// The lexer produces these so that they only take effect when the parser +// handles #pragma omp ... directives. +ANNOTATION(pragma_openmp) +ANNOTATION(pragma_openmp_end) + #undef ANNOTATION #undef TESTING_KEYWORD #undef OBJC2_AT_KEYWORD diff --git a/include/clang/Basic/TokenKinds.h b/include/clang/Basic/TokenKinds.h index e850971..dcbe1da 100644 --- a/include/clang/Basic/TokenKinds.h +++ b/include/clang/Basic/TokenKinds.h @@ -68,15 +68,21 @@ inline bool isAnyIdentifier(TokenKind K) { return (K == tok::identifier) || (K == tok::raw_identifier); } +/// \brief Return true if this is a C or C++ string-literal (or +/// C++11 user-defined-string-literal) token. +inline bool isStringLiteral(TokenKind K) { + return K == tok::string_literal || K == tok::wide_string_literal || + K == tok::utf8_string_literal || K == tok::utf16_string_literal || + K == tok::utf32_string_literal; +} + /// \brief Return true if this is a "literal" kind, like a numeric /// constant, string, etc. inline bool isLiteral(TokenKind K) { - return (K == tok::numeric_constant) || (K == tok::char_constant) || - (K == tok::wide_char_constant) || (K == tok::utf16_char_constant) || - (K == tok::utf32_char_constant) || (K == tok::string_literal) || - (K == tok::wide_string_literal) || (K == tok::utf8_string_literal) || - (K == tok::utf16_string_literal) || (K == tok::utf32_string_literal) || - (K == tok::angle_string_literal); + return K == tok::numeric_constant || K == tok::char_constant || + K == tok::wide_char_constant || K == tok::utf16_char_constant || + K == tok::utf32_char_constant || isStringLiteral(K) || + K == tok::angle_string_literal; } /// \brief Return true if this is any of tok::annot_* kinds. diff --git a/include/clang/Basic/TypeTraits.h b/include/clang/Basic/TypeTraits.h index 882b52d..1645796 100644 --- a/include/clang/Basic/TypeTraits.h +++ b/include/clang/Basic/TypeTraits.h @@ -20,11 +20,14 @@ namespace clang { /// \brief Names for the unary type traits. enum UnaryTypeTrait { UTT_HasNothrowAssign, + UTT_HasNothrowMoveAssign, UTT_HasNothrowCopy, UTT_HasNothrowConstructor, UTT_HasTrivialAssign, + UTT_HasTrivialMoveAssign, UTT_HasTrivialCopy, UTT_HasTrivialDefaultConstructor, + UTT_HasTrivialMoveConstructor, UTT_HasTrivialDestructor, UTT_HasVirtualDestructor, UTT_IsAbstract, diff --git a/include/clang/Basic/Version.h b/include/clang/Basic/Version.h index 3f1b4d8..7db8a2e 100644 --- a/include/clang/Basic/Version.h +++ b/include/clang/Basic/Version.h @@ -16,9 +16,8 @@ #ifndef LLVM_CLANG_BASIC_VERSION_H #define LLVM_CLANG_BASIC_VERSION_H -#include "llvm/ADT/StringRef.h" - #include "clang/Basic/Version.inc" +#include "llvm/ADT/StringRef.h" /// \brief Helper macro for CLANG_VERSION_STRING. #define CLANG_MAKE_VERSION_STRING2(X) #X diff --git a/include/clang/Basic/VersionTuple.h b/include/clang/Basic/VersionTuple.h index a94f76c..ff06a5c 100644 --- a/include/clang/Basic/VersionTuple.h +++ b/include/clang/Basic/VersionTuple.h @@ -55,16 +55,16 @@ public: unsigned getMajor() const { return Major; } /// \brief Retrieve the minor version number, if provided. - llvm::Optional<unsigned> getMinor() const { + Optional<unsigned> getMinor() const { if (!HasMinor) - return llvm::Optional<unsigned>(); + return None; return Minor; } /// \brief Retrieve the subminor version number, if provided. - llvm::Optional<unsigned> getSubminor() const { + Optional<unsigned> getSubminor() const { if (!HasSubminor) - return llvm::Optional<unsigned>(); + return None; return Subminor; } diff --git a/include/clang/Basic/Visibility.h b/include/clang/Basic/Visibility.h index e81ad91..b623b94 100644 --- a/include/clang/Basic/Visibility.h +++ b/include/clang/Basic/Visibility.h @@ -15,6 +15,8 @@ #ifndef LLVM_CLANG_BASIC_VISIBILITY_H #define LLVM_CLANG_BASIC_VISIBILITY_H +#include "clang/Basic/Linkage.h" + namespace clang { /// \brief Describes the different kinds of visibility that a declaration @@ -46,6 +48,80 @@ inline Visibility minVisibility(Visibility L, Visibility R) { return L < R ? L : R; } +class LinkageInfo { + uint8_t linkage_ : 2; + uint8_t visibility_ : 2; + uint8_t explicit_ : 1; + + void setVisibility(Visibility V, bool E) { visibility_ = V; explicit_ = E; } +public: + LinkageInfo() : linkage_(ExternalLinkage), visibility_(DefaultVisibility), + explicit_(false) {} + LinkageInfo(Linkage L, Visibility V, bool E) + : linkage_(L), visibility_(V), explicit_(E) { + assert(getLinkage() == L && getVisibility() == V && + isVisibilityExplicit() == E && "Enum truncated!"); + } + + static LinkageInfo external() { + return LinkageInfo(); + } + static LinkageInfo internal() { + return LinkageInfo(InternalLinkage, DefaultVisibility, false); + } + static LinkageInfo uniqueExternal() { + return LinkageInfo(UniqueExternalLinkage, DefaultVisibility, false); + } + static LinkageInfo none() { + return LinkageInfo(NoLinkage, DefaultVisibility, false); + } + + Linkage getLinkage() const { return (Linkage)linkage_; } + Visibility getVisibility() const { return (Visibility)visibility_; } + bool isVisibilityExplicit() const { return explicit_; } + + void setLinkage(Linkage L) { linkage_ = L; } + + void mergeLinkage(Linkage L) { + setLinkage(minLinkage(getLinkage(), L)); + } + void mergeLinkage(LinkageInfo other) { + mergeLinkage(other.getLinkage()); + } + + /// Merge in the visibility 'newVis'. + void mergeVisibility(Visibility newVis, bool newExplicit) { + Visibility oldVis = getVisibility(); + + // Never increase visibility. + if (oldVis < newVis) + return; + + // If the new visibility is the same as the old and the new + // visibility isn't explicit, we have nothing to add. + if (oldVis == newVis && !newExplicit) + return; + + // Otherwise, we're either decreasing visibility or making our + // existing visibility explicit. + setVisibility(newVis, newExplicit); + } + void mergeVisibility(LinkageInfo other) { + mergeVisibility(other.getVisibility(), other.isVisibilityExplicit()); + } + + /// Merge both linkage and visibility. + void merge(LinkageInfo other) { + mergeLinkage(other); + mergeVisibility(other); + } + + /// Merge linkage and conditionally merge visibility. + void mergeMaybeWithVisibility(LinkageInfo other, bool withVis) { + mergeLinkage(other); + if (withVis) mergeVisibility(other); + } +}; } #endif // LLVM_CLANG_BASIC_VISIBILITY_H |
