WIP: Builtins: Start adding half versions of math builtins

[arsenm]

Summary

The implementation of the OpenCL builtin currently library uses 2 different hacks to get to the corresponding IR intrinsics from the source. This will allow removal of those.

I'm not sure this is the right naming scheme, but tries to follow the
single character suffix like f/l. This is a problem for sin/cos, since
__builtin_sinh already means double sinh etc. Another alternative might be _f16

[rjmccall]

In N2405 (http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2405.pdf), these are called truncf16, cosf16, etc., which I think is appropriate.

[arsenm]

Change naming scheme, add more and tests

[rjmccall]

LGTM

[arsenm]

r367973

include/clang/Basic/Builtins.def

 
 // Standard libc/libm functions:
 BUILTIN(__builtin_atan2 , "ddd"  , "Fne")
 BUILTIN(__builtin_atan2f, "fff"  , "Fne")
 BUILTIN(__builtin_atan2l, "LdLdLd", "Fne")
 BUILTIN(__builtin_abs  , "ii"  , "ncF")
 BUILTIN(__builtin_copysign, "ddd", "ncF")
 BUILTIN(__builtin_copysignf, "fff", "ncF")
+BUILTIN(__builtin_copysignf16, "hhh", "ncF")
 BUILTIN(__builtin_copysignl, "LdLdLd", "ncF")
 BUILTIN(__builtin_copysignf128, "LLdLLdLLd", "ncF")
 BUILTIN(__builtin_fabs , "dd"  , "ncF")
 BUILTIN(__builtin_fabsf, "ff"  , "ncF")
 BUILTIN(__builtin_fabsl, "LdLd", "ncF")
+BUILTIN(__builtin_fabsf16, "hh"  , "ncF")
 BUILTIN(__builtin_fabsf128, "LLdLLd", "ncF")
 BUILTIN(__builtin_fmod , "ddd"  , "Fne")
 BUILTIN(__builtin_fmodf, "fff"  , "Fne")
+BUILTIN(__builtin_fmodf16, "hhh"  , "Fne")
 BUILTIN(__builtin_fmodl, "LdLdLd", "Fne")
 BUILTIN(__builtin_frexp , "ddi*"  , "Fn")
 BUILTIN(__builtin_frexpf, "ffi*"  , "Fn")
 BUILTIN(__builtin_frexpl, "LdLdi*", "Fn")
 BUILTIN(__builtin_huge_val, "d", "nc")
 BUILTIN(__builtin_huge_valf, "f", "nc")
 BUILTIN(__builtin_huge_vall, "Ld", "nc")
 BUILTIN(__builtin_huge_valf128, "LLd", "nc")

 BUILTIN(__builtin_nansf, "fcC*" , "FnU")
 BUILTIN(__builtin_nansl, "LdcC*", "FnU")
 BUILTIN(__builtin_nansf128, "LLdcC*", "FnU")
 BUILTIN(__builtin_powi , "ddi"  , "Fnc")
 BUILTIN(__builtin_powif, "ffi"  , "Fnc")
 BUILTIN(__builtin_powil, "LdLdi", "Fnc")
 BUILTIN(__builtin_pow , "ddd"  , "Fne")
 BUILTIN(__builtin_powf, "fff"  , "Fne")
+BUILTIN(__builtin_powf16, "hhh"  , "Fne")
 BUILTIN(__builtin_powl, "LdLdLd", "Fne")
 
 // Standard unary libc/libm functions with double/float/long double variants:
 BUILTIN(__builtin_acos , "dd"  , "Fne")
 BUILTIN(__builtin_acosf, "ff"  , "Fne")
 BUILTIN(__builtin_acosl, "LdLd", "Fne")
 BUILTIN(__builtin_acosh , "dd"  , "Fne")
 BUILTIN(__builtin_acoshf, "ff"  , "Fne")

 BUILTIN(__builtin_atanh , "dd", "Fne")
 BUILTIN(__builtin_atanhf, "ff", "Fne")
 BUILTIN(__builtin_atanhl, "LdLd", "Fne")
 BUILTIN(__builtin_cbrt , "dd", "Fnc")
 BUILTIN(__builtin_cbrtf, "ff", "Fnc")
 BUILTIN(__builtin_cbrtl, "LdLd", "Fnc")
 BUILTIN(__builtin_ceil , "dd"  , "Fnc")
 BUILTIN(__builtin_ceilf, "ff"  , "Fnc")
