Add FP tests

Author: mmha

clang/include/clang/CIR/MissingFeatures.h

@@ -83,7 +83,6 @@ struct MissingFeatures {
   static bool opFuncSetComdat() { return false; }
 
   // CallOp handling
-  static bool opCallBuiltinFunc() { return false; }
   static bool opCallPseudoDtor() { return false; }
   static bool opCallAggregateArgs() { return false; }
   static bool opCallPaddingArgs() { return false; }

clang/lib/CIR/CodeGen/CIRGenBuilder.cpp

@@ -50,9 +50,7 @@ cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc,
 
 cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc,
                                              llvm::APInt intVal) {
-  unsigned width = intVal.getBitWidth();
-  cir::IntType t = getUIntNTy(width);
-  return getConstInt(loc, t, intVal.getZExtValue());
+  return getConstInt(loc, llvm::APSInt(intVal));
 }
 
 cir::ConstantOp CIRGenBuilderTy::getConstInt(mlir::Location loc, mlir::Type t,

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -11,6 +11,7 @@
 
 #include "Address.h"
 #include "CIRGenTypeCache.h"
+#include "clang/CIR/Interfaces/CIRFPTypeInterface.h"
 #include "clang/CIR/MissingFeatures.h"
 
 #include "clang/CIR/Dialect/Builder/CIRBaseBuilder.h"
@@ -236,28 +237,11 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
 
   cir::ConstantOp getConstInt(mlir::Location loc, mlir::Type t, uint64_t c);
 
-  mlir::Type getFPType(llvm::fltSemantics const &sem) {
-    switch (llvm::APFloat::SemanticsToEnum(sem)) {
-    case llvm::APFloat::S_IEEEhalf:
-      return cir::FP16Type::get(getContext(), typeCache.FP16Ty);
-    case llvm::APFloat::S_BFloat:
-      return cir::BF16Type::get(getContext(), typeCache.BFloat16Ty);
-    case llvm::APFloat::S_IEEEsingle:
-      return cir::SingleType::get(getContext(), typeCache.FloatTy);
-    case llvm::APFloat::S_IEEEdouble:
-      return cir::DoubleType::get(getContext(), typeCache.DoubleTy);
-    case llvm::APFloat::S_IEEEquad:
-      return cir::FP128Type::get(getContext(), typeCache.FP128Ty);
-    case llvm::APFloat::S_x87DoubleExtended:
-      return cir::FP80Type::get(getContext(), typeCache.FP80Ty);
-    default:
-      llvm_unreachable("Unrecognized floating semantics");
-    }
-  }
-
-  cir::ConstantOp getConstFP(mlir::Location loc, llvm::APFloat fpVal) {
-    mlir::Type type = getFPType(fpVal.getSemantics());
-    return create<cir::ConstantOp>(loc, getAttr<cir::FPAttr>(type, fpVal));
+  cir::ConstantOp getConstFP(mlir::Location loc, mlir::Type t,
+                             llvm::APFloat fpVal) {
+    assert(mlir::isa<cir::CIRFPTypeInterface>(t) &&
+           "expected floating point type");
+    return create<cir::ConstantOp>(loc, getAttr<cir::FPAttr>(t, fpVal));
   }
 
   bool isInt8Ty(mlir::Type i) {

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -43,8 +43,8 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl &gd, unsigned builtinID,
       // type. We feel it should be Ok to use expression type because it is
       // hard to imagine a builtin function evaluates to a value that
       // over/underflows its own defined type.
-      mlir::Type resTy = convertType(e->getType());
-      return RValue::get(builder.getConstFP(getLoc(e->getExprLoc()), resTy,
+      mlir::Type type = convertType(e->getType());
+      return RValue::get(builder.getConstFP(getLoc(e->getExprLoc()), type,
                                             result.Val.getFloat()));
     }
   }

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -1043,7 +1043,7 @@ CIRGenCallee CIRGenFunction::emitDirectCallee(const GlobalDecl &gd) {
   const auto *fd = cast<FunctionDecl>(gd.getDecl());
 
   if (unsigned builtinID = fd->getBuiltinID()) {
-    if(fd->getAttr<AsmLabelAttr>()) {
+    if (fd->getAttr<AsmLabelAttr>()) {
       cgm.errorNYI("AsmLabelAttr");
     }
 

clang/test/CIR/CodeGen/builtin_call.cpp

@@ -11,6 +11,18 @@ constexpr extern int cx_var = __builtin_is_constant_evaluated();
 // LLVM: @cx_var = {{.*}} i32 1
 // OGCG: @cx_var = {{.*}} i32 1
 
+constexpr extern float cx_var_single = __builtin_huge_valf();
+
+// CIR: cir.global {{.*}} @cx_var_single = #cir.fp<0x7F800000> : !cir.float
+// LLVM: @cx_var_single = {{.*}} float 0x7FF0000000000000
+// OGCG: @cx_var_single = {{.*}} float 0x7FF0000000000000
+
+constexpr extern long double cx_var_ld = __builtin_huge_vall();
+
+// CIR: cir.global {{.*}} @cx_var_ld = #cir.fp<0x7FFF8000000000000000> : !cir.long_double<!cir.f80>
+// LLVM: @cx_var_ld = {{.*}} x86_fp80 0xK7FFF8000000000000000
+// OGCG: @cx_var_ld = {{.*}} x86_fp80 0xK7FFF8000000000000000
+
 int is_constant_evaluated() {
     return __builtin_is_constant_evaluated();
 }
@@ -28,3 +40,39 @@ int is_constant_evaluated() {
 // OGCG: define {{.*}}i32 @_Z21is_constant_evaluatedv()
 // OGCG: ret i32 0
 // OGCG: }
+
+long double constant_fp_builtin_ld() {
+  return __builtin_fabsl(-0.1L);
+}
+
+// CIR: cir.func @_Z22constant_fp_builtin_ldv() -> !cir.long_double<!cir.f80>
+// CIR: %[[PONE:.+]] = cir.const #cir.fp<1.000000e-01> : !cir.long_double<!cir.f80>
+
+// LLVM: define {{.*}}x86_fp80 @_Z22constant_fp_builtin_ldv()
+// LLVM: %[[MEM:.+]] = alloca x86_fp80
+// LLVM: store x86_fp80 0xK3FFBCCCCCCCCCCCCCCCD, ptr %[[MEM]]
+// LLVM: %[[RETVAL:.+]] = load x86_fp80, ptr %[[MEM]]
+// LLVM: ret x86_fp80 %[[RETVAL]]
+// LLVM: }
+
+// OGCG: define {{.*}}x86_fp80 @_Z22constant_fp_builtin_ldv()
+// OGCG: ret x86_fp80 0xK3FFBCCCCCCCCCCCCCCCD
+// OGCG: }
+
+float constant_fp_builtin_single() {
+  return __builtin_fabsf(-0.1f);
+}
+
+// CIR: cir.func @_Z26constant_fp_builtin_singlev() -> !cir.float
+// CIR: %[[PONE:.+]] = cir.const #cir.fp<1.000000e-01> : !cir.float
+
+// LLVM: define {{.*}}float @_Z26constant_fp_builtin_singlev()
+// LLVM: %[[MEM:.+]] = alloca float
+// LLVM: store float 0x3FB99999A0000000, ptr %[[MEM]]
+// LLVM: %[[RETVAL:.+]] = load float, ptr %[[MEM]]
+// LLVM: ret float %[[RETVAL]]
+// LLVM: }
+
+// OGCG: define {{.*}}float @_Z26constant_fp_builtin_singlev()
+// OGCG: ret float 0x3FB99999A0000000
+// OGCG: }