[clang] Option control afn flag

[masoud.ataei]

Summary

Proposing an clang option to control afn flag.

This change is proposed as a support for: https://reviews.llvm.org/D101759

[masoud.ataei]

Remove extra function deceleration.

[qiucf]

Making a new option mapped to another float op flag looks reasonable, but is there any clearer motivation for this? (such as the need for -Ofast -fno-approx-func)

llvm/include/llvm/Target/TargetOptions.h

190

-enable-no-signed-zeros-fp-math is an llc flag.

Do we really have -enable-approx-func-fp-math for llc now?

[masoud.ataei]

In D106191#2966852, @qiucf wrote:

Making a new option mapped to another float op flag looks reasonable, but is there any clearer motivation for this? (such as the need for -Ofast -fno-approx-func)

This patch https://reviews.llvm.org/D101759 is the real motivation for option controlling afn flag. We want to have a way to distinguishes getting _finite or non-finite version of MASS functions. Only with afn flag (on O3), we want to get non-finite version of MASS functions. (finite version need extra fast-math flags.)

llvm/include/llvm/Target/TargetOptions.h

190

I am adding and using this option in https://reviews.llvm.org/D101759 patch.

[lebedev.ri]

FWIW i think this part is fine in principle.
Not sure about errno.

[bmahjour]

clang/include/clang/Driver/Options.td

1767–1768

So this option already exists and seems to behave the way we want it to. Does anyone know why it was made NoDriverOption?

> cat fp.c
#include <math.h>
void foo(float *f1, float *f2)
{
  *f1 = sin(*f2) + *f1;
}
> clang -c fp.c -S -emit-llvm -mllvm -disable-llvm-optzns -O3 -Xclang -fapprox-func && grep afn fp.ll
  %call = call afn double @sin(double %conv) #2
  %add = fadd afn double %call, %conv1

Could we just expose it as a supported option and call it done. ie make it more like fhonor_nans below but without introducing a new function attribute:

def fapprox_func : Flag<["-"], "fapprox-func">, Group<f_Group>;

so that instead of having -Xclang -fapprox-func in the command above we could just have -fapprox-func ?

clang/test/CodeGen/afn-flag-test.c

11

can we avoid these attributes?

14

avoid attributes.

[masoud.ataei]

Sorry that it took me so long to reply reviews. Thank you for reviewing this patch.

clang/include/clang/Driver/Options.td

1767–1768

With the change that I proposed for approx_func option, we don't need to pass it with -Xclang. So, in your example, we can simply remove -Xclang and it will work the same:

> clang -c fp.c -S -emit-llvm -mllvm -disable-llvm-optzns -O3 -fapprox-func && grep afn fp.ll
  %call = call afn double @sin(double %conv) #2
  %add = fadd afn double %call, %conv1

(even no need for -mllvm -disable-llvm-optzns -O3)

Example for -fapprox-func and -fno-approx-func:

$ clang -c fp.c -S -emit-llvm -fapprox-func && grep afn fp.ll
  %call = call afn double @sin(double %conv) #2
  %add = fadd afn double %call, %conv1
$ clang -c fp.c -S -emit-llvm -fno-approx-func && grep afn fp.ll
$

clang/lib/CodeGen/CGCall.cpp

1832

Regarding the attributes discussion below, here is place that attributes are added.

clang/test/CodeGen/afn-flag-test.c

11

I understand that attributes are less desirable now in LLVM. But all other options for fast-math flags (-fhonor-nans, -fhonor_infinities, ...) add the attributes too. So, to be consistent with others I added this attribute too.

Example: This will add "no-nans-fp-math"="true" attribute along with nnan flag.

$ clang -c fp.c -S -emit-llvm -fno-honor-nans

14

Same as above.

[nemanjai]

Added @jansvoboda11 to the review as it appears he was the one that added the original option.

[masoud.ataei]

Reminder for reviewers.

[lebedev.ri]

Looks reasonable to me.
@aaron.ballman @erichkeane does it seem complete or are we missing some infra piece?

clang/include/clang/Driver/Options.td