+BUILTIN(__builtin_ceilf16, "hh"  , "Fnc")
 BUILTIN(__builtin_ceill, "LdLd", "Fnc")
 BUILTIN(__builtin_cos , "dd"  , "Fne")
 BUILTIN(__builtin_cosf, "ff"  , "Fne")
+BUILTIN(__builtin_cosf16, "hh"  , "Fne")
 BUILTIN(__builtin_cosh , "dd"  , "Fne")
 BUILTIN(__builtin_coshf, "ff"  , "Fne")
 BUILTIN(__builtin_coshl, "LdLd", "Fne")
 BUILTIN(__builtin_cosl, "LdLd", "Fne")
 BUILTIN(__builtin_erf , "dd", "Fne")
 BUILTIN(__builtin_erff, "ff", "Fne")
 BUILTIN(__builtin_erfl, "LdLd", "Fne")
 BUILTIN(__builtin_erfc , "dd", "Fne")
 BUILTIN(__builtin_erfcf, "ff", "Fne")
 BUILTIN(__builtin_erfcl, "LdLd", "Fne")
 BUILTIN(__builtin_exp , "dd"  , "Fne")
 BUILTIN(__builtin_expf, "ff"  , "Fne")
+BUILTIN(__builtin_expf16, "hh"  , "Fne")
 BUILTIN(__builtin_expl, "LdLd", "Fne")
 BUILTIN(__builtin_exp2 , "dd"  , "Fne")
 BUILTIN(__builtin_exp2f, "ff"  , "Fne")
+BUILTIN(__builtin_exp2f16, "hh"  , "Fne")
 BUILTIN(__builtin_exp2l, "LdLd", "Fne")
 BUILTIN(__builtin_expm1 , "dd", "Fne")
 BUILTIN(__builtin_expm1f, "ff", "Fne")
 BUILTIN(__builtin_expm1l, "LdLd", "Fne")
 BUILTIN(__builtin_fdim, "ddd", "Fne")
 BUILTIN(__builtin_fdimf, "fff", "Fne")
 BUILTIN(__builtin_fdiml, "LdLdLd", "Fne")
 BUILTIN(__builtin_floor , "dd"  , "Fnc")
 BUILTIN(__builtin_floorf, "ff"  , "Fnc")
+BUILTIN(__builtin_floorf16, "hh"  , "Fnc")
 BUILTIN(__builtin_floorl, "LdLd", "Fnc")
 BUILTIN(__builtin_fma, "dddd", "Fne")
 BUILTIN(__builtin_fmaf, "ffff", "Fne")
+BUILTIN(__builtin_fmaf16, "hhhh", "Fne")
 BUILTIN(__builtin_fmal, "LdLdLdLd", "Fne")
 BUILTIN(__builtin_fmax, "ddd", "Fnc")
 BUILTIN(__builtin_fmaxf, "fff", "Fnc")
+BUILTIN(__builtin_fmaxf16, "hhh", "Fnc")
 BUILTIN(__builtin_fmaxl, "LdLdLd", "Fnc")
 BUILTIN(__builtin_fmin, "ddd", "Fnc")
 BUILTIN(__builtin_fminf, "fff", "Fnc")
