diff options
| author | dim <dim@FreeBSD.org> | 2012-12-02 13:20:44 +0000 |
|---|---|---|
| committer | dim <dim@FreeBSD.org> | 2012-12-02 13:20:44 +0000 |
| commit | 056abd2059c65a3e908193aeae16fad98017437c (patch) | |
| tree | 2732d02d7d51218d6eed98ac7fcfc5b8794896b5 /include/clang/Basic | |
| parent | cc73504950eb7b5dff2dded9bedd67bc36d64641 (diff) | |
| download | FreeBSD-src-056abd2059c65a3e908193aeae16fad98017437c.zip FreeBSD-src-056abd2059c65a3e908193aeae16fad98017437c.tar.gz | |
Vendor import of clang release_32 branch r168974 (effectively, 3.2 RC2):
http://llvm.org/svn/llvm-project/cfe/branches/release_32@168974
Diffstat (limited to 'include/clang/Basic')
36 files changed, 1350 insertions, 288 deletions
diff --git a/include/clang/Basic/Attr.td b/include/clang/Basic/Attr.td index fade83e..bfe8093 100644 --- a/include/clang/Basic/Attr.td +++ b/include/clang/Basic/Attr.td @@ -190,7 +190,7 @@ def Availability : InheritableAttr { [{static llvm::StringRef getPrettyPlatformName(llvm::StringRef Platform) { return llvm::StringSwitch<llvm::StringRef>(Platform) .Case("ios", "iOS") - .Case("macosx", "Mac OS X") + .Case("macosx", "OS X") .Default(llvm::StringRef()); } }]; } @@ -341,6 +341,11 @@ def Final : InheritableAttr { let SemaHandler = 0; } +def MinSize : InheritableAttr { + let Spellings = [GNU<"minsize">]; + let Subjects = [Function]; +} + def Format : InheritableAttr { let Spellings = [GNU<"format">]; let Args = [StringArgument<"Type">, IntArgument<"FormatIdx">, @@ -528,6 +533,11 @@ def ObjCReturnsInnerPointer : Attr { let Subjects = [ObjCMethod]; } +def ObjCRequiresSuper : InheritableAttr { + let Spellings = [GNU<"objc_requires_super">]; + let Subjects = [ObjCMethod]; +} + def ObjCRootClass : Attr { let Spellings = [GNU<"objc_root_class">]; let Subjects = [ObjCInterface]; @@ -556,6 +566,10 @@ def Packed : InheritableAttr { let Spellings = [GNU<"packed">]; } +def PnaclCall : InheritableAttr { + let Spellings = [GNU<"pnaclcall">]; +} + def Pcs : InheritableAttr { let Spellings = [GNU<"pcs">]; let Args = [EnumArgument<"PCS", "PCSType", diff --git a/include/clang/Basic/Builtins.def b/include/clang/Basic/Builtins.def index 84b2881..d48eadc 100644 --- a/include/clang/Basic/Builtins.def +++ b/include/clang/Basic/Builtins.def @@ -41,6 +41,7 @@ // J -> jmp_buf // SJ -> sigjmp_buf // K -> ucontext_t +// p -> pid_t // . -> "...". This may only occur at the end of the function list. // // Types may be prefixed with the following modifiers: @@ -388,6 +389,7 @@ BUILTIN(__builtin_popcountll, "iULLi", "nc") // FIXME: These type signatures are not correct for targets with int != 32-bits // or with ULL != 64-bits. +BUILTIN(__builtin_bswap16, "UsUs", "nc") BUILTIN(__builtin_bswap32, "UiUi", "nc") BUILTIN(__builtin_bswap64, "ULLiULLi", "nc") @@ -478,6 +480,7 @@ BUILTIN(__builtin_expect, "LiLiLi" , "nc") BUILTIN(__builtin_prefetch, "vvC*.", "nc") BUILTIN(__builtin_readcyclecounter, "ULLi", "n") BUILTIN(__builtin_trap, "v", "nr") +BUILTIN(__builtin_debugtrap, "v", "n") BUILTIN(__builtin_unreachable, "v", "nr") BUILTIN(__builtin_shufflevector, "v." , "nc") BUILTIN(__builtin_alloca, "v*z" , "n") @@ -735,7 +738,7 @@ LIBBUILTIN(strcasecmp, "icC*cC*", "f", "strings.h", ALL_LANGUAGES) LIBBUILTIN(strncasecmp, "icC*cC*z", "f", "strings.h", ALL_LANGUAGES) // POSIX unistd.h LIBBUILTIN(_exit, "vi", "fr", "unistd.h", ALL_LANGUAGES) -LIBBUILTIN(vfork, "i", "fj", "unistd.h", ALL_LANGUAGES) +LIBBUILTIN(vfork, "p", "fj", "unistd.h", ALL_LANGUAGES) // POSIX setjmp.h // In some systems setjmp is a macro that expands to _setjmp. We undefine @@ -826,9 +829,13 @@ LIBBUILTIN(atan2, "ddd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(atan2l, "LdLdLd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(atan2f, "fff", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(ceil, "dd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(ceill, "LdLd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(ceilf, "ff", "fe", "math.h", ALL_LANGUAGES) +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(copysign, "ddd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(copysignl, "LdLdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(copysignf, "fff", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(cos, "dd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(cosl, "LdLd", "fe", "math.h", ALL_LANGUAGES) @@ -838,37 +845,53 @@ LIBBUILTIN(exp, "dd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(expl, "LdLd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(expf, "ff", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fabs, "dd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fabsl, "LdLd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fabsf, "ff", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(exp2, "dd", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(exp2l, "LdLd", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(exp2f, "ff", "fe", "math.h", ALL_LANGUAGES) + +LIBBUILTIN(fabs, "dd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fabsl, "LdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fabsf, "ff", "fc", "math.h", ALL_LANGUAGES) -LIBBUILTIN(floor, "dd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(floorl, "LdLd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(floorf, "ff", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(floor, "dd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(floorl, "LdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(floorf, "ff", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(fma, "dddd", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(fmal, "LdLdLdLd", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(fmaf, "ffff", "fc", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fmax, "ddd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fmaxl, "LdLdLd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fmaxf, "fff", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fmax, "ddd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fmaxl, "LdLdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fmaxf, "fff", "fc", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fmin, "ddd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fminl, "LdLdLd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(fminf, "fff", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fmin, "ddd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fminl, "LdLdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(fminf, "fff", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(log, "dd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(logl, "LdLd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(logf, "ff", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(log2, "dd", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(log2l, "LdLd", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(log2f, "ff", "fe", "math.h", ALL_LANGUAGES) + +LIBBUILTIN(nearbyint, "dd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(nearbyintl, "LdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(nearbyintf, "ff", "fc", "math.h", ALL_LANGUAGES) + LIBBUILTIN(pow, "ddd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(powl, "LdLdLd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(powf, "fff", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(round, "dd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(roundl, "LdLd", "fe", "math.h", ALL_LANGUAGES) -LIBBUILTIN(roundf, "ff", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(rint, "dd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(rintl, "LdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(rintf, "ff", "fc", "math.h", ALL_LANGUAGES) + +LIBBUILTIN(round, "dd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(roundl, "LdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(roundf, "ff", "fc", "math.h", ALL_LANGUAGES) LIBBUILTIN(sin, "dd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(sinl, "LdLd", "fe", "math.h", ALL_LANGUAGES) @@ -882,6 +905,10 @@ LIBBUILTIN(tan, "dd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(tanl, "LdLd", "fe", "math.h", ALL_LANGUAGES) LIBBUILTIN(tanf, "ff", "fe", "math.h", ALL_LANGUAGES) +LIBBUILTIN(trunc, "dd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(truncl, "LdLd", "fc", "math.h", ALL_LANGUAGES) +LIBBUILTIN(truncf, "ff", "fc", "math.h", ALL_LANGUAGES) + // Blocks runtime Builtin math library functions LIBBUILTIN(_Block_object_assign, "vv*vC*iC", "f", "Blocks.h", ALL_LANGUAGES) LIBBUILTIN(_Block_object_dispose, "vvC*iC", "f", "Blocks.h", ALL_LANGUAGES) diff --git a/include/clang/Basic/BuiltinsMips.def b/include/clang/Basic/BuiltinsMips.def index d013715..43fb907 100644 --- a/include/clang/Basic/BuiltinsMips.def +++ b/include/clang/Basic/BuiltinsMips.def @@ -14,6 +14,8 @@ // The format of this database matches clang/Basic/Builtins.def. +// MIPS DSP Rev 1 + // Add/subtract with optional saturation BUILTIN(__builtin_mips_addu_qb, "V4ScV4ScV4Sc", "n") BUILTIN(__builtin_mips_addu_s_qb, "V4ScV4ScV4Sc", "n") @@ -122,4 +124,65 @@ BUILTIN(__builtin_mips_lbux, "iv*i", "n") BUILTIN(__builtin_mips_lhx, "iv*i", "n") BUILTIN(__builtin_mips_lwx, "iv*i", "n") +// MIPS DSP Rev 2 + +BUILTIN(__builtin_mips_absq_s_qb, "V4ScV4Sc", "n") + +BUILTIN(__builtin_mips_addqh_ph, "V2sV2sV2s", "nc") +BUILTIN(__builtin_mips_addqh_r_ph, "V2sV2sV2s", "nc") +BUILTIN(__builtin_mips_addqh_w, "iii", "nc") +BUILTIN(__builtin_mips_addqh_r_w, "iii", "nc") + +BUILTIN(__builtin_mips_addu_ph, "V2sV2sV2s", "n") +BUILTIN(__builtin_mips_addu_s_ph, "V2sV2sV2s", "n") + +BUILTIN(__builtin_mips_adduh_qb, "V4ScV4ScV4Sc", "nc") +BUILTIN(__builtin_mips_adduh_r_qb, "V4ScV4ScV4Sc", "nc") + +BUILTIN(__builtin_mips_append, "iiiIi", "nc") +BUILTIN(__builtin_mips_balign, "iiiIi", "nc") + +BUILTIN(__builtin_mips_cmpgdu_eq_qb, "iV4ScV4Sc", "n") +BUILTIN(__builtin_mips_cmpgdu_lt_qb, "iV4ScV4Sc", "n") +BUILTIN(__builtin_mips_cmpgdu_le_qb, "iV4ScV4Sc", "n") + +BUILTIN(__builtin_mips_dpa_w_ph, "LLiLLiV2sV2s", "nc") +BUILTIN(__builtin_mips_dps_w_ph, "LLiLLiV2sV2s", "nc") + +BUILTIN(__builtin_mips_dpaqx_s_w_ph, "LLiLLiV2sV2s", "n") +BUILTIN(__builtin_mips_dpaqx_sa_w_ph, "LLiLLiV2sV2s", "n") +BUILTIN(__builtin_mips_dpax_w_ph, "LLiLLiV2sV2s", "nc") +BUILTIN(__builtin_mips_dpsx_w_ph, "LLiLLiV2sV2s", "nc") +BUILTIN(__builtin_mips_dpsqx_s_w_ph, "LLiLLiV2sV2s", "n") +BUILTIN(__builtin_mips_dpsqx_sa_w_ph, "LLiLLiV2sV2s", "n") + +BUILTIN(__builtin_mips_mul_ph, "V2sV2sV2s", "n") +BUILTIN(__builtin_mips_mul_s_ph, "V2sV2sV2s", "n") + +BUILTIN(__builtin_mips_mulq_rs_w, "iii", "n") +BUILTIN(__builtin_mips_mulq_s_ph, "V2sV2sV2s", "n") +BUILTIN(__builtin_mips_mulq_s_w, "iii", "n") +BUILTIN(__builtin_mips_mulsa_w_ph, "LLiLLiV2sV2s", "nc") + +BUILTIN(__builtin_mips_precr_qb_ph, "V4ScV2sV2s", "n") +BUILTIN(__builtin_mips_precr_sra_ph_w, "V2siiIi", "nc") +BUILTIN(__builtin_mips_precr_sra_r_ph_w, "V2siiIi", "nc") + +BUILTIN(__builtin_mips_prepend, "iiiIi", "nc") + +BUILTIN(__builtin_mips_shra_qb, "V4ScV4Sci", "nc") +BUILTIN(__builtin_mips_shra_r_qb, "V4ScV4Sci", "nc") +BUILTIN(__builtin_mips_shrl_ph, "V2sV2si", "nc") + +BUILTIN(__builtin_mips_subqh_ph, "V2sV2sV2s", "nc") +BUILTIN(__builtin_mips_subqh_r_ph, "V2sV2sV2s", "nc") +BUILTIN(__builtin_mips_subqh_w, "iii", "nc") +BUILTIN(__builtin_mips_subqh_r_w, "iii", "nc") + +BUILTIN(__builtin_mips_subu_ph, "V2sV2sV2s", "n") +BUILTIN(__builtin_mips_subu_s_ph, "V2sV2sV2s", "n") + +BUILTIN(__builtin_mips_subuh_qb, "V4ScV4ScV4Sc", "nc") +BUILTIN(__builtin_mips_subuh_r_qb, "V4ScV4ScV4Sc", "nc") + #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsNVPTX.def b/include/clang/Basic/BuiltinsNVPTX.def index f90a43f..3c3f06c 100644 --- a/include/clang/Basic/BuiltinsNVPTX.def +++ b/include/clang/Basic/BuiltinsNVPTX.def @@ -14,6 +14,7 @@ // The format of this database matches clang/Basic/Builtins.def. +// Builtins retained from previous PTX back-end BUILTIN(__builtin_ptx_read_tid_x, "i", "nc") BUILTIN(__builtin_ptx_read_tid_y, "i", "nc") BUILTIN(__builtin_ptx_read_tid_z, "i", "nc") @@ -59,4 +60,249 @@ BUILTIN(__builtin_ptx_read_pm3, "i", "n") BUILTIN(__builtin_ptx_bar_sync, "vi", "n") +// Builtins exposed as part of NVVM +BUILTIN(__syncthreads, "v", "n") +BUILTIN(__nvvm_bar0, "v", "n") +BUILTIN(__nvvm_bar0_popc, "ii", "n") +BUILTIN(__nvvm_bar0_and, "ii", "n") +BUILTIN(__nvvm_bar0_or, "ii", "n") +BUILTIN(__nvvm_membar_cta, "v", "n") +BUILTIN(__nvvm_membar_gl, "v", "n") +BUILTIN(__nvvm_membar_sys, "v", "n") +BUILTIN(__nvvm_popc_i, "ii", "nc") +BUILTIN(__nvvm_popc_ll, "LiLi", "nc") +BUILTIN(__nvvm_prmt, "UiUiUiUi", "nc") +BUILTIN(__nvvm_min_i, "iii", "nc") +BUILTIN(__nvvm_min_ui, "UiUiUi", "nc") +BUILTIN(__nvvm_min_ll, "LLiLLiLLi", "nc") +BUILTIN(__nvvm_min_ull, "ULLiULLiULLi", "nc") +BUILTIN(__nvvm_max_i, "iii", "nc") +BUILTIN(__nvvm_max_ui, "UiUiUi", "nc") +BUILTIN(__nvvm_max_ll, "LLiLLiLLi", "nc") +BUILTIN(__nvvm_max_ull, "ULLiULLiULLi", "nc") +BUILTIN(__nvvm_mulhi_i, "iii", "nc") +BUILTIN(__nvvm_mulhi_ui, "UiUiUi", "nc") +BUILTIN(__nvvm_mulhi_ll, "LLiLLiLLi", "nc") +BUILTIN(__nvvm_mulhi_ull, "ULLiULLiULLi", "nc") +BUILTIN(__nvvm_mul24_i, "iii", "nc") +BUILTIN(__nvvm_mul24_ui, "UiUiUi", "nc") +BUILTIN(__nvvm_brev32, "UiUi", "nc") +BUILTIN(__nvvm_brev64, "ULLiULLi", "nc") +BUILTIN(__nvvm_sad_i, "iiii", "nc") +BUILTIN(__nvvm_sad_ui, "UiUiUiUi", "nc") +BUILTIN(__nvvm_abs_i, "ii", "nc") +BUILTIN(__nvvm_abs_ll, "LiLi", "nc") +BUILTIN(__nvvm_floor_ftz_f, "ff", "nc") +BUILTIN(__nvvm_floor_f, "ff", "nc") +BUILTIN(__nvvm_floor_d, "dd", "nc") +BUILTIN(__nvvm_fabs_ftz_f, "ff", "nc") +BUILTIN(__nvvm_fabs_f, "ff", "nc") +BUILTIN(__nvvm_fabs_d, "dd", "nc") +BUILTIN(__nvvm_rcp_approx_ftz_d, "dd", "nc") +BUILTIN(__nvvm_fmin_ftz_f, "fff", "nc") +BUILTIN(__nvvm_fmin_f, "fff", "nc") +BUILTIN(__nvvm_fmax_ftz_f, "fff", "nc") +BUILTIN(__nvvm_fmax_f, "fff", "nc") +BUILTIN(__nvvm_rsqrt_approx_ftz_f, "ff", "nc") +BUILTIN(__nvvm_rsqrt_approx_f, "ff", "nc") +BUILTIN(__nvvm_fmin_d, "ddd", "nc") +BUILTIN(__nvvm_fmax_d, "ddd", "nc") +BUILTIN(__nvvm_rsqrt_approx_d, "dd", "nc") +BUILTIN(__nvvm_ceil_d, "dd", "nc") +BUILTIN(__nvvm_trunc_d, "dd", "nc") +BUILTIN(__nvvm_round_d, "dd", "nc") +BUILTIN(__nvvm_ex2_approx_d, "dd", "nc") +BUILTIN(__nvvm_lg2_approx_d, "dd", "nc") +BUILTIN(__nvvm_round_ftz_f, "ff", "nc") +BUILTIN(__nvvm_round_f, "ff", "nc") +BUILTIN(__nvvm_ex2_approx_ftz_f, "ff", "nc") +BUILTIN(__nvvm_ex2_approx_f, "ff", "nc") +BUILTIN(__nvvm_lg2_approx_ftz_f, "ff", "nc") +BUILTIN(__nvvm_lg2_approx_f, "ff", "nc") +BUILTIN(__nvvm_sin_approx_ftz_f, "ff", "nc") +BUILTIN(__nvvm_sin_approx_f, "ff", "nc") +BUILTIN(__nvvm_cos_approx_ftz_f, "ff", "nc") +BUILTIN(__nvvm_cos_approx_f, "ff", "nc") +BUILTIN(__nvvm_trunc_ftz_f, "ff", "nc") +BUILTIN(__nvvm_trunc_f, "ff", "nc") +BUILTIN(__nvvm_ceil_ftz_f, "ff", "nc") +BUILTIN(__nvvm_ceil_f, "ff", "nc") +BUILTIN(__nvvm_saturate_d, "dd", "nc") +BUILTIN(__nvvm_saturate_ftz_f, "ff", "nc") +BUILTIN(__nvvm_saturate_f, "ff", "nc") +BUILTIN(__nvvm_fma_rn_ftz_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rn_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rz_ftz_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rz_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rm_ftz_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rm_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rp_ftz_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rp_f, "ffff", "nc") +BUILTIN(__nvvm_fma_rn_d, "dddd", "nc") +BUILTIN(__nvvm_fma_rz_d, "dddd", "nc") +BUILTIN(__nvvm_fma_rm_d, "dddd", "nc") +BUILTIN(__nvvm_fma_rp_d, "dddd", "nc") +BUILTIN(__nvvm_div_approx_ftz_f, "fff", "nc") +BUILTIN(__nvvm_div_approx_f, "fff", "nc") +BUILTIN(__nvvm_div_rn_ftz_f, "fff", "nc") +BUILTIN(__nvvm_div_rn_f, "fff", "nc") +BUILTIN(__nvvm_div_rz_ftz_f, "fff", "nc") +BUILTIN(__nvvm_div_rz_f, "fff", "nc") +BUILTIN(__nvvm_div_rm_ftz_f, "fff", "nc") +BUILTIN(__nvvm_div_rm_f, "fff", "nc") +BUILTIN(__nvvm_div_rp_ftz_f, "fff", "nc") +BUILTIN(__nvvm_div_rp_f, "fff", "nc") +BUILTIN(__nvvm_rcp_rn_ftz_f, "ff", "nc") +BUILTIN(__nvvm_rcp_rn_f, "ff", "nc") +BUILTIN(__nvvm_rcp_rz_ftz_f, "ff", "nc") +BUILTIN(__nvvm_rcp_rz_f, "ff", "nc") +BUILTIN(__nvvm_rcp_rm_ftz_f, "ff", "nc") +BUILTIN(__nvvm_rcp_rm_f, "ff", "nc") +BUILTIN(__nvvm_rcp_rp_ftz_f, "ff", "nc") +BUILTIN(__nvvm_rcp_rp_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rn_ftz_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rn_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rz_ftz_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rz_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rm_ftz_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rm_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rp_ftz_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_rp_f, "ff", "nc") +BUILTIN(__nvvm_div_rn_d, "ddd", "nc") +BUILTIN(__nvvm_div_rz_d, "ddd", "nc") +BUILTIN(__nvvm_div_rm_d, "ddd", "nc") +BUILTIN(__nvvm_div_rp_d, "ddd", "nc") +BUILTIN(__nvvm_rcp_rn_d, "dd", "nc") +BUILTIN(__nvvm_rcp_rz_d, "dd", "nc") +BUILTIN(__nvvm_rcp_rm_d, "dd", "nc") +BUILTIN(__nvvm_rcp_rp_d, "dd", "nc") +BUILTIN(__nvvm_sqrt_rn_d, "dd", "nc") +BUILTIN(__nvvm_sqrt_rz_d, "dd", "nc") +BUILTIN(__nvvm_sqrt_rm_d, "dd", "nc") +BUILTIN(__nvvm_sqrt_rp_d, "dd", "nc") +BUILTIN(__nvvm_sqrt_approx_ftz_f, "ff", "nc") +BUILTIN(__nvvm_sqrt_approx_f, "ff", "nc") +BUILTIN(__nvvm_add_rn_d, "ddd", "nc") +BUILTIN(__nvvm_add_rz_d, "ddd", "nc") +BUILTIN(__nvvm_add_rm_d, "ddd", "nc") +BUILTIN(__nvvm_add_rp_d, "ddd", "nc") +BUILTIN(__nvvm_mul_rn_d, "ddd", "nc") +BUILTIN(__nvvm_mul_rz_d, "ddd", "nc") +BUILTIN(__nvvm_mul_rm_d, "ddd", "nc") +BUILTIN(__nvvm_mul_rp_d, "ddd", "nc") +BUILTIN(__nvvm_add_rm_ftz_f, "fff", "nc") +BUILTIN(__nvvm_add_rm_f, "fff", "nc") +BUILTIN(__nvvm_add_rp_ftz_f, "fff", "nc") +BUILTIN(__nvvm_add_rp_f, "fff", "nc") +BUILTIN(__nvvm_mul_rm_ftz_f, "fff", "nc") +BUILTIN(__nvvm_mul_rm_f, "fff", "nc") +BUILTIN(__nvvm_mul_rp_ftz_f, "fff", "nc") +BUILTIN(__nvvm_mul_rp_f, "fff", "nc") +BUILTIN(__nvvm_add_rn_ftz_f, "fff", "nc") +BUILTIN(__nvvm_add_rn_f, "fff", "nc") +BUILTIN(__nvvm_add_rz_ftz_f, "fff", "nc") +BUILTIN(__nvvm_add_rz_f, "fff", "nc") +BUILTIN(__nvvm_mul_rn_ftz_f, "fff", "nc") +BUILTIN(__nvvm_mul_rn_f, "fff", "nc") +BUILTIN(__nvvm_mul_rz_ftz_f, "fff", "nc") +BUILTIN(__nvvm_mul_rz_f, "fff", "nc") +BUILTIN(__nvvm_d2f_rn_ftz, "fd", "nc") +BUILTIN(__nvvm_d2f_rn, "fd", "nc") +BUILTIN(__nvvm_d2f_rz_ftz, "fd", "nc") +BUILTIN(__nvvm_d2f_rz, "fd", "nc") +BUILTIN(__nvvm_d2f_rm_ftz, "fd", "nc") +BUILTIN(__nvvm_d2f_rm, "fd", "nc") +BUILTIN(__nvvm_d2f_rp_ftz, "fd", "nc") +BUILTIN(__nvvm_d2f_rp, "fd", "nc") +BUILTIN(__nvvm_d2i_rn, "id", "nc") +BUILTIN(__nvvm_d2i_rz, "id", "nc") +BUILTIN(__nvvm_d2i_rm, "id", "nc") +BUILTIN(__nvvm_d2i_rp, "id", "nc") +BUILTIN(__nvvm_d2ui_rn, "Uid", "nc") +BUILTIN(__nvvm_d2ui_rz, "Uid", "nc") +BUILTIN(__nvvm_d2ui_rm, "Uid", "nc") +BUILTIN(__nvvm_d2ui_rp, "Uid", "nc") +BUILTIN(__nvvm_i2d_rn, "di", "nc") +BUILTIN(__nvvm_i2d_rz, "di", "nc") +BUILTIN(__nvvm_i2d_rm, "di", "nc") +BUILTIN(__nvvm_i2d_rp, "di", "nc") +BUILTIN(__nvvm_ui2d_rn, "dUi", "nc") +BUILTIN(__nvvm_ui2d_rz, "dUi", "nc") +BUILTIN(__nvvm_ui2d_rm, "dUi", "nc") +BUILTIN(__nvvm_ui2d_rp, "dUi", "nc") +BUILTIN(__nvvm_f2i_rn_ftz, "if", "nc") +BUILTIN(__nvvm_f2i_rn, "if", "nc") +BUILTIN(__nvvm_f2i_rz_ftz, "if", "nc") +BUILTIN(__nvvm_f2i_rz, "if", "nc") +BUILTIN(__nvvm_f2i_rm_ftz, "if", "nc") +BUILTIN(__nvvm_f2i_rm, "if", "nc") +BUILTIN(__nvvm_f2i_rp_ftz, "if", "nc") +BUILTIN(__nvvm_f2i_rp, "if", "nc") +BUILTIN(__nvvm_f2ui_rn_ftz, "Uif", "nc") +BUILTIN(__nvvm_f2ui_rn, "Uif", "nc") +BUILTIN(__nvvm_f2ui_rz_ftz, "Uif", "nc") +BUILTIN(__nvvm_f2ui_rz, "Uif", "nc") +BUILTIN(__nvvm_f2ui_rm_ftz, "Uif", "nc") +BUILTIN(__nvvm_f2ui_rm, "Uif", "nc") +BUILTIN(__nvvm_f2ui_rp_ftz, "Uif", "nc") +BUILTIN(__nvvm_f2ui_rp, "Uif", "nc") +BUILTIN(__nvvm_i2f_rn, "fi", "nc") +BUILTIN(__nvvm_i2f_rz, "fi", "nc") +BUILTIN(__nvvm_i2f_rm, "fi", "nc") +BUILTIN(__nvvm_i2f_rp, "fi", "nc") +BUILTIN(__nvvm_ui2f_rn, "fUi", "nc") +BUILTIN(__nvvm_ui2f_rz, "fUi", "nc") +BUILTIN(__nvvm_ui2f_rm, "fUi", "nc") +BUILTIN(__nvvm_ui2f_rp, "fUi", "nc") +BUILTIN(__nvvm_lohi_i2d, "dii", "nc") +BUILTIN(__nvvm_d2i_lo, "id", "nc") +BUILTIN(__nvvm_d2i_hi, "id", "nc") +BUILTIN(__nvvm_f2ll_rn_ftz, "LLif", "nc") +BUILTIN(__nvvm_f2ll_rn, "LLif", "nc") +BUILTIN(__nvvm_f2ll_rz_ftz, "LLif", "nc") +BUILTIN(__nvvm_f2ll_rz, "LLif", "nc") +BUILTIN(__nvvm_f2ll_rm_ftz, "LLif", "nc") +BUILTIN(__nvvm_f2ll_rm, "LLif", "nc") +BUILTIN(__nvvm_f2ll_rp_ftz, "LLif", "nc") +BUILTIN(__nvvm_f2ll_rp, "LLif", "nc") +BUILTIN(__nvvm_f2ull_rn_ftz, "ULLif", "nc") +BUILTIN(__nvvm_f2ull_rn, "ULLif", "nc") +BUILTIN(__nvvm_f2ull_rz_ftz, "ULLif", "nc") +BUILTIN(__nvvm_f2ull_rz, "ULLif", "nc") +BUILTIN(__nvvm_f2ull_rm_ftz, "ULLif", "nc") +BUILTIN(__nvvm_f2ull_rm, "ULLif", "nc") +BUILTIN(__nvvm_f2ull_rp_ftz, "ULLif", "nc") +BUILTIN(__nvvm_f2ull_rp, "ULLif", "nc") +BUILTIN(__nvvm_d2ll_rn, "LLid", "nc") +BUILTIN(__nvvm_d2ll_rz, "LLid", "nc") +BUILTIN(__nvvm_d2ll_rm, "LLid", "nc") +BUILTIN(__nvvm_d2ll_rp, "LLid", "nc") +BUILTIN(__nvvm_d2ull_rn, "ULLid", "nc") +BUILTIN(__nvvm_d2ull_rz, "ULLid", "nc") +BUILTIN(__nvvm_d2ull_rm, "ULLid", "nc") +BUILTIN(__nvvm_d2ull_rp, "ULLid", "nc") +BUILTIN(__nvvm_ll2f_rn, "fLLi", "nc") +BUILTIN(__nvvm_ll2f_rz, "fLLi", "nc") +BUILTIN(__nvvm_ll2f_rm, "fLLi", "nc") +BUILTIN(__nvvm_ll2f_rp, "fLLi", "nc") +BUILTIN(__nvvm_ull2f_rn, "fULLi", "nc") +BUILTIN(__nvvm_ull2f_rz, "fULLi", "nc") +BUILTIN(__nvvm_ull2f_rm, "fULLi", "nc") +BUILTIN(__nvvm_ull2f_rp, "fULLi", "nc") +BUILTIN(__nvvm_ll2d_rn, "dLLi", "nc") +BUILTIN(__nvvm_ll2d_rz, "dLLi", "nc") +BUILTIN(__nvvm_ll2d_rm, "dLLi", "nc") +BUILTIN(__nvvm_ll2d_rp, "dLLi", "nc") +BUILTIN(__nvvm_ull2d_rn, "dULLi", "nc") +BUILTIN(__nvvm_ull2d_rz, "dULLi", "nc") +BUILTIN(__nvvm_ull2d_rm, "dULLi", "nc") +BUILTIN(__nvvm_ull2d_rp, "dULLi", "nc") +BUILTIN(__nvvm_f2h_rn_ftz, "Usf", "nc") +BUILTIN(__nvvm_f2h_rn, "Usf", "nc") +BUILTIN(__nvvm_h2f, "fUs", "nc") +BUILTIN(__nvvm_bitcast_i2f, "fi", "nc") +BUILTIN(__nvvm_bitcast_f2i, "if", "nc") +BUILTIN(__nvvm_bitcast_ll2d, "dLLi", "nc") +BUILTIN(__nvvm_bitcast_d2ll, "LLid", "nc") + #undef BUILTIN diff --git a/include/clang/Basic/BuiltinsX86.def b/include/clang/Basic/BuiltinsX86.def index 75e6074..5b46f8e 100644 --- a/include/clang/Basic/BuiltinsX86.def +++ b/include/clang/Basic/BuiltinsX86.def @@ -613,6 +613,12 @@ BUILTIN(__builtin_ia32_gatherd_d256, "V8iV8iV8iC*V8iV8iIc", "") BUILTIN(__builtin_ia32_gatherq_d, "V4iV4iV4iC*V2LLiV4iIc", "") BUILTIN(__builtin_ia32_gatherq_d256, "V4iV4iV4iC*V4LLiV4iIc", "") +// F16C +BUILTIN(__builtin_ia32_vcvtps2ph, "V8sV4fIi", "") +BUILTIN(__builtin_ia32_vcvtps2ph256, "V8sV8fIi", "") +BUILTIN(__builtin_ia32_vcvtph2ps, "V4fV8s", "") +BUILTIN(__builtin_ia32_vcvtph2ps256, "V8fV8s", "") + // RDRAND BUILTIN(__builtin_ia32_rdrand16_step, "UiUs*", "") BUILTIN(__builtin_ia32_rdrand32_step, "UiUi*", "") @@ -730,5 +736,8 @@ BUILTIN(__builtin_ia32_vfrczps, "V4fV4f", "") BUILTIN(__builtin_ia32_vfrczpd, "V2dV2d", "") BUILTIN(__builtin_ia32_vfrczps256, "V8fV8f", "") BUILTIN(__builtin_ia32_vfrczpd256, "V4dV4d", "") +BUILTIN(__builtin_ia32_xbegin, "i", "") +BUILTIN(__builtin_ia32_xend, "v", "") +BUILTIN(__builtin_ia32_xabort, "vIc", "") #undef BUILTIN diff --git a/include/clang/Basic/ConvertUTF.h b/include/clang/Basic/ConvertUTF.h index e7cfa8a..cdc4269 100644 --- a/include/clang/Basic/ConvertUTF.h +++ b/include/clang/Basic/ConvertUTF.h @@ -147,7 +147,6 @@ ConversionResult ConvertUTF32toUTF8 ( const UTF32** sourceStart, const UTF32* sourceEnd, UTF8** targetStart, UTF8* targetEnd, ConversionFlags flags); -#ifdef CLANG_NEEDS_THESE_ONE_DAY ConversionResult ConvertUTF16toUTF32 ( const UTF16** sourceStart, const UTF16* sourceEnd, UTF32** targetStart, UTF32* targetEnd, ConversionFlags flags); @@ -159,7 +158,9 @@ ConversionResult ConvertUTF32toUTF16 ( Boolean isLegalUTF8Sequence(const UTF8 *source, const UTF8 *sourceEnd); -Boolean isLegalUTF8String(const UTF8 *source, const UTF8 *sourceEnd); +Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd); + +unsigned getNumBytesForUTF8(UTF8 firstByte); #ifdef __cplusplus } @@ -175,11 +176,13 @@ 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. + * 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); + char *&ResultPtr, const UTF8 *&ErrorPtr); /** * Convert an Unicode code point to UTF8 sequence. @@ -194,7 +197,6 @@ bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source, bool ConvertCodePointToUTF8(unsigned Source, char *&ResultPtr); } -#endif #endif diff --git a/include/clang/Basic/Diagnostic.h b/include/clang/Basic/Diagnostic.h index 3997fb8..e47f3e1 100644 --- a/include/clang/Basic/Diagnostic.h +++ b/include/clang/Basic/Diagnostic.h @@ -16,6 +16,7 @@ #define LLVM_CLANG_DIAGNOSTIC_H #include "clang/Basic/DiagnosticIDs.h" +#include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/SourceLocation.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" @@ -29,6 +30,7 @@ namespace clang { class DiagnosticConsumer; class DiagnosticBuilder; + class DiagnosticOptions; class IdentifierInfo; class DeclContext; class LangOptions; @@ -160,13 +162,6 @@ public: ak_qualtype_pair ///< pair<QualType, QualType> }; - /// \brief Specifies which overload candidates to display when overload - /// resolution fails. - enum OverloadsShown { - Ovl_All, ///< Show all overloads. - Ovl_Best ///< Show just the "best" overload candidates. - }; - /// \brief Represents on argument value, which is a union discriminated /// by ArgumentKind, with a value. typedef std::pair<ArgumentKind, intptr_t> ArgumentValue; @@ -190,6 +185,7 @@ private: // backtrace stack, 0 -> no limit. ExtensionHandling ExtBehavior; // Map extensions onto warnings or errors? IntrusiveRefCntPtr<DiagnosticIDs> Diags; + IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts; DiagnosticConsumer *Client; bool OwnsDiagClient; SourceManager *SourceMgr; @@ -341,6 +337,7 @@ private: public: explicit DiagnosticsEngine( const IntrusiveRefCntPtr<DiagnosticIDs> &Diags, + DiagnosticOptions *DiagOpts, DiagnosticConsumer *client = 0, bool ShouldOwnClient = true); ~DiagnosticsEngine(); @@ -349,6 +346,9 @@ public: return Diags; } + /// \brief Retrieve the diagnostic options. + DiagnosticOptions &getDiagnosticOptions() const { return *DiagOpts; } + DiagnosticConsumer *getClient() { return Client; } const DiagnosticConsumer *getClient() const { return Client; } @@ -478,10 +478,13 @@ public: } OverloadsShown getShowOverloads() const { return ShowOverloads; } - /// \brief Pretend that the last diagnostic issued was ignored. + /// \brief Pretend that the last diagnostic issued was ignored, so any + /// subsequent notes will be suppressed. /// /// This can be used by clients who suppress diagnostics themselves. void setLastDiagnosticIgnored() { + if (LastDiagLevel == DiagnosticIDs::Fatal) + FatalErrorOccurred = true; LastDiagLevel = DiagnosticIDs::Ignored; } @@ -584,7 +587,7 @@ public: const char *Argument, unsigned ArgLen, const ArgumentValue *PrevArgs, unsigned NumPrevArgs, SmallVectorImpl<char> &Output, - SmallVectorImpl<intptr_t> &QualTypeVals) const { + ArrayRef<intptr_t> QualTypeVals) const { ArgToStringFn(Kind, Val, Modifier, ModLen, Argument, ArgLen, PrevArgs, NumPrevArgs, Output, ArgToStringCookie, QualTypeVals); @@ -837,7 +840,7 @@ class DiagnosticBuilder { /// call to ForceEmit. mutable bool IsForceEmit; - void operator=(const DiagnosticBuilder&); // DO NOT IMPLEMENT + void operator=(const DiagnosticBuilder &) LLVM_DELETED_FUNCTION; friend class DiagnosticsEngine; DiagnosticBuilder() @@ -961,6 +964,10 @@ public: "Too many arguments to diagnostic!"); DiagObj->DiagFixItHints[NumFixits++] = Hint; } + + bool hasMaxRanges() const { + return NumRanges == DiagnosticsEngine::MaxRanges; + } }; inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB, diff --git a/include/clang/Basic/DiagnosticASTKinds.td b/include/clang/Basic/DiagnosticASTKinds.td index 9cfe5ef..d869c99 100644 --- a/include/clang/Basic/DiagnosticASTKinds.td +++ b/include/clang/Basic/DiagnosticASTKinds.td @@ -137,7 +137,7 @@ def err_odr_function_type_inconsistent : Error< def warn_odr_tag_type_inconsistent : Warning< "type %0 has incompatible definitions in different translation units">; def note_odr_tag_kind_here: Note< - "%0 is a %select{struct|union|class|enum}1 here">; + "%0 is a %select{struct|interface|union|class|enum}1 here">; def note_odr_field : Note<"field %0 has type %1 here">; def note_odr_missing_field : Note<"no corresponding field here">; def note_odr_bit_field : Note<"bit-field %0 with type %1 and length %2 here">; diff --git a/include/clang/Basic/DiagnosticCommentKinds.td b/include/clang/Basic/DiagnosticCommentKinds.td index 235ca79..e6dfe5b 100644 --- a/include/clang/Basic/DiagnosticCommentKinds.td +++ b/include/clang/Basic/DiagnosticCommentKinds.td @@ -121,5 +121,21 @@ def warn_doc_returns_attached_to_a_void_function : Warning< "method returning void}1">, InGroup<Documentation>, DefaultIgnore; +// \deprecated command + +def warn_doc_deprecated_not_sync : Warning< + "declaration is marked with '\\deprecated' command but does not have " + "a deprecation attribute">, + InGroup<DocumentationDeprecatedSync>, DefaultIgnore; + +def note_add_deprecation_attr : Note< + "add a deprecation attribute to the declaration to silence this warning">; + +// verbatim block commands + +def warn_verbatim_block_end_without_start : Warning< + "'\\%0' command does not terminate a verbatim text block">, + InGroup<Documentation>, DefaultIgnore; + } // end of documentation issue category } // end of AST component diff --git a/include/clang/Basic/DiagnosticCommonKinds.td b/include/clang/Basic/DiagnosticCommonKinds.td index f859287..a6ce9d4 100644 --- a/include/clang/Basic/DiagnosticCommonKinds.td +++ b/include/clang/Basic/DiagnosticCommonKinds.td @@ -78,9 +78,12 @@ def note_decl_hiding_tag_type : Note< "%1 %0 is hidden by a non-type declaration of %0 here">; // Sema && Lex -def ext_longlong : Extension< +def ext_c99_longlong : Extension< "'long long' is an extension when C99 mode is not enabled">, InGroup<LongLong>; +def ext_cxx11_longlong : Extension< + "'long long' is a C++11 extension">, + InGroup<CXX11LongLong>; def warn_cxx98_compat_longlong : Warning< "'long long' is incompatible with C++98">, InGroup<CXX98CompatPedantic>, DefaultIgnore; diff --git a/include/clang/Basic/DiagnosticDriverKinds.td b/include/clang/Basic/DiagnosticDriverKinds.td index 583b234..4b43035 100644 --- a/include/clang/Basic/DiagnosticDriverKinds.td +++ b/include/clang/Basic/DiagnosticDriverKinds.td @@ -11,6 +11,8 @@ let Component = "Driver" in { def err_drv_no_such_file : Error<"no such file or directory: '%0'">; def err_drv_unsupported_opt : Error<"unsupported option '%0'">; +def err_drv_unsupported_opt_for_target : Error< + "unsupported option '%0' for target '%1'">; def err_drv_unsupported_option_argument : Error< "unsupported argument '%1' to option '%0'">; def err_drv_unknown_stdin_type : Error< @@ -91,10 +93,10 @@ def err_drv_invalid_arch_for_deployment_target : Error< "invalid architecture '%0' for deployment target '%1'">; def err_drv_objc_gc_arr : Error< "cannot specify both '-fobjc-arc' and '%0'">; -def err_arc_nonfragile_abi : Error< - "-fobjc-arc is not supported with legacy abi">; -def err_arc_unsupported : Error< - "-fobjc-arc is not supported on current deployment target">; +def err_arc_unsupported_on_runtime : Error< + "-fobjc-arc is not supported on platforms using the legacy runtime">; +def err_arc_unsupported_on_toolchain : Error< // feel free to generalize this + "-fobjc-arc is not supported on versions of OS X prior to 10.6">; def err_drv_mg_requires_m_or_mm : Error< "option '-MG' requires '-M' or '-MM'">; def err_drv_asan_android_requires_pie : Error< @@ -119,14 +121,10 @@ def warn_drv_unused_argument : Warning< def warn_drv_empty_joined_argument : Warning< "joined argument expects additional value: '%0'">, InGroup<DiagGroup<"unused-command-line-argument">>; -def warn_drv_not_using_clang_cpp : Warning< - "not using the clang preprocessor due to user override">; -def warn_drv_not_using_clang_cxx : Warning< - "not using the clang compiler for C++ inputs">; -def warn_drv_not_using_clang_arch : Warning< - "not using the clang compiler for the '%0' architecture">; def warn_drv_clang_unsupported : Warning< "the clang compiler does not support '%0'">; +def warn_drv_deprecated_arg : Warning< + "argument '%0' is deprecated, use '%1' instead">, InGroup<Deprecated>; def warn_drv_assuming_mfloat_abi_is : Warning< "unknown platform, assuming -mfloat-abi=%0">; def warn_ignoring_ftabstop_value : Warning< @@ -141,5 +139,9 @@ def warn_drv_pch_not_first_include : Warning< def note_drv_command_failed_diag_msg : Note< "diagnostic msg: %0">; - + +def err_analyzer_config_no_value : Error< + "analyzer-config option '%0' has a key but no value">; +def err_analyzer_config_multiple_values : Error< + "analyzer-config option '%0' should contain only one '='">; } diff --git a/include/clang/Basic/DiagnosticFrontendKinds.td b/include/clang/Basic/DiagnosticFrontendKinds.td index 417a22c..b7a8476 100644 --- a/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/include/clang/Basic/DiagnosticFrontendKinds.td @@ -58,6 +58,8 @@ def warn_fe_cc_print_header_failure : Warning< "unable to open CC_PRINT_HEADERS file: %0 (using stderr)">; 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 warn_fe_serialized_diag_failure : Warning< "unable to open file %0 for serializing diagnostics (%1)">, @@ -76,6 +78,11 @@ def err_verify_invalid_content : Error< def err_verify_inconsistent_diags : Error< "'%0' diagnostics %select{expected|seen}1 but not %select{seen|expected}1: " "%2">; +def err_verify_invalid_no_diags : Error< + "%select{expected|'expected-no-diagnostics'}0 directive cannot follow " + "%select{'expected-no-diagnostics' directive|other expected directives}0">; +def err_verify_no_directives : Error< + "no expected directives found: consider use of 'expected-no-diagnostics'">; def note_fixit_applied : Note<"FIX-IT applied suggested code changes">; def note_fixit_in_macro : Note< diff --git a/include/clang/Basic/DiagnosticGroups.td b/include/clang/Basic/DiagnosticGroups.td index d8632dd..f9f9ec7 100644 --- a/include/clang/Basic/DiagnosticGroups.td +++ b/include/clang/Basic/DiagnosticGroups.td @@ -22,8 +22,6 @@ def : DiagGroup<"address">; def AddressOfTemporary : DiagGroup<"address-of-temporary">; def : DiagGroup<"aggregate-return">; def AmbigMemberTemplate : DiagGroup<"ambiguous-member-template">; -def : DiagGroup<"attributes">; -def : DiagGroup<"bad-function-cast">; def Availability : DiagGroup<"availability">; def Section : DiagGroup<"section">; def AutoImport : DiagGroup<"auto-import">; @@ -33,8 +31,11 @@ def StringConversion : DiagGroup<"string-conversion">; def SignConversion : DiagGroup<"sign-conversion">; def BoolConversion : DiagGroup<"bool-conversion">; def IntConversion : DiagGroup<"int-conversion">; +def EnumConversion : DiagGroup<"enum-conversion">; def NonLiteralNullConversion : DiagGroup<"non-literal-null-conversion">; def NullConversion : DiagGroup<"null-conversion">; +def ImplicitConversionFloatingPointToBool : + DiagGroup<"implicit-conversion-floating-point-to-bool">; def BuiltinRequiresHeader : DiagGroup<"builtin-requires-header">; def CXXCompat: DiagGroup<"c++-compat">; def CastAlign : DiagGroup<"cast-align">; @@ -42,11 +43,11 @@ def : DiagGroup<"cast-qual">; def : DiagGroup<"char-align">; def Comment : DiagGroup<"comment">; def : DiagGroup<"ctor-dtor-privacy">; -def : DiagGroup<"declaration-after-statement">; def DefaultArgSpecialMember : DiagGroup<"default-arg-special-member">; def GNUDesignator : DiagGroup<"gnu-designator">; def DeleteNonVirtualDtor : DiagGroup<"delete-non-virtual-dtor">; +def AbstractFinalClass : DiagGroup<"abstract-final-class">; def DeprecatedDeclarations : DiagGroup<"deprecated-declarations">; def DeprecatedWritableStr : DiagGroup<"deprecated-writable-strings">; @@ -58,9 +59,14 @@ def DeprecatedImplementations :DiagGroup<"deprecated-implementations">; def : DiagGroup<"disabled-optimization">; def : DiagGroup<"discard-qual">; def : DiagGroup<"div-by-zero">; + def DocumentationHTML : DiagGroup<"documentation-html">; def DocumentationPedantic : DiagGroup<"documentation-pedantic">; -def Documentation : DiagGroup<"documentation", [DocumentationHTML]>; +def DocumentationDeprecatedSync : DiagGroup<"documentation-deprecated-sync">; +def Documentation : DiagGroup<"documentation", + [DocumentationHTML, + DocumentationDeprecatedSync]>; + def EmptyBody : DiagGroup<"empty-body">; def ExtraTokens : DiagGroup<"extra-tokens">; def CXX11ExtraSemi : DiagGroup<"c++11-extra-semi">; @@ -108,9 +114,9 @@ def ExitTimeDestructors : DiagGroup<"exit-time-destructors">; def FlexibleArrayExtensions : DiagGroup<"flexible-array-extensions">; def FourByteMultiChar : DiagGroup<"four-char-constants">; def GlobalConstructors : DiagGroup<"global-constructors">; -def : DiagGroup<"idiomatic-parentheses">; def BitwiseOpParentheses: DiagGroup<"bitwise-op-parentheses">; def LogicalOpParentheses: DiagGroup<"logical-op-parentheses">; +def ShiftOpParentheses: DiagGroup<"shift-op-parentheses">; def DanglingElse: DiagGroup<"dangling-else">; def IgnoredQualifiers : DiagGroup<"ignored-qualifiers">; def : DiagGroup<"import">; @@ -119,7 +125,6 @@ def IncompleteUmbrella : DiagGroup<"incomplete-umbrella">; def KNRPromotedParameter : DiagGroup<"knr-promoted-parameter">; def : DiagGroup<"init-self">; def : DiagGroup<"inline">; -def : DiagGroup<"int-to-pointer-cast">; def : DiagGroup<"invalid-pch">; def LiteralRange : DiagGroup<"literal-range">; def LocalTypeTemplateArgs : DiagGroup<"local-type-template-args", @@ -131,11 +136,12 @@ def MissingBraces : DiagGroup<"missing-braces">; def MissingDeclarations: DiagGroup<"missing-declarations">; def : DiagGroup<"missing-format-attribute">; def : DiagGroup<"missing-include-dirs">; -def : DiagGroup<"missing-noreturn">; def MultiChar : DiagGroup<"multichar">; def : DiagGroup<"nested-externs">; -def : DiagGroup<"newline-eof">; -def LongLong : DiagGroup<"long-long">; +def CXX11LongLong : DiagGroup<"c++11-long-long">; +def LongLong : DiagGroup<"long-long", [CXX11LongLong]>; +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">; @@ -157,6 +163,7 @@ def OverlengthStrings : DiagGroup<"overlength-strings">; def OverloadedVirtual : DiagGroup<"overloaded-virtual">; def PrivateExtern : DiagGroup<"private-extern">; def SelTypeCast : DiagGroup<"cast-of-sel-type">; +def BadFunctionCast : DiagGroup<"bad-function-cast">; def ObjCPropertyImpl : DiagGroup<"objc-property-implementation">; def ObjCPropertyNoAttribute : DiagGroup<"objc-property-no-attribute">; def ObjCMissingSuperCalls : DiagGroup<"objc-missing-super-calls">; @@ -183,7 +190,7 @@ def Sentinel : DiagGroup<"sentinel">; def MissingMethodReturnType : DiagGroup<"missing-method-return-type">; def : DiagGroup<"sequence-point">; def Shadow : DiagGroup<"shadow">; -def : DiagGroup<"shorten-64-to-32">; +def Shorten64To32 : DiagGroup<"shorten-64-to-32">; def : DiagGroup<"sign-promo">; def SignCompare : DiagGroup<"sign-compare">; def : DiagGroup<"stack-protector">; @@ -192,11 +199,15 @@ def : DiagGroup<"synth">; def SizeofArrayArgument : DiagGroup<"sizeof-array-argument">; def StringPlusInt : DiagGroup<"string-plus-int">; def StrncatSize : DiagGroup<"strncat-size">; -def TautologicalCompare : DiagGroup<"tautological-compare">; +def TautologicalOutOfRangeCompare : DiagGroup<"tautological-constant-out-of-range-compare">; +def TautologicalCompare : DiagGroup<"tautological-compare", + [TautologicalOutOfRangeCompare]>; def HeaderHygiene : DiagGroup<"header-hygiene">; +def DuplicateDeclSpecifier : DiagGroup<"duplicate-decl-specifier">; +def CompareDistinctPointerType : DiagGroup<"compare-distinct-pointer-types">; // Preprocessor warnings. -def : DiagGroup<"builtin-macro-redefined">; +def AmbiguousMacro : DiagGroup<"ambiguous-macro">; // Just silence warnings about -Wstrict-aliasing for now. def : DiagGroup<"strict-aliasing=0">; @@ -262,26 +273,29 @@ def ImplicitAtomic : DiagGroup<"implicit-atomic-properties">; def CustomAtomic : DiagGroup<"custom-atomic-properties">; def AtomicProperties : DiagGroup<"atomic-properties", [ImplicitAtomic, CustomAtomic]>; -def AutomaticReferenceCountingABI : DiagGroup<"arc-abi">; +// FIXME: Remove arc-abi once an Xcode is released that doesn't pass this flag. +def : DiagGroup<"arc-abi">; def ARCUnsafeRetainedAssign : DiagGroup<"arc-unsafe-retained-assign">; def ARCRetainCycles : DiagGroup<"arc-retain-cycles">; def ARCNonPodMemAccess : DiagGroup<"arc-non-pod-memaccess">; def AutomaticReferenceCounting : DiagGroup<"arc", - [AutomaticReferenceCountingABI, - ARCUnsafeRetainedAssign, + [ARCUnsafeRetainedAssign, ARCRetainCycles, ARCNonPodMemAccess]>; +def ARCRepeatedUseOfWeakMaybe : DiagGroup<"arc-maybe-repeated-use-of-weak">; +def ARCRepeatedUseOfWeak : DiagGroup<"arc-repeated-use-of-weak", + [ARCRepeatedUseOfWeakMaybe]>; def Selector : DiagGroup<"selector">; def Protocol : DiagGroup<"protocol">; def SuperSubClassMismatch : DiagGroup<"super-class-method-mismatch">; def OverridingMethodMismatch : DiagGroup<"overriding-method-mismatch">; -def : DiagGroup<"variadic-macros">; def VariadicMacros : DiagGroup<"variadic-macros">; def VectorConversion : DiagGroup<"vector-conversion">; // clang specific def VexingParse : DiagGroup<"vexing-parse">; def VLA : DiagGroup<"vla">; def VolatileRegisterVar : DiagGroup<"volatile-register-var">; def Visibility : DiagGroup<"visibility">; +def ZeroLengthArray : DiagGroup<"zero-length-array">; // GCC calls -Wdeprecated-writable-strings -Wwrite-strings. def GCCWriteStrings : DiagGroup<"write-strings" , [DeprecatedWritableStr]>; @@ -300,6 +314,7 @@ def ParenthesesOnEquality : DiagGroup<"parentheses-equality">; def Parentheses : DiagGroup<"parentheses", [LogicalOpParentheses, BitwiseOpParentheses, + ShiftOpParentheses, ParenthesesOnEquality, DanglingElse]>; @@ -311,15 +326,16 @@ def Parentheses : DiagGroup<"parentheses", // - bool-to-pointer conversion warnings are on by default // - __null-to-integer conversion warnings are on by default def Conversion : DiagGroup<"conversion", - [DiagGroup<"shorten-64-to-32">, + [BoolConversion, ConstantConversion, + EnumConversion, + Shorten64To32, + IntConversion, LiteralConversion, - StringConversion, - SignConversion, - BoolConversion, - NullConversion, // NULL->non-pointer NonLiteralNullConversion, // (1-1)->pointer (etc) - IntConversion]>, + NullConversion, // NULL->non-pointer + SignConversion, + StringConversion]>, DiagCategory<"Value Conversion Issue">; def Unused : DiagGroup<"unused", @@ -345,6 +361,8 @@ def Format2 : DiagGroup<"format=2", def TypeSafety : DiagGroup<"type-safety">; +def IntToPointerCast : DiagGroup<"int-to-pointer-cast">; + def Extra : DiagGroup<"extra", [ MissingFieldInitializers, IgnoredQualifiers, @@ -361,6 +379,7 @@ def Most : DiagGroup<"most", [ DeleteNonVirtualDtor, Format, Implicit, + IntToPointerCast, MismatchedTags, MissingBraces, MultiChar, @@ -382,9 +401,12 @@ def Most : DiagGroup<"most", [ // Thread Safety warnings def ThreadSafetyAttributes : DiagGroup<"thread-safety-attributes">; -def ThreadSafetyAnalysis : DiagGroup<"thread-safety-analysis">; -def ThreadSafety : DiagGroup<"thread-safety", - [ThreadSafetyAttributes, ThreadSafetyAnalysis]>; +def ThreadSafetyAnalysis : DiagGroup<"thread-safety-analysis">; +def ThreadSafetyPrecise : DiagGroup<"thread-safety-precise">; +def ThreadSafety : DiagGroup<"thread-safety", + [ThreadSafetyAttributes, + ThreadSafetyAnalysis, + ThreadSafetyPrecise]>; // 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 @@ -414,7 +436,8 @@ def NonGCC : DiagGroup<"non-gcc", // A warning group for warnings about using C++11 features as extensions in // earlier C++ versions. -def CXX11 : DiagGroup<"c++11-extensions", [CXX11ExtraSemi]>; +def CXX11 : DiagGroup<"c++11-extensions", [CXX11ExtraSemi, CXX11LongLong]>; + def : DiagGroup<"c++0x-extensions", [CXX11]>; def DelegatingCtorCycles : DiagGroup<"delegating-ctor-cycles">; @@ -426,7 +449,7 @@ def C11 : DiagGroup<"c11-extensions">; def C99 : DiagGroup<"c99-extensions">; // A warning group for warnings about GCC extensions. -def GNU : DiagGroup<"gnu", [GNUDesignator, VLA]>; +def GNU : DiagGroup<"gnu", [GNUDesignator, VLA, ZeroLengthArray]>; // A warning group for warnings about code that clang accepts but gcc doesn't. def GccCompat : DiagGroup<"gcc-compat">; @@ -451,3 +474,9 @@ def ObjCStringComparison : DiagGroup<"objc-string-compare">; def ObjCLiteralComparison : DiagGroup<"objc-literal-compare", [ ObjCStringComparison ]>; + +// Inline ASM warnings. +def ASMOperandWidths : DiagGroup<"asm-operand-widths">; +def ASM : DiagGroup<"asm", [ + ASMOperandWidths + ]>; diff --git a/include/clang/Basic/DiagnosticLexKinds.td b/include/clang/Basic/DiagnosticLexKinds.td index cc958db..c6c50ab 100644 --- a/include/clang/Basic/DiagnosticLexKinds.td +++ b/include/clang/Basic/DiagnosticLexKinds.td @@ -41,9 +41,9 @@ def trigraph_ends_block_comment : Warning<"trigraph ends block comment">, def trigraph_converted : Warning<"trigraph converted to '%0' character">, InGroup<Trigraphs>; -def ext_multi_line_bcpl_comment : Extension<"multi-line // comment">, +def ext_multi_line_line_comment : Extension<"multi-line // comment">, InGroup<Comment>; -def ext_bcpl_comment : Extension< +def ext_line_comment : Extension< "// comments are not allowed in this language">, InGroup<Comment>; def ext_no_newline_eof : Extension<"no newline at end of file">, @@ -55,7 +55,7 @@ def warn_cxx98_compat_no_newline_eof : Warning< def ext_dollar_in_identifier : Extension<"'$' in identifier">, InGroup<DiagGroup<"dollar-in-identifier-extension">>; -def ext_charize_microsoft : Extension<"@# is a microsoft extension">, +def ext_charize_microsoft : Extension<"charizing operator #@ is a Microsoft extension">, InGroup<Microsoft>; def ext_token_used : Extension<"extension used">, @@ -127,15 +127,16 @@ def warn_char_constant_too_large : Warning< def err_multichar_utf_character_literal : Error< "Unicode character literals may not contain multiple characters">; def err_exponent_has_no_digits : Error<"exponent has no digits">; -def ext_imaginary_constant : Extension<"imaginary constants are an extension">; +def ext_imaginary_constant : Extension< + "imaginary constants are a GNU extension">, InGroup<GNU>; def err_hexconstant_requires_exponent : Error< "hexadecimal floating constants require an exponent">; def err_hexconstant_requires_digits : Error< "hexadecimal floating constants require a significand">; def ext_hexconstant_invalid : Extension< - "hexadecimal floating constants are a C99 feature">; + "hexadecimal floating constants are a C99 feature">, InGroup<C99>; def ext_binary_literal : Extension< - "binary integer literals are an extension">; + "binary integer literals are a GNU extension">, InGroup<GNU>; def err_pascal_string_too_long : Error<"Pascal string is too long">; def warn_octal_escape_too_large : ExtWarn<"octal escape sequence out of range">; def warn_hex_escape_too_large : ExtWarn<"hex escape sequence out of range">; @@ -228,6 +229,12 @@ def pp_macro_not_used : Warning<"macro is not used">, DefaultIgnore, def warn_pp_undef_identifier : Warning< "%0 is not defined, evaluates to 0">, InGroup<DiagGroup<"undef">>, DefaultIgnore; +def warn_pp_ambiguous_macro : Warning< + "ambiguous expansion of macro %0">, InGroup<AmbiguousMacro>; +def note_pp_ambiguous_macro_chosen : Note< + "expanding this definition of %0">; +def note_pp_ambiguous_macro_other : Note< + "other definition of %0">; def pp_invalid_string_literal : Warning< "invalid string literal, ignoring final '\\'">; @@ -484,15 +491,21 @@ def err_mmap_missing_module_unqualified : Error< def err_mmap_missing_module_qualified : Error< "no module named '%0' in '%1'">; def err_mmap_top_level_inferred_submodule : Error< - "only submodules may be inferred with wildcard syntax">; + "only submodules and framework modules may be inferred with wildcard syntax">; def err_mmap_inferred_no_umbrella : Error< "inferred submodules require a module with an umbrella">; +def err_mmap_inferred_framework_submodule : Error< + "inferred submodule cannot be a framework submodule">; +def err_mmap_explicit_inferred_framework : Error< + "inferred framework modules cannot be 'explicit'">; +def err_mmap_missing_exclude_name : Error< + "expected excluded module name">; def err_mmap_inferred_redef : Error< "redefinition of inferred submodule">; def err_mmap_expected_lbrace_wildcard : Error< "expected '{' to start inferred submodule">; -def err_mmap_expected_wildcard_member : Error< - "expected module export wildcard">; +def err_mmap_expected_inferred_member : Error< + "expected %select{module exclusion with 'exclude'|'export *'}0">; def err_mmap_expected_export_wildcard : Error< "only '*' can be exported from an inferred submodule">; def err_mmap_explicit_top_level : Error< @@ -509,5 +522,7 @@ def warn_auto_module_import : Warning< "import of module '%1'">, InGroup<AutoImport>, DefaultIgnore; def warn_uncovered_module_header : Warning< "umbrella header does not include header '%0'">, 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 new file mode 100644 index 0000000..476ac1e --- /dev/null +++ b/include/clang/Basic/DiagnosticOptions.def @@ -0,0 +1,93 @@ +//===--- DiagOptions.def - Diagnostic option database ------------- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the diagnostic options. Users of this file +// must define the DIAGOPT macro to make use of this information. +// Optionally, the user may also define ENUM_DIAGOPT (for options +// that have enumeration type and VALUE_DIAGOPT (for options that +// describe a value rather than a flag). The SEMANTIC_* variants of these macros +// indicate options that affect the processing of the program, rather than +// simply the output. +// +//===----------------------------------------------------------------------===// +#ifndef DIAGOPT +# error Define the DIAGOPT macro to handle language options +#endif + +#ifndef VALUE_DIAGOPT +# define VALUE_DIAGOPT(Name, Bits, Default) \ +DIAGOPT(Name, Bits, Default) +#endif + +#ifndef ENUM_DIAGOPT +# define ENUM_DIAGOPT(Name, Type, Bits, Default) \ +DIAGOPT(Name, Bits, Default) +#endif + +#ifndef SEMANTIC_DIAGOPT +# define SEMANTIC_DIAGOPT(Name, Bits, Default) DIAGOPT(Name, Bits, Default) +#endif + +#ifndef SEMANTIC_VALUE_DIAGOPT +# define SEMANTIC_VALUE_DIAGOPT(Name, Bits, Default) \ + VALUE_DIAGOPT(Name, Bits, Default) +#endif + +#ifndef SEMANTIC_ENUM_DIAGOPT +# define SEMANTIC_ENUM_DIAGOPT(Name, Type, Bits, Default) \ + ENUM_DIAGOPT(Name, Type, Bits, Default) +#endif + +SEMANTIC_DIAGOPT(IgnoreWarnings, 1, 0) /// -w +DIAGOPT(NoRewriteMacros, 1, 0) /// -Wno-rewrite-macros +DIAGOPT(Pedantic, 1, 0) /// -pedantic +DIAGOPT(PedanticErrors, 1, 0) /// -pedantic-errors +DIAGOPT(ShowColumn, 1, 1) /// Show column number on diagnostics. +DIAGOPT(ShowLocation, 1, 1) /// Show source location information. +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(ShowOptionNames, 1, 0) /// Show the option name for mappable + /// diagnostics. +DIAGOPT(ShowNoteIncludeStack, 1, 0) /// Show include stacks for notes. +VALUE_DIAGOPT(ShowCategories, 2, 0) /// Show categories: 0 -> none, 1 -> Number, + /// 2 -> Full Name. + +ENUM_DIAGOPT(Format, TextDiagnosticFormat, 2, Clang) /// Format for diagnostics: + +DIAGOPT(ShowColors, 1, 0) /// Show diagnostics with ANSI color sequences. +ENUM_DIAGOPT(ShowOverloads, OverloadsShown, 1, + Ovl_All) /// Overload candidates to show. +DIAGOPT(VerifyDiagnostics, 1, 0) /// Check that diagnostics match the expected + /// diagnostics, indicated by markers in the + /// input source file. + +DIAGOPT(ElideType, 1, 0) /// Elide identical types in template diffing +DIAGOPT(ShowTemplateTree, 1, 0) /// Print a template tree when diffing + +VALUE_DIAGOPT(ErrorLimit, 32, 0) /// Limit # errors emitted. +/// Limit depth of macro expansion backtrace. +VALUE_DIAGOPT(MacroBacktraceLimit, 32, DefaultMacroBacktraceLimit) +/// Limit depth of instantiation backtrace. +VALUE_DIAGOPT(TemplateBacktraceLimit, 32, DefaultTemplateBacktraceLimit) +/// Limit depth of constexpr backtrace. +VALUE_DIAGOPT(ConstexprBacktraceLimit, 32, DefaultConstexprBacktraceLimit) + +VALUE_DIAGOPT(TabStop, 32, DefaultTabStop) /// The distance between tab stops. +/// Column limit for formatting message diagnostics, or 0 if unused. +VALUE_DIAGOPT(MessageLength, 32, 0) + +#undef DIAGOPT +#undef ENUM_DIAGOPT +#undef VALUE_DIAGOPT +#undef SEMANTIC_DIAGOPT +#undef SEMANTIC_ENUM_DIAGOPT +#undef SEMANTIC_VALUE_DIAGOPT + diff --git a/include/clang/Basic/DiagnosticOptions.h b/include/clang/Basic/DiagnosticOptions.h new file mode 100644 index 0000000..b75cb0c --- /dev/null +++ b/include/clang/Basic/DiagnosticOptions.h @@ -0,0 +1,85 @@ +//===--- DiagnosticOptions.h ------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H +#define LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H + +#include "llvm/ADT/IntrusiveRefCntPtr.h" + +#include <string> +#include <vector> + +namespace clang { + +/// \brief Specifies which overload candidates to display when overload +/// resolution fails. +enum OverloadsShown { + Ovl_All, ///< Show all overloads. + Ovl_Best ///< Show just the "best" overload candidates. +}; + +/// DiagnosticOptions - Options for controlling the compiler diagnostics +/// engine. +class DiagnosticOptions : public llvm::RefCountedBase<DiagnosticOptions>{ +public: + enum TextDiagnosticFormat { Clang, Msvc, Vi }; + + // Default values. + enum { DefaultTabStop = 8, MaxTabStop = 100, + DefaultMacroBacktraceLimit = 6, + DefaultTemplateBacktraceLimit = 10, + DefaultConstexprBacktraceLimit = 10 }; + + // Define simple diagnostic options (with no accessors). +#define DIAGOPT(Name, Bits, Default) unsigned Name : Bits; +#define ENUM_DIAGOPT(Name, Type, Bits, Default) +#include "clang/Basic/DiagnosticOptions.def" + +protected: + // Define diagnostic options of enumeration type. These are private, and will + // have accessors (below). +#define DIAGOPT(Name, Bits, Default) +#define ENUM_DIAGOPT(Name, Type, Bits, Default) unsigned Name : Bits; +#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. + std::string DiagnosticLogFile; + + /// The file to serialize diagnostics to (non-appending). + std::string DiagnosticSerializationFile; + + /// The list of -W... options used to alter the diagnostic mappings, with the + /// prefixes removed. + std::vector<std::string> Warnings; + +public: + // Define accessors/mutators for diagnostic options of enumeration type. +#define DIAGOPT(Name, Bits, Default) +#define ENUM_DIAGOPT(Name, Type, Bits, Default) \ + Type get##Name() const { return static_cast<Type>(Name); } \ + void set##Name(Type Value) { Name = static_cast<unsigned>(Value); } +#include "clang/Basic/DiagnosticOptions.def" + + DiagnosticOptions() { +#define DIAGOPT(Name, Bits, Default) Name = Default; +#define ENUM_DIAGOPT(Name, Type, Bits, Default) set##Name(Default); +#include "clang/Basic/DiagnosticOptions.def" + } +}; + +typedef DiagnosticOptions::TextDiagnosticFormat TextDiagnosticFormat; + +} // end namespace clang + +#endif diff --git a/include/clang/Basic/DiagnosticParseKinds.td b/include/clang/Basic/DiagnosticParseKinds.td index b1c16fa..21eeccb 100644 --- a/include/clang/Basic/DiagnosticParseKinds.td +++ b/include/clang/Basic/DiagnosticParseKinds.td @@ -18,10 +18,13 @@ 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< - "ISO C requires a translation unit to contain at least one declaration.">, + "ISO C requires a translation unit to contain at least one declaration">, InGroup<DiagGroup<"empty-translation-unit">>; def warn_cxx98_compat_top_level_semi : Warning< "extra ';' outside of a function is incompatible with C++98">, @@ -40,11 +43,14 @@ def warn_extra_semi_after_mem_fn_def : Warning< "extra ';' after member function definition">, InGroup<ExtraSemi>, DefaultIgnore; -def ext_duplicate_declspec : Extension<"duplicate '%0' declaration specifier">; +def ext_duplicate_declspec : ExtWarn<"duplicate '%0' declaration specifier">, + InGroup<DuplicateDeclSpecifier>; +def warn_duplicate_declspec : Warning<"duplicate '%0' declaration specifier">, + InGroup<DuplicateDeclSpecifier>; def ext_plain_complex : ExtWarn< "plain '_Complex' requires a type specifier; assuming '_Complex double'">; def ext_integer_complex : Extension< - "complex integer types are an extension">; + "complex integer types are a GNU extension">, InGroup<GNU>; def ext_thread_before : Extension<"'__thread' before '%0'">; def ext_empty_struct_union : Extension< @@ -80,8 +86,11 @@ def err_enumerator_list_missing_comma : Error< "missing ',' between enumerators">; def err_enumerator_unnamed_no_def : Error< "unnamed enumeration must be a definition">; -def ext_ms_enum_fixed_underlying_type : Extension< - "enumeration types with a fixed underlying type are a Microsoft extension">, +def ext_cxx11_enum_fixed_underlying_type : Extension< + "enumeration types with a fixed underlying type are a C++11 extension">, + InGroup<CXX11>; +def ext_c_enum_fixed_underlying_type : Extension< + "enumeration types with a fixed underlying type are a Microsoft extension">, InGroup<Microsoft>; def warn_cxx98_compat_enum_fixed_underlying_type : Warning< "enumeration types with a fixed underlying type are incompatible with C++98">, @@ -207,6 +216,17 @@ def err_expected_semi_after_static_assert : Error< "expected ';' after static_assert">; def err_expected_semi_for : Error<"expected ';' in 'for' statement specifier">; def err_expected_colon_after : Error<"expected ':' after %0">; +def warn_missing_selector_name : Warning< + "%0 used as the name of the previous parameter rather than as part " + "of the selector">, + InGroup<DiagGroup<"missing-selector-name">>; +def note_missing_selector_name : Note< + "introduce a parameter name to make %0 part of the selector">; +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< @@ -331,6 +351,8 @@ def ext_c11_static_assert : Extension< def warn_cxx98_compat_static_assert : Warning< "static_assert declarations are incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; +def err_paren_after_colon_colon : Error< + "unexpected parenthesis after '::'">; /// Objective-C parser diagnostics def err_expected_minus_or_plus : Error< @@ -423,7 +445,8 @@ def err_expected_member_or_base_name : Error< def err_expected_lbrace_after_base_specifiers : Error< "expected '{' after base class list">; def ext_ellipsis_exception_spec : Extension< - "exception specification of '...' is a Microsoft extension">; + "exception specification of '...' is a Microsoft extension">, + InGroup<Microsoft>; def err_dynamic_and_noexcept_specification : Error< "cannot have both throw() and noexcept() clause on the same function">; def warn_cxx98_compat_noexcept_decl : Warning< @@ -455,9 +478,6 @@ def err_literal_operator_string_prefix : Error< "string literal after 'operator' cannot have an encoding prefix">; def err_literal_operator_string_not_empty : Error< "string literal after 'operator' must be '\"\"'">; -def err_literal_operator_missing_space : Error< - "C++11 requires a space between the \"\" and the user-defined suffix in a " - "literal operator">; def warn_cxx98_compat_literal_operator : Warning< "literal operators are incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; @@ -570,7 +590,7 @@ def err_expected_type_name_after_typename : Error< "expected an identifier or template-id after '::'">; def err_explicit_spec_non_template : Error< "explicit %select{specialization|instantiation}0 of non-template " - "%select{class|struct|union}1 %2">; + "%select{class|struct|union|interface}1 %2">; def err_default_template_template_parameter_not_template : Error< "default template argument for a template template parameter must be a class " @@ -627,6 +647,11 @@ def ext_override_control_keyword : ExtWarn< def warn_cxx98_compat_override_control_keyword : Warning< "'%0' keyword is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; +def err_override_control_interface : Error< + "'%0' keyword not permitted with interface types">; + +def err_access_specifier_interface : Error< + "interface types cannot specify '%select{private|protected}0' access">; def err_duplicate_virt_specifier : Error< "class member already marked '%0'">; @@ -710,6 +735,11 @@ def warn_pragma_unused_expected_var : Warning< "expected '#pragma unused' argument to be a variable name">; def warn_pragma_unused_expected_punc : Warning< "expected ')' or ',' in '#pragma unused'">; +// - #pragma fp_contract +def err_pragma_fp_contract_scope : Error< + "'#pragma fp_contract' should only appear at file scope or at the start of a " + "compound expression">; + // OpenCL Section 6.8.g def err_not_opencl_storage_class_specifier : Error< diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 2d63dc4..0d64bf3 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -20,13 +20,6 @@ def warn_variables_not_in_loop_body : Warning< "used in loop condition not modified in loop body">, InGroup<DiagGroup<"loop-analysis">>, DefaultIgnore; -def warn_identical_enum_values : Warning< - "all elements of %0 are initialized with literals to value %1">, - InGroup<DiagGroup<"unique-enum">>; -def note_identical_enum_values : Note< - "initialize the last element with the previous element to silence " - "this warning">; - // Constant expressions def err_expr_not_ice : Error< "expression is not an %select{integer|integral}0 constant expression">; @@ -102,7 +95,7 @@ def err_variably_modified_new_type : Error< // C99 Designated Initializers def ext_designated_init : Extension< - "designated initializers are a C99 feature">; + "designated initializers are a C99 feature">, InGroup<C99>; def err_array_designator_negative : Error< "array designator value '%0' is negative">; def err_array_designator_empty_range : Error< @@ -410,12 +403,10 @@ def err_statically_allocated_object : Error< "interface type cannot be statically allocated">; def err_object_cannot_be_passed_returned_by_value : Error< "interface type %1 cannot be %select{returned|passed}0 by value" - "; did you forget * in %1">; + "; 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 warn_enum_value_overflow : Warning<"overflow in enumeration value">; -def warn_pragma_options_align_unsupported_option : Warning< - "unsupported alignment option in '#pragma options align'">; def warn_pragma_options_align_reset_failed : Warning< "#pragma options align=reset failed: %0">; def err_pragma_options_align_mac68k_target_unsupported : Error< @@ -521,7 +512,8 @@ def warn_conflicting_overriding_ret_types : Warning< def warn_conflicting_ret_types : Warning< "conflicting return type in " - "implementation of %0%diff{: $ vs $|}1,2">; + "implementation of %0%diff{: $ vs $|}1,2">, + InGroup<MismatchedReturnTypes>; def warn_conflicting_overriding_ret_type_modifiers : Warning< "conflicting distributed object modifiers on return type " @@ -550,7 +542,9 @@ def warn_conflicting_overriding_param_types : Warning< def warn_conflicting_param_types : Warning< "conflicting parameter types in " - "implementation of %0%diff{: $ vs $|}1,2">; + "implementation of %0%diff{: $ vs $|}1,2">, + InGroup<MismatchedParameterTypes>; + def warn_conflicting_param_modifiers : Warning< "conflicting distributed object modifiers on parameter type " "in implementation of %0">, @@ -595,6 +589,8 @@ def warn_accessor_property_type_mismatch : Warning< "type of property %0 does not match type of accessor %1">; def not_conv_function_declared_at : Note<"type conversion function declared here">; def note_method_declared_at : Note<"method %0 declared here">; +def note_property_attribute : Note<"property %0 is declared " + "%select{deprecated|unavailable}1 here">; def err_setter_type_void : Error<"type of setter must be void">; def err_duplicate_method_decl : Error<"duplicate declaration of method %0">; def warn_duplicate_method_decl : @@ -700,7 +696,7 @@ def error_bad_property_context : Error< "property implementation must be in a class or category implementation">; def error_missing_property_ivar_decl : Error< "synthesized property %0 must either be named the same as a compatible" - " ivar or must explicitly name an ivar">; + " instance variable or must explicitly name an instance variable">; def error_synthesize_weak_non_arc_or_gc : Error< "@synthesize of 'weak' property is only allowed in ARC or GC mode">; def err_arc_perform_selector_retains : Error< @@ -712,38 +708,55 @@ def err_gc_weak_property_strong_type : Error< "weak attribute declared on a __strong type property in GC mode">; def warn_receiver_is_weak : Warning < "weak %select{receiver|property|implicit property}0 may be " - "unpredictably null in ARC mode">, + "unpredictably set to nil">, InGroup<DiagGroup<"receiver-is-weak">>, DefaultIgnore; +def note_arc_assign_to_strong : Note< + "assign the value to a strong variable to keep the object alive during use">; +def warn_arc_repeated_use_of_weak : Warning < + "weak %select{variable|property|implicit property|instance variable}0 %1 is " + "accessed multiple times in this %select{function|method|block|lambda}2 " + "but may be unpredictably set to nil; assign to a strong variable to keep " + "the object alive">, + InGroup<ARCRepeatedUseOfWeak>, DefaultIgnore; +def warn_implicitly_retains_self : Warning < + "block implicitly retains 'self'; explicitly mention 'self' to indicate " + "this is intended behavior">, + InGroup<DiagGroup<"implicit-retain-self">>, DefaultIgnore; +def warn_arc_possible_repeated_use_of_weak : Warning < + "weak %select{variable|property|implicit property|instance variable}0 %1 may " + "be accessed multiple times in this %select{function|method|block|lambda}2 " + "and may be unpredictably set to nil; assign to a strong variable to keep " + "the object alive">, + InGroup<ARCRepeatedUseOfWeakMaybe>, DefaultIgnore; +def note_arc_weak_also_accessed_here : Note< + "also accessed here">; def err_incomplete_synthesized_property : Error< "cannot synthesize property %0 with incomplete type %1">; def error_property_ivar_type : Error< - "type of property %0 (%1) does not match type of ivar %2 (%3)">; + "type of property %0 (%1) does not match type of instance variable %2 (%3)">; def error_property_accessor_type : Error< "type of property %0 (%1) does not match type of accessor %2 (%3)">; def error_ivar_in_superclass_use : Error< - "property %0 attempting to use ivar %1 declared in super class %2">; + "property %0 attempting to use instance variable %1 declared in super class %2">; def error_weak_property : Error< - "existing ivar %1 for __weak property %0 must be __weak">; + "existing instance variable %1 for __weak property %0 must be __weak">; def error_strong_property : Error< - "existing ivar %1 for strong property %0 may not be __weak">; + "existing instance variable %1 for strong property %0 may not be __weak">; def error_dynamic_property_ivar_decl : Error< - "dynamic property can not have ivar specification">; + "dynamic property can not have instance variable specification">; def error_duplicate_ivar_use : Error< - "synthesized properties %0 and %1 both claim ivar %2">; + "synthesized properties %0 and %1 both claim instance variable %2">; def error_property_implemented : Error<"property %0 is already implemented">; def warn_objc_property_attr_mutually_exclusive : Warning< "property attributes '%0' and '%1' are mutually exclusive">, InGroup<ReadOnlySetterAttrs>, DefaultIgnore; -def warn_objc_missing_super_dealloc : Warning< - "method possibly missing a [super dealloc] call">, +def warn_objc_missing_super_call : Warning< + "method possibly missing a [super %0] call">, InGroup<ObjCMissingSuperCalls>; def error_dealloc_bad_result_type : Error< "dealloc return type must be correctly specified as 'void' under ARC, " "instead of %0">; -def warn_objc_missing_super_finalize : Warning< - "method possibly missing a [super finalize] call">, - InGroup<ObjCMissingSuperCalls>; def warn_undeclared_selector : Warning< "undeclared selector %0">, InGroup<UndeclaredSelector>, DefaultIgnore; def warn_implicit_atomic_property : Warning< @@ -768,7 +781,7 @@ def err_static_assert_expression_is_not_constant : Error< def err_static_assert_failed : Error<"static_assert failed %0">; def warn_inline_namespace_reopened_noninline : Warning< - "inline namespace cannot be re-opened as a non-inline namespace">; + "inline namespace cannot be reopened as a non-inline namespace">; def err_inline_namespace_mismatch : Error< "%select{|non-}0inline namespace " "cannot be reopened as %select{non-|}0inline">; @@ -792,10 +805,11 @@ def warn_cxx98_compat_friend_is_member : Warning< "with C++98">, InGroup<CXX98Compat>, DefaultIgnore; def ext_unelaborated_friend_type : ExtWarn< "unelaborated friend declaration is a C++11 extension; specify " - "'%select{struct|union|class|enum}0' to befriend %1">, InGroup<CXX11>; + "'%select{struct|interface|union|class|enum}0' to befriend %1">, + InGroup<CXX11>; def warn_cxx98_compat_unelaborated_friend_type : Warning< - "befriending %1 without '%select{struct|union|class|enum}0' keyword is " - "incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; + "befriending %1 without '%select{struct|interface|union|class|enum}0' " + "keyword is incompatible with C++98">, InGroup<CXX98Compat>, DefaultIgnore; def err_qualified_friend_not_found : Error< "no function named %0 with type %1 was found in the specified scope">; def err_introducing_special_friend : Error< @@ -806,16 +820,26 @@ def err_tagless_friend_type_template : Error< def err_no_matching_local_friend : Error< "no matching function found in local scope">; def err_no_matching_local_friend_suggest : Error< - "no matching function %0 found in local scope; did you mean %2">; + "no matching function %0 found in local scope; did you mean %2?">; def err_partial_specialization_friend : Error< "partial specialization cannot be declared as a friend">; def err_qualified_friend_def : Error< "friend function definition cannot be qualified with '%0'">; 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_invalid_member_in_interface : Error< + "%select{data member |non-public member function |static member function |" + "user-declared constructor|user-declared destructor|operator |" + "nested class }0%1 is not permitted within an interface type">; +def err_invalid_base_in_interface : Error< + "interface type cannot inherit from " + "%select{'struct|non-public 'interface|'class}0 %1'">; + def err_abstract_type_in_decl : Error< - "%select{return|parameter|variable|field|ivar}0 type %1 is an abstract class">; + "%select{return|parameter|variable|field|instance variable}0 type %1 is an abstract class">; def err_allocation_of_abstract_type : Error< "allocating an object of abstract class type %0">; def err_throw_abstract_type : Error< @@ -841,6 +865,12 @@ def note_pure_virtual_function : Note< def err_deleted_decl_not_first : Error< "deleted definition must be first declaration">; +def err_deleted_override : Error< + "deleted function %0 cannot override a non-deleted function">; + +def err_non_deleted_override : Error< + "non-deleted function %0 cannot override a deleted function">; + def warn_weak_vtable : Warning< "%0 has no out-of-line virtual method definitions; its vtable will be " "emitted in every translation unit">, @@ -1030,7 +1060,7 @@ def warn_call_to_pure_virtual_member_function_from_ctor_dtor : Warning< "not available in the %select{constructor|destructor}1 of %2">; def note_field_decl : Note<"member is declared here">; -def note_ivar_decl : Note<"ivar 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_member_synthesized_at : Note< @@ -1113,8 +1143,8 @@ def err_constructor_redeclared : Error<"constructor cannot be redeclared">; def err_constructor_byvalue_arg : Error< "copy constructor must pass its first argument by reference">; def warn_no_constructor_for_refconst : Warning< - "%select{struct|union|class|enum}0 %1 does not declare any constructor to " - "initialize its non-modifiable members">; + "%select{struct|interface|union|class|enum}0 %1 does not declare any " + "constructor to initialize its non-modifiable members">; def note_refconst_member_not_initialized : Note< "%select{const|reference}0 member %1 will never be initialized">; def ext_ms_explicit_constructor_call : ExtWarn< @@ -1214,11 +1244,18 @@ def err_init_reference_member_uninitialized : Error< "reference member of type %0 uninitialized">; def note_uninit_reference_member : Note< "uninitialized reference member is here">; -def warn_field_is_uninit : Warning<"field is uninitialized when used here">, +def warn_field_is_uninit : Warning<"field %0 is uninitialized when used here">, + InGroup<Uninitialized>; +def warn_reference_field_is_uninit : Warning< + "reference %0 is not yet bound to a value when used here">, InGroup<Uninitialized>; def warn_uninit_self_reference_in_init : Warning< "variable %0 is uninitialized when used within its own initialization">, InGroup<Uninitialized>; +def warn_uninit_self_reference_in_reference_init : Warning< + "reference %0 is not yet bound to a value when used within its own" + " initialization">, + InGroup<Uninitialized>; def warn_uninit_var : Warning< "variable %0 is uninitialized when %select{used here|captured by block}1">, InGroup<Uninitialized>, DefaultIgnore; @@ -1300,9 +1337,10 @@ def err_new_array_of_auto : Error< "cannot allocate array of 'auto'">; def err_auto_not_allowed : Error< "'auto' not allowed %select{in function prototype|in non-static struct member" - "|in non-static union member|in non-static class member|in exception declaration" - "|in template parameter|in block literal|in template argument" - "|in typedef|in type alias|in function return type|here}0">; + "|in non-static union member|in non-static class member|in interface member" + "|in exception declaration|in template parameter|in block literal" + "|in template argument|in typedef|in type alias|in function return type" + "|here}0">; def err_auto_var_requires_init : Error< "declaration of variable %0 with type %1 requires an initializer">; def err_auto_new_requires_ctor_arg : Error< @@ -1346,6 +1384,8 @@ def err_function_marked_override_not_overriding : Error< "%0 marked 'override' but does not override any member functions">; def err_class_marked_final_used_as_base : Error< "base %0 is marked 'final'">; +def warn_abstract_final_class : Warning< + "abstract class is marked 'final'">, InGroup<AbstractFinalClass>; // C++11 attributes def err_repeat_attribute : Error<"'%0' attribute cannot be repeated">; @@ -1408,7 +1448,17 @@ def err_for_range_member_begin_end_mismatch : Error< "range type %0 has '%select{begin|end}1' member but no '%select{end|begin}1' member">; def err_for_range_begin_end_types_differ : Error< "'begin' and 'end' must return the same type (got %0 and %1)">; -def note_for_range_type : Note<"range has type %0">; +def note_in_for_range: Note< + "when looking up '%select{begin|end}0' function for range expression " + "of type %1">; +def err_for_range_invalid: Error< + "invalid range expression of type %0; no viable '%select{begin|end}1' " + "function available">; +def err_for_range_dereference : Error< + "invalid range expression of type %0; did you mean to dereference it " + "with '*'?">; +def note_for_range_invalid_iterator : Note < + "in implicit call to 'operator%select{!=|*|++}0' for iterator of type %1">; def note_for_range_begin_end : Note< "selected '%select{begin|end}0' %select{function|template }1%2 with iterator type %3">; @@ -1420,7 +1470,7 @@ def err_invalid_constexpr : Error< "%select{function parameter|typedef|non-static data member}0 " "cannot be constexpr">; def err_constexpr_tag : Error< - "%select{class|struct|union|enum}0 cannot be marked constexpr">; + "%select{class|struct|interface|union|enum}0 cannot be marked constexpr">; def err_constexpr_dtor : Error<"destructor cannot be marked constexpr">; def err_constexpr_no_declarators : Error< "constexpr can only be used in variable and function declarations">; @@ -1438,11 +1488,12 @@ def err_constexpr_redecl_mismatch : Error< def err_constexpr_virtual : Error<"virtual function cannot be constexpr">; def err_constexpr_virtual_base : Error< "constexpr %select{member function|constructor}0 not allowed in " - "%select{class|struct}1 with virtual base %plural{1:class|:classes}2">; + "%select{struct|interface|class}1 with virtual base " + "%plural{1:class|:classes}2">; def note_non_literal_incomplete : Note< "incomplete type %0 is not a literal type">; -def note_non_literal_virtual_base : Note<"%select{class|struct}0 with virtual " - "base %plural{1:class|:classes}1 is not a literal type">; +def note_non_literal_virtual_base : Note<"%select{struct|interface|class}0 " + "with virtual base %plural{1:class|:classes}1 is not a literal type">; def note_constexpr_virtual_base_here : Note<"virtual base class declared here">; def err_constexpr_non_literal_return : Error< "constexpr function's return type %0 is not a literal type">; @@ -1490,10 +1541,10 @@ def note_non_literal_user_provided_dtor : Note< def note_non_literal_nontrivial_dtor : Note< "%0 is not literal because it has a non-trivial destructor">; def warn_private_extern : Warning< - "Use of __private_extern__ on tentative definition has unexpected" - " behaviour - use __attribute__((visibility(\"hidden\"))) on extern" - " declaration or definition instead">, - InGroup<PrivateExtern>, DefaultIgnore; + "use of __private_extern__ on a declaration may not produce external symbol " + "private to the linkage unit and is deprecated">, InGroup<PrivateExtern>; +def note_private_extern : Note< + "use __attribute__((visibility(\"hidden\"))) attribute instead">; // C++11 char16_t/char32_t def warn_cxx98_compat_unicode_type : Warning< @@ -1681,7 +1732,9 @@ def warn_attribute_invalid_on_stmt : Warning< "attribute %0 cannot be specified on a statement">, InGroup<IgnoredAttributes>; def warn_declspec_attribute_ignored : Warning< - "attribute %0 is ignored, place it after \"%select{class|struct|union|enum}1\" to apply attribute to type declaration">, InGroup<IgnoredAttributes>; + "attribute %0 is ignored, place it after " + "\"%select{class|struct|union|interface|enum}1\" to apply attribute to " + "type declaration">, InGroup<IgnoredAttributes>; def warn_attribute_precede_definition : Warning< "attribute declaration must precede definition">, InGroup<IgnoredAttributes>; @@ -1699,7 +1752,8 @@ def warn_nsobject_attribute : Warning< "__attribute ((NSObject)) may be put on a typedef only, " "attribute is ignored">, InGroup<NSobjectAttribute>; def warn_attribute_weak_on_local : Warning< - "__weak attribute cannot be specified on an automatic variable">, + "__weak attribute cannot be specified on an automatic variable when ARC " + "is not enabled">, InGroup<IgnoredAttributes>; def warn_weak_identifier_undeclared : Warning< "weak identifier %0 never declared">; @@ -1753,6 +1807,8 @@ def err_attribute_vecreturn_only_pod_record : Error< def err_cconv_change : Error< "function declared '%0' here was previously declared " "%select{'%2'|without calling convention}1">; +def warn_cconv_ignored : Warning< + "calling convention %0 ignored for this target">, InGroup<IgnoredAttributes>; def err_cconv_knr : Error< "function with no prototype cannot use %0 calling convention">; def err_cconv_varargs : Error< @@ -1840,14 +1896,6 @@ def warn_lock_exclusive_and_shared : Warning< InGroup<ThreadSafetyAnalysis>, DefaultIgnore; def note_lock_exclusive_and_shared : Note< "the other lock of mutex '%0' is here">; -def warn_variable_requires_lock : Warning< - "%select{reading|writing}2 variable '%0' requires locking " - "%select{'%1'|'%1' exclusively}2">, - InGroup<ThreadSafetyAnalysis>, DefaultIgnore; -def warn_var_deref_requires_lock : Warning< - "%select{reading|writing}2 the value pointed to by '%0' requires locking " - "%select{'%1'|'%1' exclusively}2">, - InGroup<ThreadSafetyAnalysis>, DefaultIgnore; def warn_variable_requires_any_lock : Warning< "%select{reading|writing}1 variable '%0' requires locking " "%select{any mutex|any mutex exclusively}1">, @@ -1856,9 +1904,6 @@ def warn_var_deref_requires_any_lock : Warning< "%select{reading|writing}1 the value pointed to by '%0' requires locking " "%select{any mutex|any mutex exclusively}1">, InGroup<ThreadSafetyAnalysis>, DefaultIgnore; -def warn_fun_requires_lock : Warning< - "calling function '%0' requires %select{shared|exclusive}2 lock on '%1'">, - InGroup<ThreadSafetyAnalysis>, DefaultIgnore; def warn_fun_excludes_mutex : Warning< "cannot call function '%0' while mutex '%1' is locked">, InGroup<ThreadSafetyAnalysis>, DefaultIgnore; @@ -1866,6 +1911,32 @@ def warn_cannot_resolve_lock : Warning< "cannot resolve lock expression">, InGroup<ThreadSafetyAnalysis>, DefaultIgnore; +// Imprecise thread safety warnings +def warn_variable_requires_lock : Warning< + "%select{reading|writing}2 variable '%0' requires locking " + "%select{'%1'|'%1' exclusively}2">, + InGroup<ThreadSafetyAnalysis>, DefaultIgnore; +def warn_var_deref_requires_lock : Warning< + "%select{reading|writing}2 the value pointed to by '%0' requires locking " + "%select{'%1'|'%1' exclusively}2">, + InGroup<ThreadSafetyAnalysis>, DefaultIgnore; +def warn_fun_requires_lock : Warning< + "calling function '%0' requires %select{shared|exclusive}2 lock on '%1'">, + InGroup<ThreadSafetyAnalysis>, DefaultIgnore; + +// Precise thread safety warnings +def warn_variable_requires_lock_precise : Warning< + "%select{reading|writing}2 variable '%0' requires locking " + "%select{'%1'|'%1' exclusively}2">, + InGroup<ThreadSafetyPrecise>, DefaultIgnore; +def warn_var_deref_requires_lock_precise : Warning< + "%select{reading|writing}2 the value pointed to by '%0' requires locking " + "%select{'%1'|'%1' exclusively}2">, + InGroup<ThreadSafetyPrecise>, DefaultIgnore; +def warn_fun_requires_lock_precise : Warning< + "calling function '%0' requires %select{shared|exclusive}2 lock on '%1'">, + InGroup<ThreadSafetyPrecise>, DefaultIgnore; +def note_found_mutex_near_match : Note<"found near match '%0'">; def warn_impcast_vector_scalar : Warning< "implicit conversion turns vector to scalar: %0 to %1">, @@ -1890,7 +1961,7 @@ def warn_impcast_integer_precision : Warning< InGroup<DiagGroup<"conversion">>, DefaultIgnore; def warn_impcast_integer_64_32 : Warning< "implicit conversion loses integer precision: %0 to %1">, - InGroup<DiagGroup<"shorten-64-to-32">>, DefaultIgnore; + InGroup<Shorten64To32>, DefaultIgnore; def warn_impcast_integer_precision_constant : Warning< "implicit conversion from %2 to %3 changes value from %0 to %1">, InGroup<ConstantConversion>; @@ -1905,7 +1976,7 @@ def warn_impcast_string_literal_to_bool : Warning< InGroup<StringConversion>, DefaultIgnore; def warn_impcast_different_enum_types : Warning< "implicit conversion from enumeration type %0 to different enumeration type " - "%1">, InGroup<DiagGroup<"conversion">>; + "%1">, InGroup<EnumConversion>; def warn_impcast_bool_to_null_pointer : Warning< "initialization of pointer of type %0 to null from a constant boolean " "expression">, InGroup<BoolConversion>; @@ -1915,6 +1986,9 @@ def warn_non_literal_null_pointer : Warning< def warn_impcast_null_pointer_to_integer : Warning< "implicit conversion of NULL constant to %0">, InGroup<NullConversion>; +def warn_impcast_floating_point_to_bool : Warning< + "implicit conversion turns floating-point number into bool: %0 to %1">, + InGroup<ImplicitConversionFloatingPointToBool>; def warn_impcast_function_to_bool : Warning< "address of function %q0 will always evaluate to 'true'">, InGroup<BoolConversion>; @@ -1927,6 +2001,10 @@ def warn_cast_align : Warning< "cast from %0 to %1 increases required alignment from %2 to %3">, InGroup<CastAlign>, DefaultIgnore; +def warn_int_to_pointer_cast : Warning< + "cast to %1 from smaller integer type %0">, + InGroup<IntToPointerCast>; + def warn_attribute_ignored_for_field_of_type : Warning< "%0 attribute ignored for field of type %1">, InGroup<IgnoredAttributes>; @@ -2008,7 +2086,7 @@ def warn_attribute_ibaction: Warning< def err_iboutletcollection_type : Error< "invalid type %0 as argument of iboutletcollection attribute">; def warn_iboutlet_object_type : Warning< - "%select{ivar|property}2 with %0 attribute must " + "%select{instance variable|property}2 with %0 attribute must " "be an object type (invalid %1)">, InGroup<DiagGroup<"invalid-iboutlet">>; def err_attribute_overloadable_not_function : Error< @@ -2028,6 +2106,12 @@ def warn_ns_attribute_wrong_parameter_type : Warning< "%0 attribute only applies to %select{Objective-C object|pointer}1 " "parameters">, InGroup<IgnoredAttributes>; +def warn_objc_requires_super_protocol : Warning< + "%0 attribute cannot be applied to %select{methods in protocols|dealloc}1">, + InGroup<DiagGroup<"requires-super-attribute">>; +def note_protocol_decl : Note< + "protocol is declared here">; + def err_ns_bridged_not_interface : Error< "parameter of 'ns_bridged' attribute does not name an Objective-C class">; @@ -3058,6 +3142,9 @@ def note_sentinel_here : Note< def warn_missing_prototype : Warning< "no previous prototype for function %0">, InGroup<DiagGroup<"missing-prototypes">>, DefaultIgnore; +def warn_missing_variable_declarations : Warning< + "no previous extern declaration for non-static variable %0">, + InGroup<DiagGroup<"missing-variable-declarations">>, DefaultIgnore; def err_redefinition : Error<"redefinition of %0">; def err_definition_of_implicitly_declared_member : Error< "definition of implicitly declared %select{default constructor|copy " @@ -3144,7 +3231,7 @@ def err_non_thread_thread : Error< def err_thread_non_thread : Error< "thread-local declaration of %0 follows non-thread-local declaration">; def err_redefinition_different_type : Error< - "redefinition of %0 with a different type">; + "redefinition of %0 with a different type%diff{: $ vs $|}1,2">; def err_redefinition_different_kind : Error< "redefinition of %0 as different kind of symbol">; def warn_forward_class_redefinition : Warning< @@ -3159,8 +3246,8 @@ def err_tag_reference_conflict : Error< "implicit declaration introduced by elaborated type conflicts with " "%select{a declaration|a typedef|a type alias|a template}0 of the same name">; def err_dependent_tag_decl : Error< - "%select{declaration|definition}0 of %select{struct|union|class|enum}1 " - "in a dependent scope">; + "%select{declaration|definition}0 of " + "%select{struct|interface|union|class|enum}1 in a dependent scope">; def err_tag_definition_of_typedef : Error< "definition of type %0 conflicts with %select{typedef|type alias}1 of the same name">; def err_conflicting_types : Error<"conflicting types for %0">; @@ -3168,15 +3255,16 @@ def err_nested_redefinition : Error<"nested redefinition of %0">; def err_use_with_wrong_tag : Error< "use of %0 with tag type that does not match previous declaration">; def warn_struct_class_tag_mismatch : Warning< - "%select{struct|class}0%select{| template}1 %2 was previously declared " - "as a %select{class|struct}0%select{| template}1">, + "%select{struct|interface|class}0%select{| template}1 %2 was previously " + "declared as a %select{struct|interface|class}3%select{| template}1">, InGroup<MismatchedTags>, DefaultIgnore; def warn_struct_class_previous_tag_mismatch : Warning< - "%2 defined as a %select{struct|class}0%select{| template}1 here but " - "previously declared as a %select{class|struct}0%select{| template}1">, + "%2 defined as %select{a struct|an interface|a class}0%select{| template}1 " + "here but previously declared as " + "%select{a struct|an interface|a class}3%select{| template}1">, InGroup<MismatchedTags>, DefaultIgnore; def note_struct_class_suggestion : Note< - "did you mean %select{struct|class}0 here?">; + "did you mean %select{struct|interface|class}0 here?">; def ext_forward_ref_enum : Extension< "ISO C forbids forward references to 'enum' types">; def err_forward_ref_enum : Error< @@ -3189,9 +3277,9 @@ def ext_forward_ref_enum_def : Extension< def err_redefinition_of_enumerator : Error<"redefinition of enumerator %0">; def err_duplicate_member : Error<"duplicate member %0">; def err_misplaced_ivar : Error< - "ivars may not be placed in %select{categories|class extension}0">; + "instance variables may not be placed in %select{categories|class extension}0">; def warn_ivars_in_interface : Warning< - "declaration of ivars in the interface is deprecated">, + "declaration of instance variables in the interface is deprecated">, InGroup<DiagGroup<"objc-interface-ivars">>, DefaultIgnore; def ext_enum_value_not_int : Extension< "ISO C restricts enumerator values to range of 'int' (%0 is too " @@ -3220,11 +3308,13 @@ def warn_array_new_too_large : Warning<"array is too large (%0 elements)">, // -Wpadded, -Wpacked def warn_padded_struct_field : Warning< - "padding %select{struct|class}0 %1 with %2 %select{byte|bit}3%select{|s}4 " - "to align %5">, InGroup<Padded>, DefaultIgnore; + "padding %select{struct|interface|class}0 %1 with %2 " + "%select{byte|bit}3%select{|s}4 to align %5">, + InGroup<Padded>, DefaultIgnore; def warn_padded_struct_anon_field : Warning< - "padding %select{struct|class}0 %1 with %2 %select{byte|bit}3%select{|s}4 " - "to align anonymous bit-field">, InGroup<Padded>, DefaultIgnore; + "padding %select{struct|interface|class}0 %1 with %2 " + "%select{byte|bit}3%select{|s}4 to align anonymous bit-field">, + InGroup<Padded>, DefaultIgnore; def warn_padded_struct_size : Warning< "padding size of %0 with %1 %select{byte|bit}2%select{|s}3 " "to alignment boundary">, InGroup<Padded>, DefaultIgnore; @@ -3244,7 +3334,7 @@ def err_typecheck_invalid_restrict_not_pointer_noarg : Error< def err_typecheck_invalid_restrict_invalid_pointee : Error< "pointer to function type %0 may not be 'restrict' qualified">; def ext_typecheck_zero_array_size : Extension< - "zero size arrays are an extension">; + "zero size arrays are an extension">, InGroup<ZeroLengthArray>; def err_typecheck_zero_array_size : Error< "zero-length arrays are not permitted in C++">; def warn_typecheck_zero_static_array_size : Warning< @@ -3354,7 +3444,7 @@ def warn_anon_bitfield_width_exceeds_type_size : Warning< def warn_missing_braces : Warning< "suggest braces around initialization of subobject">, - InGroup<DiagGroup<"missing-braces">>, DefaultIgnore; + InGroup<MissingBraces>, DefaultIgnore; def err_missing_braces : Error< "cannot omit braces around initialization of subobject when using direct " "list-initialization">; @@ -3472,14 +3562,16 @@ def ext_flexible_array_in_array : Extension< def err_flexible_array_init : Error< "initialization of flexible array member is not allowed">; def ext_flexible_array_empty_aggregate_ms : Extension< - "flexible array member %0 in otherwise empty %select{struct|class}1 " - "is a Microsoft extension">, InGroup<Microsoft>; + "flexible array member %0 in otherwise empty " + "%select{struct|interface|union|class|enum}1 is a Microsoft extension">, + InGroup<Microsoft>; def ext_flexible_array_union_ms : Extension< "flexible array member %0 in a union is a Microsoft extension">, InGroup<Microsoft>; def ext_flexible_array_empty_aggregate_gnu : Extension< - "flexible array member %0 in otherwise empty %select{struct|class}1 " - "is a GNU extension">, InGroup<GNU>; + "flexible array member %0 in otherwise empty " + "%select{struct|interface|union|class|enum}1 is a GNU extension">, + InGroup<GNU>; def ext_flexible_array_union_gnu : Extension< "flexible array member %0 in a union is a GNU extension">, InGroup<GNU>; @@ -3497,7 +3589,7 @@ def err_arc_weak_unavailable_assign : Error< "assignment of a weak-unavailable object to a __weak object">; def err_arc_weak_unavailable_property : Error< "synthesis of a weak-unavailable property is disallowed " - "because it requires synthesis of an ivar of the __weak object">; + "because it requires synthesis of an instance variable of the __weak object">; def err_arc_convesion_of_weak_unavailable : Error< "%select{implicit conversion|cast}0 of weak-unavailable object of type %1 to" " a __weak object of type %2">; @@ -3527,6 +3619,9 @@ def err_arc_illegal_selector : Error< "ARC forbids use of %0 in a @selector">; def err_arc_illegal_method_def : Error< "ARC forbids implementation of %0">; +def warn_arc_strong_pointer_objc_pointer : Warning< + "method parameter of type %0 with no explicit ownership">, + InGroup<DiagGroup<"explicit-ownership-type">>, DefaultIgnore; } // end "ARC Restrictions" category @@ -3549,11 +3644,6 @@ def err_typecheck_arc_assign_self_class_method : Error< def err_typecheck_arr_assign_enumeration : Error< "fast enumeration variables can't be modified in ARC by default; " "declare the variable __strong to allow this">; -def warn_arc_non_pod_class_with_object_member : Warning< - "%0 cannot be shared between ARC and non-ARC " - "code; add a copy constructor, a copy assignment operator, and a destructor " - "to make it ABI-compatible">, InGroup<AutomaticReferenceCountingABI>, - DefaultIgnore; def warn_arc_retained_assign : Warning< "assigning retained object to %select{weak|unsafe_unretained}0 " "%select{property|variable}1" @@ -3563,19 +3653,10 @@ def warn_arc_retained_property_assign : Warning< "assigning retained object to unsafe property" "; object will be released after assignment">, InGroup<ARCUnsafeRetainedAssign>; -def warn_arc_trivial_member_function_with_object_member : Warning< - "%0 cannot be shared between ARC and non-ARC " - "code; add a non-trivial %select{copy constructor|copy assignment operator|" - "destructor}1 to make it ABI-compatible">, - InGroup<AutomaticReferenceCountingABI>, DefaultIgnore; def err_arc_new_array_without_ownership : Error< "'new' cannot allocate an array of %0 with no explicit ownership">; -def warn_err_new_delete_object_array : Warning< - "%select{allocating|destroying}0 an array of %1; this array must not " - "%select{be deleted in|have been allocated from}0 non-ARC code">, - InGroup<AutomaticReferenceCountingABI>, DefaultIgnore; def err_arc_autoreleasing_var : Error< - "%select{__block variables|global variables|fields|ivars}0 cannot have " + "%select{__block variables|global variables|fields|instance variables}0 cannot have " "__autoreleasing ownership">; def err_arc_autoreleasing_capture : Error< "cannot capture __autoreleasing variable in a " @@ -3632,10 +3713,10 @@ def warn_arc_object_memaccess : Warning< let CategoryName = "ARC and @properties" in { def err_arc_strong_property_ownership : Error< - "existing ivar %1 for strong property %0 may not be " + "existing instance variable %1 for strong property %0 may not be " "%select{|__unsafe_unretained||__weak}2">; def err_arc_assign_property_ownership : Error< - "existing ivar %1 for property %0 with %select{unsafe_unretained| assign}2 " + "existing instance variable %1 for property %0 with %select{unsafe_unretained| assign}2 " "attribute must be __unsafe_unretained">; def err_arc_inconsistent_property_ownership : Error< "%select{|unsafe_unretained|strong|weak}1 property %0 may not also be " @@ -3766,16 +3847,14 @@ def warn_precedence_bitwise_rel : Warning< InGroup<Parentheses>; def note_precedence_bitwise_first : Note< "place parentheses around the %0 expression to evaluate it first">; -def note_precedence_bitwise_silence : Note< - "place parentheses around the %0 expression to silence this warning">; +def note_precedence_silence : Note< + "place parentheses around the '%0' expression to silence this warning">; def warn_precedence_conditional : Warning< "operator '?:' has lower precedence than '%0'; '%0' will be evaluated first">, InGroup<Parentheses>; def note_precedence_conditional_first : Note< "place parentheses around the '?:' expression to evaluate it first">; -def note_precedence_conditional_silence : Note< - "place parentheses around the '%0' expression to silence this warning">; def warn_logical_instead_of_bitwise : Warning< "use of logical '%0' with constant operand">, @@ -3787,13 +3866,13 @@ def note_logical_instead_of_bitwise_remove_constant : Note< def warn_bitwise_and_in_bitwise_or : Warning< "'&' within '|'">, InGroup<BitwiseOpParentheses>; -def note_bitwise_and_in_bitwise_or_silence : Note< - "place parentheses around the '&' expression to silence this warning">; def warn_logical_and_in_logical_or : Warning< "'&&' within '||'">, InGroup<LogicalOpParentheses>; -def note_logical_and_in_logical_or_silence : Note< - "place parentheses around the '&&' expression to silence this warning">; + +def warn_addition_in_bitshift : Warning< + "operator '%0' has lower precedence than '%1'; " + "'%1' will be evaluated first">, InGroup<ShiftOpParentheses>; def warn_self_assignment : Warning< "explicitly assigning a variable of type %0 to itself">, @@ -3896,6 +3975,8 @@ def ext_out_of_line_declaration : ExtWarn< "out-of-line declaration of a member must be a definition">, InGroup<OutOfLineDeclaration>, DefaultError; def warn_member_extra_qualification : Warning< + "extra qualification on member %0">, InGroup<Microsoft>; +def err_member_extra_qualification : Error< "extra qualification on member %0">; def err_member_qualification : Error< "non-friend class member %0 cannot have a qualified name">; @@ -4013,7 +4094,8 @@ def ext_typecheck_comparison_of_pointer_integer : ExtWarn< def err_typecheck_comparison_of_pointer_integer : Error< "comparison between pointer and integer (%0 and %1)">; def ext_typecheck_comparison_of_distinct_pointers : ExtWarn< - "comparison of distinct pointer types%diff{ ($ and $)|}0,1">; + "comparison of distinct pointer types%diff{ ($ and $)|}0,1">, + InGroup<CompareDistinctPointerType>; def ext_typecheck_cond_incompatible_operands : ExtWarn< "incompatible operand types (%0 and %1)">; def err_cond_voidptr_arc : Error < @@ -4023,7 +4105,7 @@ def err_typecheck_comparison_of_distinct_pointers : Error< "comparison of distinct pointer types%diff{ ($ and $)|}0,1">; def ext_typecheck_comparison_of_distinct_pointers_nonstandard : ExtWarn< "comparison of distinct pointer types (%0 and %1) uses non-standard " - "composite pointer type %2">; + "composite pointer type %2">, InGroup<CompareDistinctPointerType>; def err_typecheck_assign_const : Error<"read-only variable is not assignable">; def err_stmtexpr_file_scope : Error< "statement expression not allowed at file scope">; @@ -4033,6 +4115,9 @@ def warn_mixed_sign_comparison : Warning< def warn_lunsigned_always_true_comparison : Warning< "comparison of unsigned%select{| enum}2 expression %0 is always %1">, InGroup<TautologicalCompare>; +def warn_out_of_range_compare : Warning< + "comparison of constant %0 with expression of type %1 is always " + "%select{false|true}2">, InGroup<TautologicalOutOfRangeCompare>; def warn_runsigned_always_true_comparison : Warning< "comparison of %0 unsigned%select{| enum}2 expression is always %1">, InGroup<TautologicalCompare>; @@ -4166,7 +4251,7 @@ def err_nogetter_property_incdec : Error< def error_no_subobject_property_setting : Error< "expression is not assignable">; def err_qualified_objc_access : Error< - "%select{property|ivar}0 access cannot be qualified with '%1'">; + "%select{property|instance variable}0 access cannot be qualified with '%1'">; def ext_freestanding_complex : Extension< "complex numbers are an extension in a freestanding C99 implementation">; @@ -4562,7 +4647,7 @@ def err_invalid_declarator_global_scope : Error< def err_invalid_declarator_in_function : Error< "definition or redeclaration of %0 not allowed inside a function">; def err_not_tag_in_scope : Error< - "no %select{struct|union|class|enum}0 named %1 in %2">; + "no %select{struct|interface|union|class|enum}0 named %1 in %2">; def err_no_typeid_with_fno_rtti : Error< "cannot use typeid with -fno-rtti">; @@ -4885,6 +4970,8 @@ def note_callee_decl : Note< "%0 declared here">; def note_defined_here : Note<"%0 defined here">; +def err_builtin_fn_use : Error<"builtin functions must be directly called">; + def warn_call_wrong_number_of_arguments : Warning< "too %select{few|many}0 arguments in call to %1">; def err_atomic_builtin_must_be_pointer : Error< @@ -4898,6 +4985,9 @@ def err_atomic_builtin_pointer_size : Error< def err_atomic_op_needs_atomic : Error< "first argument to atomic operation must be a pointer to _Atomic " "type (%0 invalid)">; +def err_atomic_op_needs_non_const_atomic : Error< + "first argument to atomic operation must be a pointer to non-const _Atomic " + "type (%0 invalid)">; def err_atomic_op_needs_trivial_copy : Error< "first argument to atomic operation must be a pointer to a trivially-copyable" " type (%0 invalid)">; @@ -4960,7 +5050,9 @@ def err_typecheck_cast_to_incomplete : Error< "cast to incomplete type %0">; def ext_typecheck_cast_nonscalar : Extension< "C99 forbids casting nonscalar type %0 to the same type">; -def ext_typecheck_cast_to_union : Extension<"C99 forbids casts to union type">; +def ext_typecheck_cast_to_union : Extension< + "cast to union type is a GNU extension">, + InGroup<GNU>; def err_typecheck_cast_to_union_no_type : Error< "cast to union type from type %0 not present in union">; def err_cast_pointer_from_non_pointer_int : Error< @@ -4968,6 +5060,9 @@ def err_cast_pointer_from_non_pointer_int : Error< def warn_cast_pointer_from_sel : Warning< "cast of type %0 to %1 is deprecated; use sel_getName instead">, InGroup<SelTypeCast>; +def warn_bad_function_cast : Warning< + "cast from function call of type %0 to non-matching type %1">, + InGroup<BadFunctionCast>, DefaultIgnore; def err_cast_pointer_to_non_pointer_int : Error< "pointer cannot be cast to type %0">; def err_typecheck_expect_scalar_operand : Error< @@ -5045,19 +5140,21 @@ let CategoryName = "Inline Assembly Issue" in { "unsupported inline asm: input with type " "%diff{$ matching output with type $|}0,1">; def err_asm_unknown_register_name : Error<"unknown register name '%0' in asm">; - def warn_asm_label_on_auto_decl : Warning< - "ignored asm label '%0' on automatic variable">; + def err_asm_empty : Error<"__asm used with no assembly instructions">; 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 warn_asm_label_on_auto_decl : Warning< + "ignored asm label '%0' on automatic variable">; def warn_invalid_asm_cast_lvalue : Warning< - "invalid use of a cast in a inline asm context requiring an l-value: " + "invalid use of a cast in an inline asm context requiring an l-value: " "accepted due to -fheinous-gnu-extensions, but clang may remove support " "for this in the future">; - - def warn_unsupported_msasm : ExtWarn< - "MS-style inline assembly is not supported">, InGroup<Microsoft>; + def warn_asm_mismatched_size_modifier : Warning< + "the size being stored is truncated, use a modifier to specify the size">, + InGroup<ASMOperandWidths>; } let CategoryName = "Semantic Issue" in { @@ -5122,7 +5219,7 @@ def err_in_class_initializer_references_def_ctor : Error< def ext_in_class_initializer_non_constant : Extension< "in-class initializer for static data member is not a constant expression; " - "folding it to a constant is a GNU extension">; + "folding it to a constant is a GNU extension">, InGroup<GNU>; // C++ anonymous unions and GNU anonymous structs/unions def ext_anonymous_union : Extension< @@ -5178,6 +5275,8 @@ def err_static_data_member_not_allowed_in_local_class : Error< def err_base_clause_on_union : Error<"unions cannot have base classes">; def err_base_must_be_class : Error<"base specifier must name a class">; def err_union_as_base_class : Error<"unions cannot be base classes">; +def err_circular_inheritance : Error< + "circular inheritance between %0 and %1">; def err_incomplete_base_class : Error<"base class has incomplete type">; def err_duplicate_base_class : Error< "base class %0 specified more than once as a direct base class">; @@ -5340,6 +5439,10 @@ def err_out_of_line_default_deletes : Error< "defaulting this %select{default constructor|copy constructor|move " "constructor|copy assignment operator|move assignment operator|destructor}0 " "would delete it after its first declaration">; +def ext_implicit_exception_spec_mismatch : ExtWarn< + "function previously declared with an %select{explicit|implicit}0 exception " + "specification redeclared with an %select{implicit|explicit}0 exception " + "specification">, InGroup<DiagGroup<"implicit-exception-spec-mismatch">>; def warn_ptr_arith_precedes_bounds : Warning< "the pointer decremented by %0 refers before the beginning of the array">, @@ -5373,6 +5476,10 @@ def warn_scanf_nonzero_width : Warning< def warn_printf_conversion_argument_type_mismatch : Warning< "format specifies type %0 but the argument has type %1">, InGroup<Format>; +def warn_format_argument_needs_cast : Warning< + "values of type '%0' should not be used as format arguments; add an explicit " + "cast to %1 instead">, + InGroup<Format>; def warn_printf_positional_arg_exceeds_data_args : Warning < "data argument position '%0' exceeds the number of data arguments (%1)">, InGroup<Format>; @@ -5397,7 +5504,8 @@ def warn_format_string_is_wide_literal : Warning< def warn_printf_format_string_contains_null_char : Warning< "format string contains '\\0' within the string body">, InGroup<Format>; def warn_printf_asterisk_missing_arg : Warning< - "'%select{*|.*}0' specified field %select{width|precision}0 is missing a matching 'int' argument">; + "'%select{*|.*}0' specified field %select{width|precision}0 is missing a matching 'int' argument">, + InGroup<Format>; def warn_printf_asterisk_wrong_type : Warning< "field %select{width|precision}0 should have type %1, but argument has type %2">, InGroup<Format>; @@ -5425,6 +5533,7 @@ def warn_scanf_scanlist_incomplete : Warning< "no closing ']' for '%%[' in scanf format string">, InGroup<Format>; def note_format_string_defined : Note<"format string is defined here">; +def note_format_fix_specifier : Note<"did you mean to use '%0'?">; def note_printf_c_str: Note<"did you mean to call the %0 method?">; def warn_null_arg : Warning< @@ -5588,7 +5697,7 @@ def warn_unannotated_fallthrough_per_function : Warning< "unannotated fall-through between switch labels in partly-annotated " "function">, InGroup<ImplicitFallthroughPerFunction>, DefaultIgnore; def note_insert_fallthrough_fixit : Note< - "insert '[[clang::fallthrough]];' to silence this warning">; + "insert '%0;' to silence this warning">; def note_insert_break_fixit : Note< "insert 'break;' to avoid fall-through">; def err_fallthrough_attr_wrong_target : Error< @@ -5824,7 +5933,7 @@ def err_typecheck_member_reference_ivar_suggest : Error< def err_property_not_found_suggest : Error< "property %0 not found on object of type %1; did you mean %2?">; def err_ivar_access_using_property_syntax_suggest : Error< - "property %0 not found on object of type %1; did you mean to access ivar %2?">; + "property %0 not found on object of type %1; did you mean to access instance variable %2?">; def err_property_found_suggest : Error< "property %0 found on object of type %1; did you mean to access " "it with the \".\" operator?">; @@ -5911,7 +6020,7 @@ def err_module_private_local : Error< "%select{local variable|parameter|typedef}0 %1 cannot be declared " "__module_private__">; def err_module_private_local_class : Error< - "local %select{struct|union|class|enum}0 cannot be declared " + "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">; diff --git a/include/clang/Basic/DiagnosticSerializationKinds.td b/include/clang/Basic/DiagnosticSerializationKinds.td index a440e80..e9df09d 100644 --- a/include/clang/Basic/DiagnosticSerializationKinds.td +++ b/include/clang/Basic/DiagnosticSerializationKinds.td @@ -25,9 +25,13 @@ def err_fe_pch_file_modified : Error< def err_fe_pch_file_overridden : Error< "file '%0' from the precompiled header has been overridden">; -def warn_pch_target_triple : Error< - "PCH file was compiled for the target '%0' but the current translation " - "unit is being compiled for target '%1'">; +def err_pch_targetopt_mismatch : Error< + "PCH file was compiled for the %0 '%1' but the current translation " + "unit is being compiled for target '%2'">; +def err_pch_targetopt_feature_mismatch : Error< + "%select{AST file|current translation unit}0 was compiled with the target " + "feature'%1' but the %select{current translation unit is|AST file was}0 " + "not">; def err_pch_langopt_mismatch : Error<"%0 was %select{disabled|enabled}1 in " "PCH file but is currently %select{disabled|enabled}2">; def err_pch_langopt_value_mismatch : Error< @@ -41,21 +45,24 @@ def warn_pch_different_branch : Error< "PCH file built from a different branch (%0) than the compiler (%1)">; def err_pch_with_compiler_errors : Error< "PCH file contains compiler errors">; -def warn_cmdline_conflicting_macro_def : Error< - "definition of the macro '%0' conflicts with the definition used to " - "build the precompiled header">; -def note_pch_macro_defined_as : Note< - "definition of macro '%0' in the precompiled header">; -def warn_cmdline_missing_macro_defs : Warning< - "macro definitions used to build the precompiled header are missing">; -def note_using_macro_def_from_pch : Note< - "using this macro definition from precompiled header">; -def warn_macro_name_used_in_pch : Error< - "definition of macro %0 conflicts with an identifier used in the " - "precompiled header">; -def warn_pch_compiler_options_mismatch : Error< - "compiler options used when building the precompiled header differ from " - "the options used when using the precompiled header">; + + +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|" + "it is not present on the command line}0">; def err_not_a_pch_file : Error< "'%0' does not appear to be a precompiled header file">, DefaultFatal; diff --git a/include/clang/Basic/FileManager.h b/include/clang/Basic/FileManager.h index b00f2b7..b2f578d 100644 --- a/include/clang/Basic/FileManager.h +++ b/include/clang/Basic/FileManager.h @@ -103,6 +103,10 @@ public: bool operator<(const FileEntry &RHS) const { return Device < RHS.Device || (Device == RHS.Device && Inode < RHS.Inode); } + + /// \brief Check whether the file is a named pipe (and thus can't be opened by + /// the native FileManager methods). + bool isNamedPipe() const; }; /// \brief Implements support for file system lookup, file system caching, diff --git a/include/clang/Basic/IdentifierTable.h b/include/clang/Basic/IdentifierTable.h index dc6acda..76242ec 100644 --- a/include/clang/Basic/IdentifierTable.h +++ b/include/clang/Basic/IdentifierTable.h @@ -21,7 +21,6 @@ #include "clang/Basic/LLVM.h" #include "llvm/ADT/StringMap.h" #include "llvm/ADT/StringRef.h" -#include "llvm/ADT/OwningPtr.h" #include "llvm/Support/PointerLikeTypeTraits.h" #include <cassert> #include <string> @@ -54,6 +53,7 @@ class IdentifierInfo { // are for builtins. unsigned ObjCOrBuiltinID :11; bool HasMacro : 1; // True if there is a #define for this. + bool HadMacro : 1; // True if there was a #define for this. bool IsExtension : 1; // True if identifier is a lang extension. bool IsCXX11CompatKeyword : 1; // True if identifier is a keyword in C++11. bool IsPoisoned : 1; // True if identifier is poisoned. @@ -70,13 +70,13 @@ class IdentifierInfo { // stored externally. bool IsModulesImport : 1; // True if this is the 'import' contextual // keyword. - // 1 bit left in 32-bit word. - + // 32-bit word is filled. + void *FETokenInfo; // Managed by the language front-end. llvm::StringMapEntry<IdentifierInfo*> *Entry; - IdentifierInfo(const IdentifierInfo&); // NONCOPYABLE. - void operator=(const IdentifierInfo&); // NONASSIGNABLE. + IdentifierInfo(const IdentifierInfo&) LLVM_DELETED_FUNCTION; + void operator=(const IdentifierInfo&) LLVM_DELETED_FUNCTION; friend class IdentifierTable; @@ -133,10 +133,21 @@ public: if (HasMacro == Val) return; HasMacro = Val; - if (Val) + if (Val) { NeedsHandleIdentifier = 1; - else + HadMacro = true; + } else { RecomputeNeedsHandleIdentifier(); + } + } + /// \brief Returns true if this identifier was \#defined to some value at any + /// moment. In this case there should be an entry for the identifier in the + /// macro history table in Preprocessor. + bool hadMacroDefinition() const { + return HadMacro; + } + void setHadMacroDefinition(bool Val) { + HadMacro = Val; } /// getTokenID - If this is a source-language token (e.g. 'for'), this API @@ -346,8 +357,8 @@ public: /// actual functionality. class IdentifierIterator { private: - IdentifierIterator(const IdentifierIterator&); // Do not implement - IdentifierIterator &operator=(const IdentifierIterator&); // Do not implement + IdentifierIterator(const IdentifierIterator &) LLVM_DELETED_FUNCTION; + void operator=(const IdentifierIterator &) LLVM_DELETED_FUNCTION; protected: IdentifierIterator() { } @@ -695,8 +706,8 @@ public: /// multi-keyword caching. class SelectorTable { void *Impl; // Actually a SelectorTableImpl - SelectorTable(const SelectorTable&); // DISABLED: DO NOT IMPLEMENT - void operator=(const SelectorTable&); // DISABLED: DO NOT IMPLEMENT + SelectorTable(const SelectorTable &) LLVM_DELETED_FUNCTION; + void operator=(const SelectorTable &) LLVM_DELETED_FUNCTION; public: SelectorTable(); ~SelectorTable(); diff --git a/include/clang/Basic/LangOptions.def b/include/clang/Basic/LangOptions.def index fab17a2..dbc08c7 100644 --- a/include/clang/Basic/LangOptions.def +++ b/include/clang/Basic/LangOptions.def @@ -48,15 +48,19 @@ LANGOPT(MicrosoftMode , 1, 0, "Microsoft compatibility mode") LANGOPT(Borland , 1, 0, "Borland extensions") LANGOPT(CPlusPlus , 1, 0, "C++") LANGOPT(CPlusPlus0x , 1, 0, "C++0x") +LANGOPT(CPlusPlus1y , 1, 0, "C++1y") LANGOPT(ObjC1 , 1, 0, "Objective-C 1") LANGOPT(ObjC2 , 1, 0, "Objective-C 2") BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0, "Objective-C auto-synthesized properties") +BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0, + "Encoding extended block type signature") BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1, "Objective-C related result type inference") LANGOPT(Trigraphs , 1, 0,"trigraphs") -LANGOPT(BCPLComment , 1, 0, "BCPL-style '//' comments") +LANGOPT(LineComment , 1, 0, "'//' comments") LANGOPT(Bool , 1, 0, "bool, true, and false keywords") +LANGOPT(WChar , 1, CPlusPlus, "wchar_t keyword") BENIGN_LANGOPT(DollarIdents , 1, 1, "'$' in identifiers") BENIGN_LANGOPT(AsmPreprocessor, 1, 0, "preprocessor in asm mode") BENIGN_LANGOPT(GNUMode , 1, 1, "GNU extensions") @@ -115,7 +119,6 @@ LANGOPT(CUDA , 1, 0, "CUDA") LANGOPT(AssumeSaneOperatorNew , 1, 1, "implicit __attribute__((malloc)) for C++'s new operators") BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision") -BENIGN_LANGOPT(CatchUndefined , 1, 0, "catching undefined behavior at run time") BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records") BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form") BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables") @@ -125,8 +128,6 @@ BENIGN_LANGOPT(ParseUnknownAnytype, 1, 0, "__unknown_anytype") BENIGN_LANGOPT(DebuggerSupport , 1, 0, "debugger support") BENIGN_LANGOPT(DebuggerCastResultToId, 1, 0, "for 'po' in the debugger, cast the result to id if it is of unknown type") BENIGN_LANGOPT(DebuggerObjCLiteral , 1, 0, "debugger Objective-C literals and subscripting support") -BENIGN_LANGOPT(AddressSanitizer , 1, 0, "AddressSanitizer enabled") -BENIGN_LANGOPT(ThreadSanitizer , 1, 0, "ThreadSanitizer enabled") BENIGN_LANGOPT(SpellChecking , 1, 1, "spell-checking") LANGOPT(SinglePrecisionConstants , 1, 0, "treating double-precision floating point constants as single precision constants") @@ -135,7 +136,7 @@ LANGOPT(DefaultFPContract , 1, 0, "FP_CONTRACT") LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment") LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility") LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting") -LANGOPT(ObjCRuntimeHasWeak , 1, 0, "__weak support in the ARC runtime") +LANGOPT(ObjCARCWeak , 1, 0, "__weak support in the ARC runtime") LANGOPT(FakeAddressSpaceMap , 1, 0, "OpenCL fake address space map") LANGOPT(MRTD , 1, 0, "-mrtd calling convention") @@ -162,6 +163,17 @@ 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/Module.h b/include/clang/Basic/Module.h index c8027f4..b6b088c 100644 --- a/include/clang/Basic/Module.h +++ b/include/clang/Basic/Module.h @@ -21,6 +21,7 @@ #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> @@ -63,11 +64,21 @@ private: /// \brief A mapping from the submodule name to the index into the /// \c SubModules vector at which that submodule resides. llvm::StringMap<unsigned> SubModuleIndex; + + /// \brief The AST file if this is a top-level module which has a + /// corresponding serialized AST file, or null otherwise. + const FileEntry *ASTFile; public: /// \brief The headers that are part of this module. llvm::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; + /// \brief The set of language features required to use this module. /// /// If any of these features is not present, the \c IsAvailable bit @@ -158,7 +169,7 @@ public: /// \brief Construct a top-level module. explicit Module(StringRef Name, SourceLocation DefinitionLoc, bool IsFramework) - : Name(Name), DefinitionLoc(DefinitionLoc), Parent(0), Umbrella(), + : Name(Name), DefinitionLoc(DefinitionLoc), Parent(0),Umbrella(),ASTFile(0), IsAvailable(true), IsFromModuleFile(false), IsFramework(IsFramework), IsExplicit(false), IsSystem(false), InferSubmodules(false), InferExplicitSubmodules(false), @@ -227,7 +238,18 @@ public: StringRef getTopLevelModuleName() const { return getTopLevelModule()->Name; } - + + /// \brief The serialized AST file for this module, if one was created. + const FileEntry *getASTFile() const { + return getTopLevelModule()->ASTFile; + } + + /// \brief Set the serialized AST file for the top-level module of this module. + void setASTFile(const FileEntry *File) { + assert((getASTFile() == 0 || getASTFile() == File) && "file path changed"); + getTopLevelModule()->ASTFile = File; + } + /// \brief Retrieve the directory for which this module serves as the /// umbrella. const DirectoryEntry *getUmbrellaDir() const; @@ -271,6 +293,10 @@ public: submodule_iterator submodule_end() { return SubModules.end(); } submodule_const_iterator submodule_end() const { return SubModules.end(); } + 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; diff --git a/include/clang/Basic/ObjCRuntime.h b/include/clang/Basic/ObjCRuntime.h index b24fe7c..d543b76 100644 --- a/include/clang/Basic/ObjCRuntime.h +++ b/include/clang/Basic/ObjCRuntime.h @@ -126,12 +126,25 @@ public: return !isGNUFamily(); } + /// \brief Does this runtime allow ARC at all? + bool allowsARC() const { + switch (getKind()) { + case FragileMacOSX: return false; + case MacOSX: return true; + case iOS: return true; + case GCC: return false; + case GNUstep: return true; + case ObjFW: return true; + } + llvm_unreachable("bad kind"); + } + /// \brief Does this runtime natively provide the ARC entrypoints? /// /// ARC cannot be directly supported on a platform that does not provide /// these entrypoints, although it may be supportable via a stub /// library. - bool hasARC() const { + bool hasNativeARC() const { switch (getKind()) { case FragileMacOSX: return false; case MacOSX: return getVersion() >= VersionTuple(10, 7); @@ -139,16 +152,35 @@ public: case GCC: return false; case GNUstep: return getVersion() >= VersionTuple(1, 6); - case ObjFW: return false; // XXX: this will change soon + case ObjFW: return true; } llvm_unreachable("bad kind"); } + /// \brief Does this runtime supports optimized setter entrypoints? + bool hasOptimizedSetter() const { + switch (getKind()) { + case MacOSX: + return getVersion() >= VersionTuple(10, 8); + case iOS: + return (getVersion() >= VersionTuple(6)); + + default: + return false; + } + } + + /// Does this runtime allow the use of __weak? + bool allowsWeak() const { + return hasNativeWeak(); + } + /// \brief Does this runtime natively provide ARC-compliant 'weak' /// entrypoints? - bool hasWeak() const { - // Right now, this is always equivalent to the ARC decision. - return hasARC(); + bool hasNativeWeak() const { + // Right now, this is always equivalent to whether the runtime + // natively supports ARC decision. + return hasNativeARC(); } /// \brief Does this runtime directly support the subscripting methods? @@ -158,7 +190,7 @@ public: switch (getKind()) { case FragileMacOSX: return false; case MacOSX: return getVersion() >= VersionTuple(10, 8); - case iOS: return false; + case iOS: return getVersion() >= VersionTuple(6); // This is really a lie, because some implementations and versions // of the runtime do not support ARC. Probably -fgnu-runtime @@ -226,6 +258,7 @@ public: } llvm_unreachable("bad kind"); } + /// \brief Does this runtime use zero-cost exceptions? bool hasUnwindExceptions() const { switch (getKind()) { diff --git a/include/clang/Basic/OnDiskHashTable.h b/include/clang/Basic/OnDiskHashTable.h index 79273fc..cc9ca9f 100644 --- a/include/clang/Basic/OnDiskHashTable.h +++ b/include/clang/Basic/OnDiskHashTable.h @@ -65,8 +65,7 @@ inline void Emit64(raw_ostream& Out, uint64_t V) { inline void Pad(raw_ostream& Out, unsigned A) { Offset off = (Offset) Out.tell(); - uint32_t n = ((uintptr_t)(off+A-1) & ~(uintptr_t)(A-1)) - off; - for (; n ; --n) + for (uint32_t n = llvm::OffsetToAlignment(off, A); n; --n) Emit8(Out, 0); } @@ -102,7 +101,7 @@ inline uint64_t ReadUnalignedLE64(const unsigned char *&Data) { inline uint32_t ReadLE32(const unsigned char *&Data) { // Hosts that directly support little-endian 32-bit loads can just // use them. Big-endian hosts need a bswap. - uint32_t V = *((uint32_t*)Data); + uint32_t V = *((const uint32_t*)Data); if (llvm::sys::isBigEndianHost()) V = llvm::ByteSwap_32(V); Data += 4; diff --git a/include/clang/Basic/Sanitizers.def b/include/clang/Basic/Sanitizers.def new file mode 100644 index 0000000..085ca16 --- /dev/null +++ b/include/clang/Basic/Sanitizers.def @@ -0,0 +1,69 @@ +//===--- Sanitizers.def - Runtime sanitizer options -------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file defines the options for specifying which runtime sanitizers to +// enable. Users of this file must define the SANITIZER macro to make use of +// this information. Users of this file can also define the SANITIZER_GROUP +// macro to get information on options which refer to sets of sanitizers. +// +//===----------------------------------------------------------------------===// + +#ifndef SANITIZER +#error "Define SANITIZER prior to including this file!" +#endif + +// SANITIZER(NAME, ID) + +// The first value is the name of the sanitizer as a string. The sanitizer can +// be enabled by specifying -fsanitize=NAME. + +// The second value is an identifier which can be used to refer to the +// sanitizer. + + +// SANITIZER_GROUP(NAME, ID, ALIAS) + +// The first two values have the same semantics as the corresponding SANITIZER +// values. The third value is an expression ORing together the IDs of individual +// sanitizers in this group. + +#ifndef SANITIZER_GROUP +#define SANITIZER_GROUP(NAME, ID, ALIAS) +#endif + + +// AddressSanitizer +SANITIZER("address", Address) + +// ThreadSanitizer +SANITIZER("thread", Thread) + +// UndefinedBehaviorSanitizer +SANITIZER("signed-integer-overflow", SignedIntegerOverflow) +SANITIZER("divide-by-zero", DivideByZero) +SANITIZER("shift", Shift) +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. +SANITIZER_GROUP("undefined", Undefined, + SignedIntegerOverflow | DivideByZero | Shift | Unreachable | + Return | VLABound | Alignment | Null | Vptr | ObjectSize | + FloatCastOverflow) + +#undef SANITIZER +#undef SANITIZER_GROUP diff --git a/include/clang/Basic/SourceLocation.h b/include/clang/Basic/SourceLocation.h index d6bba38..cfcf468 100644 --- a/include/clang/Basic/SourceLocation.h +++ b/include/clang/Basic/SourceLocation.h @@ -21,6 +21,7 @@ #include <utility> #include <functional> #include <cassert> +#include <string> namespace llvm { class MemoryBuffer; @@ -171,6 +172,7 @@ public: } void print(raw_ostream &OS, const SourceManager &SM) const; + LLVM_ATTRIBUTE_USED std::string printToString(const SourceManager &SM) const; void dump(const SourceManager &SM) const; }; diff --git a/include/clang/Basic/SourceManager.h b/include/clang/Basic/SourceManager.h index 32268d7..db6bfd2 100644 --- a/include/clang/Basic/SourceManager.h +++ b/include/clang/Basic/SourceManager.h @@ -62,7 +62,6 @@ class LangOptions; class ASTWriter; class ASTReader; -/// \namespace /// \brief Public enums and private classes that are part of the /// SourceManager implementation. /// @@ -221,7 +220,7 @@ namespace SrcMgr { private: // Disable assignments. - ContentCache &operator=(const ContentCache& RHS); + ContentCache &operator=(const ContentCache& RHS) LLVM_DELETED_FUNCTION; }; /// \brief Information about a FileID, basically just the logical file @@ -647,8 +646,8 @@ class SourceManager : public RefCountedBase<SourceManager> { mutable llvm::DenseMap<FileID, MacroArgsMap *> MacroArgsCacheMap; // SourceManager doesn't support copy construction. - explicit SourceManager(const SourceManager&); - void operator=(const SourceManager&); + explicit SourceManager(const SourceManager&) LLVM_DELETED_FUNCTION; + void operator=(const SourceManager&) LLVM_DELETED_FUNCTION; public: SourceManager(DiagnosticsEngine &Diag, FileManager &FileMgr, bool UserFilesAreVolatile = false); @@ -675,9 +674,10 @@ public: /// /// One example of when this would be used is when the main source is read /// from STDIN. - FileID createMainFileIDForMemBuffer(const llvm::MemoryBuffer *Buffer) { + FileID createMainFileIDForMemBuffer(const llvm::MemoryBuffer *Buffer, + SrcMgr::CharacteristicKind Kind = SrcMgr::C_User) { assert(MainFileID.isInvalid() && "MainFileID already set!"); - MainFileID = createFileIDForMemBuffer(Buffer); + MainFileID = createFileIDForMemBuffer(Buffer, Kind); return MainFileID; } @@ -734,10 +734,11 @@ public: /// This does no caching of the buffer and takes ownership of the /// MemoryBuffer, so only pass a MemoryBuffer to this once. FileID createFileIDForMemBuffer(const llvm::MemoryBuffer *Buffer, + SrcMgr::CharacteristicKind FileCharacter = SrcMgr::C_User, int LoadedID = 0, unsigned LoadedOffset = 0, SourceLocation IncludeLoc = SourceLocation()) { return createFileID(createMemBufferContentCache(Buffer), IncludeLoc, - SrcMgr::C_User, LoadedID, LoadedOffset); + FileCharacter, LoadedID, LoadedOffset); } /// \brief Return a new SourceLocation that encodes the @@ -1557,7 +1558,11 @@ private: getDecomposedSpellingLocSlowCase(const SrcMgr::SLocEntry *E, unsigned Offset) const; void computeMacroArgsCache(MacroArgsMap *&MacroArgsCache, FileID FID) const; - + void associateFileChunkWithMacroArgExp(MacroArgsMap &MacroArgsCache, + FileID FID, + SourceLocation SpellLoc, + SourceLocation ExpansionLoc, + unsigned ExpansionLength) const; friend class ASTReader; friend class ASTWriter; }; diff --git a/include/clang/Basic/Specifiers.h b/include/clang/Basic/Specifiers.h index 96cada1..c82b8cb 100644 --- a/include/clang/Basic/Specifiers.h +++ b/include/clang/Basic/Specifiers.h @@ -53,6 +53,7 @@ namespace clang { TST_union, TST_struct, TST_class, // C++ class type + TST_interface, // C++ (Microsoft-specific) __interface type TST_typename, // Typedef, C++ class-name or enum name, etc. TST_typeofType, TST_typeofExpr, @@ -174,6 +175,20 @@ namespace clang { ICIS_CopyInit, ///< Copy initialization. ICIS_ListInit ///< Direct list-initialization. }; + + /// \brief CallingConv - Specifies the calling convention that a function uses. + enum CallingConv { + CC_Default, + CC_C, // __attribute__((cdecl)) + CC_X86StdCall, // __attribute__((stdcall)) + CC_X86FastCall, // __attribute__((fastcall)) + CC_X86ThisCall, // __attribute__((thiscall)) + CC_X86Pascal, // __attribute__((pascal)) + CC_AAPCS, // __attribute__((pcs("aapcs"))) + CC_AAPCS_VFP, // __attribute__((pcs("aapcs-vfp"))) + CC_PnaclCall // __attribute__((pnaclcall)) + }; + } // end namespace clang #endif // LLVM_CLANG_BASIC_SPECIFIERS_H diff --git a/include/clang/Basic/StmtNodes.td b/include/clang/Basic/StmtNodes.td index 47738af..8f6a1c9 100644 --- a/include/clang/Basic/StmtNodes.td +++ b/include/clang/Basic/StmtNodes.td @@ -28,11 +28,10 @@ def SwitchCase : Stmt<1>; def CaseStmt : DStmt<SwitchCase>; def DefaultStmt : DStmt<SwitchCase>; -// GNU Extensions -def AsmStmt : Stmt; - -// MS Extensions -def MSAsmStmt : Stmt; +// Asm statements +def AsmStmt : Stmt<1>; +def GCCAsmStmt : DStmt<AsmStmt>; +def MSAsmStmt : DStmt<AsmStmt>; // Obj-C statements def ObjCAtTryStmt : Stmt; @@ -132,6 +131,7 @@ def PackExpansionExpr : DStmt<Expr>; def SizeOfPackExpr : DStmt<Expr>; def SubstNonTypeTemplateParmExpr : DStmt<Expr>; def SubstNonTypeTemplateParmPackExpr : DStmt<Expr>; +def FunctionParmPackExpr : DStmt<Expr>; def MaterializeTemporaryExpr : DStmt<Expr>; def LambdaExpr : DStmt<Expr>; diff --git a/include/clang/Basic/TargetInfo.h b/include/clang/Basic/TargetInfo.h index 54d49e6..2d26783 100644 --- a/include/clang/Basic/TargetInfo.h +++ b/include/clang/Basic/TargetInfo.h @@ -23,7 +23,9 @@ #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> @@ -38,7 +40,6 @@ class LangOptions; class MacroBuilder; class SourceLocation; class SourceManager; -class TargetOptions; namespace Builtin { struct Info; } @@ -61,6 +62,7 @@ enum TargetCXXABI { /// \brief Exposes information about the current target. /// class TargetInfo : public RefCountedBase<TargetInfo> { + llvm::IntrusiveRefCntPtr<TargetOptions> TargetOpts; llvm::Triple Triple; protected: // Target values set by the ctor of the actual target implementation. Default @@ -111,6 +113,16 @@ public: virtual ~TargetInfo(); + /// \brief Retrieve the target options. + TargetOptions &getTargetOpts() const { + assert(TargetOpts && "Missing target options"); + return *TargetOpts; + } + + void setTargetOpts(TargetOptions &TargetOpts) { + this->TargetOpts = &TargetOpts; + } + ///===---- Target Data Type Query Methods -------------------------------===// enum IntType { NoInt = 0, @@ -150,12 +162,18 @@ public: /// __builtin_va_list as defined by the x86-64 ABI: /// http://www.x86-64.org/documentation/abi.pdf - X86_64ABIBuiltinVaList + X86_64ABIBuiltinVaList, + + /// __builtin_va_list as defined by ARM AAPCS ABI + /// http://infocenter.arm.com + // /help/topic/com.arm.doc.ihi0042d/IHI0042D_aapcs.pdf + AAPCSABIBuiltinVaList }; protected: IntType SizeType, IntMaxType, UIntMaxType, PtrDiffType, IntPtrType, WCharType, - WIntType, Char16Type, Char32Type, Int64Type, SigAtomicType; + WIntType, Char16Type, Char32Type, Int64Type, SigAtomicType, + ProcessIDType; /// \brief Whether Objective-C's built-in boolean type should be signed char. /// @@ -196,7 +214,7 @@ public: IntType getChar32Type() const { return Char32Type; } IntType getInt64Type() const { return Int64Type; } IntType getSigAtomicType() const { return SigAtomicType; } - + IntType getProcessIDType() const { return ProcessIDType; } /// \brief Return the width (in bits) of the specified integer type enum. /// @@ -500,6 +518,11 @@ public: bool validateInputConstraint(ConstraintInfo *OutputConstraints, unsigned NumOutputs, ConstraintInfo &info) const; + virtual bool validateConstraintModifier(StringRef /*Constraint*/, + const char /*Modifier*/, + unsigned /*Size*/) const { + return true; + } bool resolveSymbolicName(const char *&Name, ConstraintInfo *OutputConstraints, unsigned NumOutputs, unsigned &Index) const; @@ -712,6 +735,34 @@ public: bool isBigEndian() const { return BigEndian; } + /// \brief Gets the default calling convention for the given target and + /// declaration context. + virtual CallingConv getDefaultCallingConv() 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; + } + + enum CallingConvCheckResult { + CCCR_OK, + CCCR_Warning + }; + + /// \brief Determines whether a given calling convention is valid for the + /// target. A calling convention can either be accepted, produce a warning + /// and be substituted with the default calling convention, or (someday) + /// produce an error (such as using thiscall on a non-instance function). + virtual CallingConvCheckResult checkCallingConvention(CallingConv CC) const { + switch (CC) { + default: + return CCCR_Warning; + case CC_C: + case CC_Default: + return CCCR_OK; + } + } + protected: virtual uint64_t getPointerWidthV(unsigned AddrSpace) const { return PointerWidth; diff --git a/include/clang/Basic/TargetOptions.h b/include/clang/Basic/TargetOptions.h index 15ececd..d6deb02 100644 --- a/include/clang/Basic/TargetOptions.h +++ b/include/clang/Basic/TargetOptions.h @@ -15,13 +15,14 @@ #ifndef LLVM_CLANG_FRONTEND_TARGETOPTIONS_H #define LLVM_CLANG_FRONTEND_TARGETOPTIONS_H +#include "llvm/ADT/IntrusiveRefCntPtr.h" #include <string> #include <vector> namespace clang { /// \brief Options for controlling the target. -class TargetOptions { +class TargetOptions : public RefCountedBase<TargetOptions> { public: /// If given, the name of the target triple to compile for. If not given the /// target will be selected to match the host. @@ -40,6 +41,9 @@ public: /// If given, the version string of the linker in use. std::string LinkerVersion; + /// \brief The list of target specific features to enable or disable, as written on the command line. + std::vector<std::string> FeaturesAsWritten; + /// The list of target specific features to enable or disable -- this should /// be a list of strings starting with by '+' or '-'. std::vector<std::string> Features; diff --git a/include/clang/Basic/TokenKinds.def b/include/clang/Basic/TokenKinds.def index fc03191..25e8d5a 100644 --- a/include/clang/Basic/TokenKinds.def +++ b/include/clang/Basic/TokenKinds.def @@ -217,6 +217,7 @@ PUNCTUATOR(greatergreatergreater, ">>>") // KEYALTIVEC - This is a keyword in AltiVec // KEYBORLAND - This is a keyword if Borland extensions are enabled // BOOLSUPPORT - This is a keyword if 'bool' is a built-in type +// WCHARSUPPORT - This is a keyword if 'wchar_t' is a built-in type // KEYWORD(auto , KEYALL) KEYWORD(break , KEYALL) @@ -295,7 +296,7 @@ KEYWORD(typename , KEYCXX) KEYWORD(typeid , KEYCXX) KEYWORD(using , KEYCXX) KEYWORD(virtual , KEYCXX) -KEYWORD(wchar_t , KEYCXX) +KEYWORD(wchar_t , WCHARSUPPORT) // C++ 2.5p2: Alternative Representations. CXX_KEYWORD_OPERATOR(and , ampamp) @@ -364,6 +365,7 @@ 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) // Name for GCC 4.6 compatibility - people have already written libraries using @@ -505,6 +507,7 @@ KEYWORD(__if_not_exists , KEYMS) KEYWORD(__single_inheritance , KEYMS) KEYWORD(__multiple_inheritance , KEYMS) KEYWORD(__virtual_inheritance , KEYMS) +KEYWORD(__interface , KEYMS) ALIAS("__int8" , char , KEYMS) ALIAS("__int16" , short , KEYMS) ALIAS("__int32" , int , KEYMS) @@ -518,7 +521,6 @@ ALIAS("_thiscall" , __thiscall , KEYMS) ALIAS("_uuidof" , __uuidof , KEYMS | KEYBORLAND) ALIAS("_inline" , inline , KEYMS) ALIAS("_declspec" , __declspec , KEYMS) -ALIAS("__interface" , struct , KEYMS) // Borland Extensions which should be disabled in strict conformance mode. ALIAS("_pascal" , __pascal , KEYBORLAND) @@ -600,6 +602,41 @@ ANNOTATION(pragma_pack) // handles them. ANNOTATION(pragma_parser_crash) +// Annotation for #pragma ms_struct... +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_msstruct) + +// Annotation for #pragma align... +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_align) + +// Annotation for #pragma weak id +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_weak) + +// Annotation for #pragma weak id = id +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_weakalias) + +// Annotation for #pragma redefine_extname... +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_redefine_extname) + +// Annotation for #pragma STDC FP_CONTRACT... +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_fp_contract) + +// Annotation for #pragma OPENCL EXTENSION... +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_opencl_extension) + #undef ANNOTATION #undef TESTING_KEYWORD #undef OBJC2_AT_KEYWORD diff --git a/include/clang/Basic/TokenKinds.h b/include/clang/Basic/TokenKinds.h index 478add8..e850971 100644 --- a/include/clang/Basic/TokenKinds.h +++ b/include/clang/Basic/TokenKinds.h @@ -63,6 +63,31 @@ const char *getTokenName(enum TokenKind Kind); /// Preprocessor::getSpelling(). const char *getTokenSimpleSpelling(enum TokenKind Kind); +/// \brief Return true if this is a raw identifier or an identifier kind. +inline bool isAnyIdentifier(TokenKind K) { + return (K == tok::identifier) || (K == tok::raw_identifier); +} + +/// \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); +} + +/// \brief Return true if this is any of tok::annot_* kinds. +inline bool isAnnotation(TokenKind K) { +#define ANNOTATION(NAME) \ + if (K == tok::annot_##NAME) \ + return true; +#include "clang/Basic/TokenKinds.def" + return false; +} + } // end namespace tok } // end namespace clang diff --git a/include/clang/Basic/TypeTraits.h b/include/clang/Basic/TypeTraits.h index 0a5a864..882b52d 100644 --- a/include/clang/Basic/TypeTraits.h +++ b/include/clang/Basic/TypeTraits.h @@ -41,6 +41,7 @@ namespace clang { UTT_IsFunction, UTT_IsFundamental, UTT_IsIntegral, + UTT_IsInterfaceClass, UTT_IsLiteral, UTT_IsLvalueReference, UTT_IsMemberFunctionPointer, diff --git a/include/clang/Basic/arm_neon.td b/include/clang/Basic/arm_neon.td index 451d562..3373e01 100644 --- a/include/clang/Basic/arm_neon.td +++ b/include/clang/Basic/arm_neon.td @@ -379,8 +379,8 @@ def VORR : Inst<"vorr", "ddd", "csilUcUsUiUlQcQsQiQlQUcQUsQUiQUl", OP_OR>; def VEOR : Inst<"veor", "ddd", "csilUcUsUiUlQcQsQiQlQUcQUsQUiQUl", OP_XOR>; def VBIC : Inst<"vbic", "ddd", "csilUcUsUiUlQcQsQiQlQUcQUsQUiQUl", OP_ANDN>; def VORN : Inst<"vorn", "ddd", "csilUcUsUiUlQcQsQiQlQUcQUsQUiQUl", OP_ORN>; -def VBSL : Inst<"vbsl", "dudd", - "csilUcUsUiUlfPcPsQcQsQiQlQUcQUsQUiQUlQfQPcQPs", OP_SEL>; +def VBSL : SInst<"vbsl", "dudd", + "csilUcUsUiUlfPcPsQcQsQiQlQUcQUsQUiQUlQfQPcQPs">; //////////////////////////////////////////////////////////////////////////////// // E.3.30 Transposition operations @@ -394,3 +394,7 @@ def VREINTERPRET : Inst<"vreinterpret", "dd", "csilUcUsUiUlhfPcPsQcQsQiQlQUcQUsQUiQUlQhQfQPcQPs", OP_REINT>; +//////////////////////////////////////////////////////////////////////////////// +// Vector fused multiply-add operations + +def VFMA : SInst<"vfma", "dddd", "fQf">; |