1768

Missing description

[erichkeane]

In D106191#3046757, @lebedev.ri wrote:

Looks reasonable to me.
@aaron.ballman @erichkeane does it seem complete or are we missing some infra piece?

At least from the CFE's side I think this is complete as far as I can see. I agree we need to have the description. I would also like to see a Driver test on this as well.

[aaron.ballman]

Agreed on the request for description and driver test coverage. I'm also wondering if there should be a release note and documentation because it's lifting a private flag to be a public one. e.g., should we update https://clang.llvm.org/docs/UsersManual.html#controlling-floating-point-behavior ?

[masoud.ataei]

Description and driver test are added.

[masoud.ataei]

Update the documentation.

[erichkeane]

clang/docs/UsersManual.rst

1393

This seems pretty incomplete to me, I have no idea what it does from this description. Can you elaborate?

[masoud.ataei]

clang/docs/UsersManual.rst

1393

If I didn't miss to say it is about math function calls, then I guess it would be more clear.

Allow substitution of approximate calculations for math function calls.

This option just adds afn fast-math flag to the function calls and in backend the math function call can be replaced by an approximate calculation (either another math function call or not).
https://llvm.org/docs/LangRef.html#fast-math-flags

[erichkeane]

clang/docs/UsersManual.rst

1393

allow substitution of approximate calculations for math function with what? I'm not clear as to what this does still. I'm not sure that I get what the 'afn' documentation means there either. Typically we'd want the clang frontend flags to be more accurate/descriptive than the LLVM-IR documentation.

[masoud.ataei]

clang/docs/UsersManual.rst

1393

This option adds afn fast-math flag to function calls in IR. And in the case of math function calls (like log, sqrt, pow, ...), afn flag allows LLVM to substitute the math calls with an "approximate calculation". What an approximate calculation is may differ based on which math call it is, what other fast-math flags are set, what is the target machine, and other factors.

An approximate calculation can be

1. sequence of instructions (inlining): for example, inlining sqrt call needs afn flag to be present in the call.
2. a substituted math function call (which may be less accurate but faster): this substitution can be (a) for general targets: for example: pow(x,0.25) to sqrt(sqrt(x)). or (b) for a specific target: for example, in the case of PowerPC, we are proposing to substitute math calls to MASS library calls https://reviews.llvm.org/D101759

Note that, afn flag is necessary for these approximate calculation but may not be sufficient. Most of them need at lease one or two other fast-math flags to be set too.

I agree the term "approximate calculation" is a very general term. But I guess it is needed to describe this general situation.

[erichkeane]

clang/docs/UsersManual.rst

1393