+BUILTIN(__builtin_fminf16, "hhh", "Fnc")
 BUILTIN(__builtin_fminl, "LdLdLd", "Fnc")
 BUILTIN(__builtin_hypot , "ddd"  , "Fne")
 BUILTIN(__builtin_hypotf, "fff"  , "Fne")
 BUILTIN(__builtin_hypotl, "LdLdLd", "Fne")
 BUILTIN(__builtin_ilogb , "id", "Fne")
 BUILTIN(__builtin_ilogbf, "if", "Fne")
 BUILTIN(__builtin_ilogbl, "iLd", "Fne")
 BUILTIN(__builtin_lgamma , "dd", "Fn")
 BUILTIN(__builtin_lgammaf, "ff", "Fn")
 BUILTIN(__builtin_lgammal, "LdLd", "Fn")
 BUILTIN(__builtin_llrint, "LLid", "Fne")
 BUILTIN(__builtin_llrintf, "LLif", "Fne")
 BUILTIN(__builtin_llrintl, "LLiLd", "Fne")
 BUILTIN(__builtin_llround , "LLid", "Fne")
 BUILTIN(__builtin_llroundf, "LLif", "Fne")
 BUILTIN(__builtin_llroundl, "LLiLd", "Fne")
 BUILTIN(__builtin_log , "dd"  , "Fne")
 BUILTIN(__builtin_log10 , "dd"  , "Fne")
 BUILTIN(__builtin_log10f, "ff"  , "Fne")
+BUILTIN(__builtin_log10f16, "hh"  , "Fne")
 BUILTIN(__builtin_log10l, "LdLd", "Fne")
 BUILTIN(__builtin_log1p , "dd"  , "Fne")
 BUILTIN(__builtin_log1pf, "ff"  , "Fne")
 BUILTIN(__builtin_log1pl, "LdLd", "Fne")
 BUILTIN(__builtin_log2, "dd"  , "Fne")
 BUILTIN(__builtin_log2f, "ff"  , "Fne")
+BUILTIN(__builtin_log2f16, "hh"  , "Fne")
 BUILTIN(__builtin_log2l, "LdLd"  , "Fne")
 BUILTIN(__builtin_logb , "dd", "Fne")
 BUILTIN(__builtin_logbf, "ff", "Fne")
 BUILTIN(__builtin_logbl, "LdLd", "Fne")
 BUILTIN(__builtin_logf, "ff"  , "Fne")
+BUILTIN(__builtin_logf16, "hh"  , "Fne")
 BUILTIN(__builtin_logl, "LdLd", "Fne")
 BUILTIN(__builtin_lrint , "Lid", "Fne")
 BUILTIN(__builtin_lrintf, "Lif", "Fne")
 BUILTIN(__builtin_lrintl, "LiLd", "Fne")
 BUILTIN(__builtin_lround , "Lid", "Fne")
 BUILTIN(__builtin_lroundf, "Lif", "Fne")
 BUILTIN(__builtin_lroundl, "LiLd", "Fne")
 BUILTIN(__builtin_nearbyint , "dd", "Fnc")
 BUILTIN(__builtin_nearbyintf, "ff", "Fnc")
 BUILTIN(__builtin_nearbyintl, "LdLd", "Fnc")
 BUILTIN(__builtin_nextafter , "ddd", "Fne")
 BUILTIN(__builtin_nextafterf, "fff", "Fne")
 BUILTIN(__builtin_nextafterl, "LdLdLd", "Fne")
 BUILTIN(__builtin_nexttoward , "ddLd", "Fne")
 BUILTIN(__builtin_nexttowardf, "ffLd", "Fne")
 BUILTIN(__builtin_nexttowardl, "LdLdLd", "Fne")
 BUILTIN(__builtin_remainder , "ddd", "Fne")
 BUILTIN(__builtin_remainderf, "fff", "Fne")
 BUILTIN(__builtin_remainderl, "LdLdLd", "Fne")
 BUILTIN(__builtin_remquo , "dddi*", "Fn")
 BUILTIN(__builtin_remquof, "fffi*", "Fn")
 BUILTIN(__builtin_remquol, "LdLdLdi*", "Fn")
 BUILTIN(__builtin_rint , "dd", "Fnc")
 BUILTIN(__builtin_rintf, "ff", "Fnc")
