[flang] Create the real constant directly with the argument type.

[c8ef]

See the discussion in #149525.

Currently, we create the float64 type directly, and then another cast is applied, which has two drawbacks.

• It may lead to suboptimal precision for f128.
• It introduces a redundant cast for f32.

[c8ef]

Without modifying libquadmath, I believe we can leverage APFloat to generate the correct precision factor. I propose the following implementation. APFloat appears to support all IEEE formats, along with some rare PowerPC formats. This change would also eliminate the redundant cast in the generated IR for real4.

// ACOSPI
mlir::Value IntrinsicLibrary::genAcospi(mlir::Type resultType,
                                        llvm::ArrayRef<mlir::Value> args) {
  assert(args.size() == 1);
  mlir::MLIRContext *context = builder.getContext();
  mlir::FunctionType ftype =
      mlir::FunctionType::get(context, {resultType}, {args[0].getType()});
  mlir::Value acos = getRuntimeCallGenerator("acos", ftype)(builder, loc, args);
  llvm::APFloat inv_pi =
      llvm::APFloat(llvm::cast<mlir::FloatType>(resultType).getFloatSemantics(),
                    "0.318309886183790671537767526745028724");
  mlir::Value factor = builder.createRealConstant(loc, resultType, inv_pi);
  return mlir::arith::MulFOp::create(builder, loc, acos, factor);
}

  2:  func.func @_QPtest_real4(%arg0: !fir.ref<f32> {fir.bindc_name = "x"}) -> f32 { 
  3:  %0 = fir.alloca f32 {bindc_name = "test_real4", uniq_name = "_QFtest_real4Etest_real4"} 
  4:  %1 = fir.load %arg0 : !fir.ref<f32> 
  5:  %2 = math.acos %1 fastmath<contract> : f32 
  6:  %cst = arith.constant 0.318309873 : f32 
  7:  %3 = arith.mulf %2, %cst fastmath<contract> : f32 
  8:  fir.store %3 to %0 : !fir.ref<f32> 
  9:  %4 = fir.load %0 : !fir.ref<f32> 
 10:  return %4 : f32 
 11:  } 

Please let me know if this approach is acceptable.
@tblah @vzakhari

[c8ef]

If we change the argument to real16, we can also achieve our desired output.

    2:  func.func @_QPtest_real4(%arg0: !fir.ref<f128> {fir.bindc_name = "x"}) -> f128 { 
    3:  %0 = fir.alloca f128 {bindc_name = "test_real4", uniq_name = "_QFtest_real4Etest_real4"} 
    4:  %1 = fir.load %arg0 : !fir.ref<f128> 
    5:  %2 = fir.call @_FortranAAcosF128(%1) fastmath<contract> : (f128) -> f128 
    6:  %cst = arith.constant 0.318309886183790671537767526745028737 : f128 
    7:  %3 = arith.mulf %2, %cst fastmath<contract> : f128 
    8:  fir.store %3 to %0 : !fir.ref<f128> 
    9:  %4 = fir.load %0 : !fir.ref<f128> 
   10:  return %4 : f128 
   11:  } 

[llvmbot]

@llvm/issue-subscribers-flang-ir

Author: Connector Switch (c8ef)

See the discussion in #149525.

Currently, we create the float64 type directly, and then another cast is applied, which has two drawbacks.

• It may lead to suboptimal precision for f128.
• It introduces a redundant cast for f32.

[c8ef]

Glad to know your take on this : ) @clementval

[tblah]

The generated code seems good to me. Thanks for the update.

I wonder if these f128 constants should be added to the llvm constants library instead of living as magic numbers in flang source.

[c8ef]

I wonder if these f128 constants should be added to the llvm constants library instead of living as magic numbers in flang source.

Yeah, I also think it should be added to llvm::numbers. Maybe we can add the string literals for pi and inv_pi. Not sure if it's appropriate.

cc @jayfoad Since you added the hex constant to llvm::numbers. Glad to know your take on this.

[c8ef]

I suggest we can implement as following(borrow some idea from libcxx):

template <class T>
inline constexpr bool __false = false;

template <class T>
struct __illformed {
    static_assert(__false<T>,
                  "A program that instantiates a primary template of a "
                  "mathematical constant variable template is ill-formed.");
};

template <class T>
inline constexpr T pi_v = __illformed<T>{};

template <>
inline constexpr double pi_v<double> = 0x1.921fb54442d18P+1;

template <>
inline constexpr const char* pi_v<const char*> =
    "3.141592653589793238462643383279502884";

constexpr double pi = pi_v<double>;