Perhaps then something like:
Allow certain math function calls (such as log, sqrt, pow, etc) to be replaced with an approximately equivalent set of instructions or alternative math function calls. For example, a pow(x, 0.25) may be replaced with sqrt(sqrt(x), despite being an inexact result in cases where <expand a little>.

For Options.td we can be a little more terse, so perhaps something a little more like:

Allow certain math function calls to be replaced with an approximately equivalent calculation.

@aaron.ballman WDYT?

[aaron.ballman]

clang/docs/UsersManual.rst

1393

I think the docs suggestion makes sense (though please be sure to add backticks to all the syntax components, correct the missing paren on sqrt(sqrt(x)), and finish the <expand a little> bit.

I think the suggested wording for Options.td looks good. Thanks!

[masoud.ataei]

Update the documentation.

[erichkeane]

1 small 'english' question, hopefully Aaron can answer, otherwise LGTM.

clang/docs/UsersManual.rst

1395

Should this be 'alternate math function calls'? I'm second guessing myself now.

[aaron.ballman]

LGTM

clang/docs/UsersManual.rst

1395

alternative is correct. alternate as an adjective means "every other, every second".

clang/docs/UsersManual.rst

 
 .. _opt_fhonor-nans:
 
 **-f[no-]honor-nans**
 
    If both ``-fno-honor-infinities`` and ``-fno-honor-nans`` are used,
    has the same effect as specifying ``-ffinite-math-only``.
 
+.. _opt_fapprox-func:
+
+**-f[no-]approx-func**
+
+   Allow certain math function calls (such as ``log``, ``sqrt``, ``pow``, etc)
+   to be replaced with an approximately equivalent set of instructions
+   or alternative math function calls. For example, a ``pow(x, 0.25)``
+   may be replaced with ``sqrt(sqrt(x))``, despite being an inexact result
+   in cases where ``x`` is ``-0.0`` or ``-inf``.
+   Defaults to ``-fno-approx-func``.
+
 .. _opt_fsigned-zeros:
 
 **-f[no-]signed-zeros**
 
    Allow optimizations that ignore the sign of floating point zeros.
    Defaults to ``-fno-signed-zeros``.
 
 .. _opt_fassociative-math:

clang/include/clang/Driver/Options.td

def fno_unsafe_math_optimizations : Flag<["-"], "fno-unsafe-math-optimizations">,
   Group<f_Group>;
 def fassociative_math : Flag<["-"], "fassociative-math">, Group<f_Group>;
 def fno_associative_math : Flag<["-"], "fno-associative-math">, Group<f_Group>;
 defm reciprocal_math : BoolFOption<"reciprocal-math",
   LangOpts<"AllowRecip">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Allow division operations to be reassociated",
           [menable_unsafe_fp_math.KeyPath]>,
   NegFlag<SetFalse>>;
-def fapprox_func : Flag<["-"], "fapprox-func">, Group<f_Group>, Flags<[CC1Option, NoDriverOption]>,
-  MarshallingInfoFlag<LangOpts<"ApproxFunc">>, ImpliedByAnyOf<[menable_unsafe_fp_math.KeyPath]>;
+defm approx_func : BoolFOption<"approx-func", LangOpts<"ApproxFunc">, DefaultFalse,
+   PosFlag<SetTrue, [CC1Option], "Allow certain math function calls to be replaced "
+           "with an approximately equivalent calculation",
+           [menable_unsafe_fp_math.KeyPath]>,
+   NegFlag<SetFalse>>;
 defm finite_math_only : BoolFOption<"finite-math-only",
   LangOpts<"FiniteMathOnly">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "", [cl_finite_math_only.KeyPath, ffast_math.KeyPath]>,
   NegFlag<SetFalse>>;
 defm signed_zeros : BoolFOption<"signed-zeros",
   LangOpts<"NoSignedZero">, DefaultFalse,
   NegFlag<SetTrue, [CC1Option], "Allow optimizations that ignore the sign of floating point zeros",
             [cl_no_signed_zeros.KeyPath, menable_unsafe_fp_math.KeyPath]>,

clang/lib/CodeGen/BackendUtil.cpp

if (LangOpts.hasDWARFExceptions())
     Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;
   if (LangOpts.hasWasmExceptions())
     Options.ExceptionModel = llvm::ExceptionHandling::Wasm;
 
   Options.NoInfsFPMath = LangOpts.NoHonorInfs;
   Options.NoNaNsFPMath = LangOpts.NoHonorNaNs;
   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
   Options.UnsafeFPMath = LangOpts.UnsafeFPMath;
+  Options.ApproxFuncFPMath = LangOpts.ApproxFunc;
 
   Options.BBSections =
       llvm::StringSwitch<llvm::BasicBlockSection>(CodeGenOpts.BBSections)
           .Case("all", llvm::BasicBlockSection::All)
           .Case("labels", llvm::BasicBlockSection::Labels)
           .StartsWith("list=", llvm::BasicBlockSection::List)
           .Case("none", llvm::BasicBlockSection::None)
           .Default(llvm::BasicBlockSection::None);

clang/lib/CodeGen/CGCall.cpp

if (!CodeGenOpts.StrictFloatCastOverflow)
       FuncAttrs.addAttribute("strict-float-cast-overflow", "false");
 
     // TODO: Are these all needed?
     // unsafe/inf/nan/nsz are handled by instruction-level FastMathFlags.
     if (LangOpts.NoHonorInfs)
       FuncAttrs.addAttribute("no-infs-fp-math", "true");
     if (LangOpts.NoHonorNaNs)
       FuncAttrs.addAttribute("no-nans-fp-math", "true");
+    if (LangOpts.ApproxFunc)
+      FuncAttrs.addAttribute("approx-func-fp-math", "true");
     if (LangOpts.UnsafeFPMath)
       FuncAttrs.addAttribute("unsafe-fp-math", "true");
     if (CodeGenOpts.SoftFloat)
       FuncAttrs.addAttribute("use-soft-float", "true");
     FuncAttrs.addAttribute("stack-protector-buffer-size",
                            llvm::utostr(CodeGenOpts.SSPBufferSize));
     if (LangOpts.NoSignedZero)
       FuncAttrs.addAttribute("no-signed-zeros-fp-math", "true");

clang/lib/Driver/ToolChains/Clang.cpp

static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
                                        const JobAction &JA) {
   // Handle various floating point optimization flags, mapping them to the
   // appropriate LLVM code generation flags. This is complicated by several
   // "umbrella" flags, so we do this by stepping through the flags incrementally
   // adjusting what we think is enabled/disabled, then at the end setting the
   // LLVM flags based on the final state.
   bool HonorINFs = true;
   bool HonorNaNs = true;
+  bool ApproxFunc = false;
   // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes.
   bool MathErrno = TC.IsMathErrnoDefault();
   bool AssociativeMath = false;
   bool ReciprocalMath = false;
   bool SignedZeros = true;
   bool TrappingMath = false; // Implemented via -ffp-exception-behavior
   bool TrappingMathPresent = false; // Is trapping-math in args, and not
                                     // overriden by ffp-exception-behavior?
case options::OPT_ffp_model_EQ: {
       }
     }
 
     switch (optID) {
     // If this isn't an FP option skip the claim below
     default: continue;
 
     // Options controlling individual features
     case options::OPT_fhonor_infinities:    HonorINFs = true;         break;
     case options::OPT_fno_honor_infinities: HonorINFs = false;        break;
     case options::OPT_fhonor_nans:          HonorNaNs = true;         break;
     case options::OPT_fno_honor_nans:       HonorNaNs = false;        break;
+    case options::OPT_fapprox_func:         ApproxFunc = true;        break;
+    case options::OPT_fno_approx_func:      ApproxFunc = false;       break;
     case options::OPT_fmath_errno:          MathErrno = true;         break;
     case options::OPT_fno_math_errno:       MathErrno = false;        break;
     case options::OPT_fassociative_math:    AssociativeMath = true;   break;
     case options::OPT_fno_associative_math: AssociativeMath = false;  break;
     case options::OPT_freciprocal_math:     ReciprocalMath = true;    break;
     case options::OPT_fno_reciprocal_math:  ReciprocalMath = false;   break;
     case options::OPT_fsigned_zeros:        SignedZeros = true;       break;
     case options::OPT_fno_signed_zeros:     SignedZeros = false;      break;
static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D,
   }
 
   if (!HonorINFs)
     CmdArgs.push_back("-menable-no-infs");
 
   if (!HonorNaNs)
     CmdArgs.push_back("-menable-no-nans");
 
+  if (ApproxFunc)
+    CmdArgs.push_back("-fapprox-func");
+
   if (MathErrno)
     CmdArgs.push_back("-fmath-errno");
 
   if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros &&
       !TrappingMath)
     CmdArgs.push_back("-menable-unsafe-fp-math");
 
   if (!SignedZeros)