+BUILTIN(__builtin_rintf16, "hh", "Fnc")
 BUILTIN(__builtin_rintl, "LdLd", "Fnc")
 BUILTIN(__builtin_round, "dd"  , "Fnc")
 BUILTIN(__builtin_roundf, "ff"  , "Fnc")
+BUILTIN(__builtin_roundf16, "hh"  , "Fnc")
 BUILTIN(__builtin_roundl, "LdLd"  , "Fnc")
 BUILTIN(__builtin_scalbln , "ddLi", "Fne")
 BUILTIN(__builtin_scalblnf, "ffLi", "Fne")
 BUILTIN(__builtin_scalblnl, "LdLdLi", "Fne")
 BUILTIN(__builtin_scalbn , "ddi", "Fne")
 BUILTIN(__builtin_scalbnf, "ffi", "Fne")
 BUILTIN(__builtin_scalbnl, "LdLdi", "Fne")
 BUILTIN(__builtin_sin , "dd"  , "Fne")
 BUILTIN(__builtin_sinf, "ff"  , "Fne")
+BUILTIN(__builtin_sinf16, "hh"  , "Fne")
 BUILTIN(__builtin_sinh , "dd"  , "Fne")
 BUILTIN(__builtin_sinhf, "ff"  , "Fne")
 BUILTIN(__builtin_sinhl, "LdLd", "Fne")
 BUILTIN(__builtin_sinl, "LdLd", "Fne")
 BUILTIN(__builtin_sqrt , "dd"  , "Fne")
 BUILTIN(__builtin_sqrtf, "ff"  , "Fne")
+BUILTIN(__builtin_sqrtf16, "hh"  , "Fne")
 BUILTIN(__builtin_sqrtl, "LdLd", "Fne")
 BUILTIN(__builtin_tan , "dd"  , "Fne")
 BUILTIN(__builtin_tanf, "ff"  , "Fne")
 BUILTIN(__builtin_tanh , "dd"  , "Fne")
 BUILTIN(__builtin_tanhf, "ff"  , "Fne")
 BUILTIN(__builtin_tanhl, "LdLd", "Fne")
 BUILTIN(__builtin_tanl, "LdLd", "Fne")
 BUILTIN(__builtin_tgamma , "dd", "Fne")
 BUILTIN(__builtin_tgammaf, "ff", "Fne")
 BUILTIN(__builtin_tgammal, "LdLd", "Fne")
 BUILTIN(__builtin_trunc , "dd", "Fnc")
 BUILTIN(__builtin_truncf, "ff", "Fnc")
 BUILTIN(__builtin_truncl, "LdLd", "Fnc")
+BUILTIN(__builtin_truncf16, "hh", "Fnc")
 
 // C99 complex builtins
 BUILTIN(__builtin_cabs, "dXd", "Fne")
 BUILTIN(__builtin_cabsf, "fXf", "Fne")
 BUILTIN(__builtin_cabsl, "LdXLd", "Fne")
 BUILTIN(__builtin_cacos, "XdXd", "Fne")
 BUILTIN(__builtin_cacosf, "XfXf", "Fne")
 BUILTIN(__builtin_cacosh, "XdXd", "Fne")

 // FP signbit builtins
 BUILTIN(__builtin_signbit, "i.", "Fnc")
 BUILTIN(__builtin_signbitf, "if", "Fnc")
 BUILTIN(__builtin_signbitl, "iLd", "Fnc")
 
 // Special FP builtins.
 BUILTIN(__builtin_canonicalize, "dd", "nc")
 BUILTIN(__builtin_canonicalizef, "ff", "nc")
+BUILTIN(__builtin_canonicalizef16, "hh", "nc")
 BUILTIN(__builtin_canonicalizel, "LdLd", "nc")
 
 // Builtins for arithmetic.
 BUILTIN(__builtin_clzs , "iUs"  , "nc")
 BUILTIN(__builtin_clz  , "iUi"  , "nc")
 BUILTIN(__builtin_clzl , "iULi" , "nc")
 BUILTIN(__builtin_clzll, "iULLi", "nc")
 // TODO: int clzimax(uintmax_t)

