Add __builtin_canonicalize

[rsmith]

Sure, it makes sense to expose this.

docs/LanguageExtensions.rst

1743

The cross-reference to the LLVM documentation here is useful, but please lead with a (brief) description of what this builtin does (the first sentence from the LLVM doc would be fine).

include/clang/Basic/Builtins.def

381–382

Why is there no long double version of this builtin?

[arsenm]

Add long double version. Add the short summary before linking to the intrinsic doc

[arsenm]

r262122

docs/LanguageExtensions.rst

 
 The first three builtins work generically for operands of any integer type,
 including boolean types.  The operands need not have the same type as each
 other, or as the result.  The other builtins may implicitly promote or
 convert their operands before performing the operation.
 
 Query for this feature with ``__has_builtin(__builtin_add_overflow)``, etc.
 
+Floating point builtins
+---------------------------------------
+
+``__builtin_canonicalize``
+--------------------------
+
+.. code-block:: c
+
+   double __builtin_canonicalize(double);
+   float __builtin_canonicalizef(float);
+
+
+This provides the semantics of the `LLVM canonicalize intrinsic <http://llvm.org/docs/LangRef.html#llvm-canonicalize-intrinsic>`_.
+
+
 .. _langext-__c11_atomic:
 
 __c11_atomic builtins
 ---------------------
 
 Clang provides a set of builtins which are intended to be used to implement
 C11's ``<stdatomic.h>`` header.  These builtins provide the semantics of the
 ``_explicit`` form of the corresponding C11 operation, and are named with a

include/clang/Basic/Builtins.def

 BUILTIN(__builtin_isnan,      "i.", "Fnc")
 BUILTIN(__builtin_isnormal,   "i.", "Fnc")
 
 // 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")
+
 // 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)
 BUILTIN(__builtin_ctzs , "iUs"  , "nc")
 BUILTIN(__builtin_ctz  , "iUi"  , "nc")

lib/CodeGen/CGBuiltin.cpp

case Builtin::BIget_pipe_max_packets: {
 
     return RValue::get(
         Builder.CreateCall(CGM.CreateRuntimeFunction(FTy, Name), {Arg0}));
   }
 
   case Builtin::BIprintf:
     if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
       return EmitCUDADevicePrintfCallExpr(E, ReturnValue);
+
+  case Builtin::BI__builtin_canonicalize:
+  case Builtin::BI__builtin_canonicalizef:
+    return RValue::get(emitUnaryBuiltin(*this, E, Intrinsic::canonicalize));
   }
 
   // If this is an alias for a lib function (e.g. __builtin_sin), emit
   // the call using the normal call path, but using the unmangled
   // version of the function name.
   if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
     return emitLibraryCall(*this, FD, E,
                            CGM.getBuiltinLibFunction(FD, BuiltinID));

test/CodeGen/builtins.c

void test_float_builtin_ops(float F, double D, long double LD) {
   // CHECK: frem x86_fp80
 
   resf = __builtin_fabsf(F);
   resd = __builtin_fabs(D);
   resld = __builtin_fabsl(LD);
   // CHECK: call float @llvm.fabs.f32(float
   // CHECK: call double @llvm.fabs.f64(double
   // CHECK: call x86_fp80 @llvm.fabs.f80(x86_fp80
+
+  resf = __builtin_canonicalizef(F);
+  resd = __builtin_canonicalize(D);
+  // CHECK: call float @llvm.canonicalize.f32(float
+  // CHECK: call double @llvm.canonicalize.f64(double
 }
 
 // __builtin_longjmp isn't supported on all platforms, so only test it on X86.
 #ifdef __x86_64__
 // CHECK-LABEL: define void @test_builtin_longjmp
 void test_builtin_longjmp(void **buffer) {
   // CHECK: [[BITCAST:%.*]] = bitcast
   // CHECK-NEXT: call void @llvm.eh.sjlj.longjmp(i8* [[BITCAST]])