clang/test/CodeGen/afn-flag-test.c

+// RUN: %clang_cc1 -fapprox-func  %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-AFN %s
+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck --check-prefix=CHECK-NO-AFN %s
+
+extern double exp(double);
+double afn_option_test(double x) {
+  return exp(x);
+  // CHECK-LABEL:  define{{.*}} double @afn_option_test(double %x) #0 {
+
+  // CHECK-AFN:      %{{.*}} = call afn double @{{.*}}exp{{.*}}(double %{{.*}})
+  // CHECK-AFN:      attributes #0 ={{.*}} "approx-func-fp-math"="true" {{.*}}
+
+  // CHECK-NO-AFN:   %{{.*}} = call double @{{.*}}exp{{.*}}(double %{{.*}})
+  // CHECK-NO-AFN-NOT:  attributes #0 ={{.*}} "approx-func-fp-math"="true" {{.*}}
+}

clang/test/Driver/fast-math.c

 // CHECK-NO-FAST-MATH-NO-NANS: "-cc1"
 // CHECK-NO-FAST-MATH-NO-NANS: "-menable-no-nans"
 //
 // RUN: %clang -### -fno-honor-nans -fno-fast-math -c %s 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-NO-NANS-NO-FAST-MATH %s
 // CHECK-NO-NANS-NO-FAST-MATH: "-cc1"
 // CHECK-NO-NANS-NO-FAST-MATH-NOT: "-menable-no-nans"
 //