lib/CodeGen/CGBuiltin.cpp

RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   // LLVM counterparts if the call is marked 'const' (known to never set errno).
   if (FD->hasAttr<ConstAttr>()) {
     switch (BuiltinID) {
     case Builtin::BIceil:
     case Builtin::BIceilf:
     case Builtin::BIceill:
     case Builtin::BI__builtin_ceil:
     case Builtin::BI__builtin_ceilf:
+    case Builtin::BI__builtin_ceilf16:
     case Builtin::BI__builtin_ceill:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::ceil));
 
     case Builtin::BIcopysign:
     case Builtin::BIcopysignf:
     case Builtin::BIcopysignl:
     case Builtin::BI__builtin_copysign:
     case Builtin::BI__builtin_copysignf:
+    case Builtin::BI__builtin_copysignf16:
     case Builtin::BI__builtin_copysignl:
     case Builtin::BI__builtin_copysignf128:
       return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::copysign));
 
     case Builtin::BIcos:
     case Builtin::BIcosf:
     case Builtin::BIcosl:
     case Builtin::BI__builtin_cos:
     case Builtin::BI__builtin_cosf:
+    case Builtin::BI__builtin_cosf16:
     case Builtin::BI__builtin_cosl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::cos));
 
     case Builtin::BIexp:
     case Builtin::BIexpf:
     case Builtin::BIexpl:
     case Builtin::BI__builtin_exp:
     case Builtin::BI__builtin_expf:
+    case Builtin::BI__builtin_expf16:
     case Builtin::BI__builtin_expl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp));
 
     case Builtin::BIexp2:
     case Builtin::BIexp2f:
     case Builtin::BIexp2l:
     case Builtin::BI__builtin_exp2:
     case Builtin::BI__builtin_exp2f:
+    case Builtin::BI__builtin_exp2f16:
     case Builtin::BI__builtin_exp2l:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::exp2));
 
     case Builtin::BIfabs:
     case Builtin::BIfabsf:
     case Builtin::BIfabsl:
     case Builtin::BI__builtin_fabs:
     case Builtin::BI__builtin_fabsf:
+    case Builtin::BI__builtin_fabsf16:
     case Builtin::BI__builtin_fabsl:
     case Builtin::BI__builtin_fabsf128:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::fabs));
 
     case Builtin::BIfloor:
     case Builtin::BIfloorf:
     case Builtin::BIfloorl:
     case Builtin::BI__builtin_floor:
     case Builtin::BI__builtin_floorf:
+    case Builtin::BI__builtin_floorf16:
     case Builtin::BI__builtin_floorl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::floor));
 
     case Builtin::BIfma:
     case Builtin::BIfmaf:
     case Builtin::BIfmal:
     case Builtin::BI__builtin_fma:
     case Builtin::BI__builtin_fmaf:
+    case Builtin::BI__builtin_fmaf16:
     case Builtin::BI__builtin_fmal:
       return RValue::get(emitTernaryBuiltin(*this, E, Intrinsic::fma));
 
     case Builtin::BIfmax:
     case Builtin::BIfmaxf:
     case Builtin::BIfmaxl:
     case Builtin::BI__builtin_fmax:
     case Builtin::BI__builtin_fmaxf:
+    case Builtin::BI__builtin_fmaxf16:
     case Builtin::BI__builtin_fmaxl:
       return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::maxnum));
 
     case Builtin::BIfmin:
     case Builtin::BIfminf:
     case Builtin::BIfminl:
     case Builtin::BI__builtin_fmin:
     case Builtin::BI__builtin_fminf:
+    case Builtin::BI__builtin_fminf16:
     case Builtin::BI__builtin_fminl:
       return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::minnum));
 
     // fmod() is a special-case. It maps to the frem instruction rather than an
     // LLVM intrinsic.
     case Builtin::BIfmod:
     case Builtin::BIfmodf:
     case Builtin::BIfmodl:
     case Builtin::BI__builtin_fmod:
     case Builtin::BI__builtin_fmodf:
+    case Builtin::BI__builtin_fmodf16:
     case Builtin::BI__builtin_fmodl: {
       Value *Arg1 = EmitScalarExpr(E->getArg(0));
       Value *Arg2 = EmitScalarExpr(E->getArg(1));
       return RValue::get(Builder.CreateFRem(Arg1, Arg2, "fmod"));
     }
 
     case Builtin::BIlog:
     case Builtin::BIlogf:
     case Builtin::BIlogl:
     case Builtin::BI__builtin_log:
     case Builtin::BI__builtin_logf:
+    case Builtin::BI__builtin_logf16:
     case Builtin::BI__builtin_logl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log));
 
     case Builtin::BIlog10:
     case Builtin::BIlog10f:
     case Builtin::BIlog10l:
     case Builtin::BI__builtin_log10:
     case Builtin::BI__builtin_log10f:
+    case Builtin::BI__builtin_log10f16:
     case Builtin::BI__builtin_log10l:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log10));
 
     case Builtin::BIlog2:
     case Builtin::BIlog2f:
     case Builtin::BIlog2l:
     case Builtin::BI__builtin_log2:
     case Builtin::BI__builtin_log2f:
+    case Builtin::BI__builtin_log2f16:
     case Builtin::BI__builtin_log2l:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::log2));
 
     case Builtin::BInearbyint:
     case Builtin::BInearbyintf:
     case Builtin::BInearbyintl:
     case Builtin::BI__builtin_nearbyint:
     case Builtin::BI__builtin_nearbyintf:
     case Builtin::BI__builtin_nearbyintl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::nearbyint));
 
     case Builtin::BIpow:
     case Builtin::BIpowf:
     case Builtin::BIpowl:
     case Builtin::BI__builtin_pow:
     case Builtin::BI__builtin_powf:
+    case Builtin::BI__builtin_powf16:
     case Builtin::BI__builtin_powl:
       return RValue::get(emitBinaryBuiltin(*this, E, Intrinsic::pow));
 
     case Builtin::BIrint:
     case Builtin::BIrintf:
     case Builtin::BIrintl:
     case Builtin::BI__builtin_rint:
     case Builtin::BI__builtin_rintf:
+    case Builtin::BI__builtin_rintf16:
     case Builtin::BI__builtin_rintl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::rint));
 
     case Builtin::BIround:
     case Builtin::BIroundf:
     case Builtin::BIroundl:
     case Builtin::BI__builtin_round:
     case Builtin::BI__builtin_roundf:
+    case Builtin::BI__builtin_roundf16:
     case Builtin::BI__builtin_roundl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::round));
 
     case Builtin::BIsin:
     case Builtin::BIsinf:
     case Builtin::BIsinl:
     case Builtin::BI__builtin_sin:
     case Builtin::BI__builtin_sinf:
+    case Builtin::BI__builtin_sinf16:
     case Builtin::BI__builtin_sinl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sin));
 
     case Builtin::BIsqrt:
     case Builtin::BIsqrtf:
     case Builtin::BIsqrtl:
     case Builtin::BI__builtin_sqrt:
     case Builtin::BI__builtin_sqrtf:
+    case Builtin::BI__builtin_sqrtf16:
     case Builtin::BI__builtin_sqrtl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::sqrt));
 
     case Builtin::BItrunc:
     case Builtin::BItruncf:
     case Builtin::BItruncl:
     case Builtin::BI__builtin_trunc:
     case Builtin::BI__builtin_truncf:
+    case Builtin::BI__builtin_truncf16:
     case Builtin::BI__builtin_truncl:
       return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::trunc));
 
     case Builtin::BIlround:
     case Builtin::BIlroundf:
     case Builtin::BIlroundl:
     case Builtin::BI__builtin_lround:
     case Builtin::BI__builtin_lroundf:
case Builtin::BI__builtin_load_halff: {
     return RValue::get(Builder.CreateFPExt(HalfVal, Builder.getFloatTy()));
   }
   case Builtin::BIprintf:
     if (getTarget().getTriple().isNVPTX())
       return EmitNVPTXDevicePrintfCallExpr(E, ReturnValue);
     break;
   case Builtin::BI__builtin_canonicalize:
   case Builtin::BI__builtin_canonicalizef:
+  case Builtin::BI__builtin_canonicalizef16:
   case Builtin::BI__builtin_canonicalizel:
     return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::canonicalize));
 
   case Builtin::BI__builtin_thread_pointer: {
     if (!getContext().getTargetInfo().isTLSSupported())
       CGM.ErrorUnsupported(E, "__builtin_thread_pointer");
     // Fall through - it's already mapped to the intrinsic by GCCBuiltin.
     break;

test/CodeGenOpenCL/builtins-f16.cl

+// RUN: %clang_cc1 -emit-llvm -o - -triple x86_64-darwin-apple %s | FileCheck %s
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// CHECK-LABEL: define void @test_half_builtins
+void test_half_builtins(half h0, half h1, half h2) {
+  volatile half res;
+
+  // CHECK: call half @llvm.copysign.f16(half %h0, half %h1)
+  res = __builtin_copysignf16(h0, h1);
+
+  // CHECK: call half @llvm.fabs.f16(half %h0)
+  res = __builtin_fabsf16(h0);
+
+  // CHECK: call half @llvm.ceil.f16(half %h0)
+  res = __builtin_ceilf16(h0);
+
+  // CHECK: call half @llvm.cos.f16(half %h0)
+  res = __builtin_cosf16(h0);
+
+  // CHECK: call half @llvm.exp.f16(half %h0)
+  res = __builtin_expf16(h0);
+
+  // CHECK: call half @llvm.exp2.f16(half %h0)
+  res = __builtin_exp2f16(h0);
+
+  // CHECK: call half @llvm.floor.f16(half %h0)
+  res = __builtin_floorf16(h0);
+
+  // CHECK: call half @llvm.fma.f16(half %h0, half %h1, half %h2)
+  res = __builtin_fmaf16(h0, h1 ,h2);
+
+  // CHECK: call half @llvm.maxnum.f16(half %h0, half %h1)
+  res = __builtin_fmaxf16(h0, h1);
+
+  // CHECK: call half @llvm.minnum.f16(half %h0, half %h1)
+  res = __builtin_fminf16(h0, h1);
+
+  // CHECK: frem half %h0, %h1
+  res = __builtin_fmodf16(h0, h1);
+
+  // CHECK: call half @llvm.pow.f16(half %h0, half %h1)
+  res = __builtin_powf16(h0, h1);
+
+  // CHECK: call half @llvm.log10.f16(half %h0)
+  res = __builtin_log10f16(h0);
+
+  // CHECK: call half @llvm.log2.f16(half %h0)
+  res = __builtin_log2f16(h0);
+
+  // CHECK: call half @llvm.log.f16(half %h0)
+  res = __builtin_logf16(h0);
+
+  // CHECK: call half @llvm.rint.f16(half %h0)
+  res = __builtin_rintf16(h0);
+
+  // CHECK: call half @llvm.round.f16(half %h0)
+  res = __builtin_roundf16(h0);
+
+  // CHECK: call half @llvm.sin.f16(half %h0)
+  res = __builtin_sinf16(h0);
+
+  // CHECK: call half @llvm.sqrt.f16(half %h0)
+  res = __builtin_sqrtf16(h0);
+
+  // CHECK: call half @llvm.trunc.f16(half %h0)
+  res = __builtin_truncf16(h0);
+
+  // CHECK: call half @llvm.canonicalize.f16(half %h0)
+  res = __builtin_canonicalizef16(h0);
+}