+// RUN: %clang -### -fapprox-func -c %s 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-APPROX-FUNC %s
+// CHECK-APPROX-FUNC: "-cc1"
+// CHECK-APPROX-FUNC: "-fapprox-func"
+//
 // RUN: %clang -### -fmath-errno -c %s 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-MATH-ERRNO %s
 // CHECK-MATH-ERRNO: "-cc1"
 // CHECK-MATH-ERRNO: "-fmath-errno"
 //
 // RUN: %clang -### -fmath-errno -fno-math-errno -c %s 2>&1 \
 // RUN:   | FileCheck --check-prefix=CHECK-NO-MATH-ERRNO %s
 // CHECK-NO-MATH-ERRNO: "-cc1"

llvm/include/llvm/Target/TargetOptions.h

enum class SwiftAsyncFramePointerMode {
     Never,
   };
 
   class TargetOptions {
   public:
     TargetOptions()
         : UnsafeFPMath(false), NoInfsFPMath(false), NoNaNsFPMath(false),
           NoTrappingFPMath(true), NoSignedZerosFPMath(false),
-          EnableAIXExtendedAltivecABI(false),
+          ApproxFuncFPMath(false), EnableAIXExtendedAltivecABI(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
           EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false),
           DisableIntegratedAS(false), RelaxELFRelocations(false),
           FunctionSections(false), DataSections(false),
           IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true),
           UniqueSectionNames(true), UniqueBasicBlockSectionNames(false),
           TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
           EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           EnableMachineFunctionSplitter(false), SupportsDefaultOutlining(false),
           EmitAddrsig(false), EmitCallSiteInfo(false),
           SupportsDebugEntryValues(false), EnableDebugEntryValues(false),
           ValueTrackingVariableLocations(false),
           ForceDwarfFrameSection(false), XRayOmitFunctionIndex(false),
           DebugStrictDwarf(false),
           FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
     bool DisableFramePointerElim(const MachineFunction &MF) const;
 
public:
     unsigned NoTrappingFPMath : 1;
 
     /// NoSignedZerosFPMath - This flag is enabled when the
     /// -enable-no-signed-zeros-fp-math is specified on the command line. This
     /// specifies that optimizations are allowed to treat the sign of a zero
     /// argument or result as insignificant.
     unsigned NoSignedZerosFPMath : 1;
 
+    /// ApproxFuncFPMath - This flag is enabled when the
+    /// -enable-approx-func-fp-math is specified on the command line. This
+    /// specifies that optimizations are allowed to substitute math functions
+    /// with approximate calculations
+    unsigned ApproxFuncFPMath : 1;
+
     /// EnableAIXExtendedAltivecABI - This flag returns true when -vec-extabi is
     /// specified. The code generator is then able to use both volatile and
     /// nonvolitle vector registers. When false, the code generator only uses
     /// volatile vector registers which is the default setting on AIX.
     unsigned EnableAIXExtendedAltivecABI : 1;
 
     /// HonorSignDependentRoundingFPMath - This returns true when the
     /// -enable-sign-dependent-rounding-fp-math is specified.  If this returns