Add Abstraction Level for Math Optimization Mode

[RoyiAvital]

All compilers have flags to control the precision mode of Math.
Most of them have something like default, strict and fast (Intel Compiler has few fast modes).

It will be great to have abstraction for those in the same manner the optimization level was abstracted.

It has some overlap with the optimization level, yet I think when a user set this it should override optimization level.

[waruqi]

Is like this? https://gcc.gnu.org/wiki/FloatingPointMath

[RoyiAvital]

Yes. GCC is more tricky as it has many flags which are math related.

MSVC, ICC and I think CLang (See -ffp-model) have this with simple high level flag.
I think a good policy will be to imitate CLang with GCC.
Though even first iteration for GCC could be default (No flag) or -ffast-math

[waruqi]

I will consider adding a new api to abstract it, and I will add it later when I have time.

Some references:

https://www.keil.com/support/man/docs/armclang_ref/armclang_ref_rni1489589347476.htm
https://clang.llvm.org/docs/UsersManual.html
https://software.intel.com/content/www/us/en/develop/documentation/cpp-compiler-developer-guide-and-reference/top/compiler-reference/compiler-options/compiler-option-details/floating-point-options/fp-model-fp.html
https://docs.microsoft.com/en-us/cpp/build/reference/fp-specify-floating-point-behavior?view=vs-2019

[waruqi]

I have added a new set_fpmodels() interface, and initially supported some abstract levels. e.g. precise(default), fast, strict, except, noexcept

set_fpmodels("fast")
set_fpmodels("strict")
set_fpmodels("fast", "except")
set_fpmodels("precise") -- default

0e6d98d

[RoyiAvital]

This is great. It seems xmake is truly an abstraction level over most compilers.
When I use CMake or Meson I have to have conditionals on the actual compiler used (Not to mention I can chose the compiler in the code using xmake).

With xmake abstractions there is no need for that because of the flexible mapping you created.
A single code can be fairly optimized for all compilers.
Really great!

[waruqi]

Ok, you can review the gcc/clang flags corresponding to fp-model level. If there are still incorrect mapping flags, I will modify it

gcc:

function nf_fpmodel(self, level)
    local maps =
    {
        precise    = "" --default
    ,   fast       = "-ffast-math"
    ,   strict     = {"-frounding-math", "-ftrapping-math"}
    ,   except     = "-ftrapping-math"
    ,   noexcept   = "-fno-trapping-math"
    }
    return maps[level]
end

Clang

function nf_fpmodel(self, level)
    local maps
    if self:has_flags("-ffp-model=fast") then
        maps =
        {
            precise    = "-ffp-model=precise"
        ,   fast       = "-ffp-model=fast"
        ,   strict     = "-ffp-model=strict"
        ,   except     = "-ftrapping-math"
        ,   noexcept   = "-fno-trapping-math"
        }
    else
        maps =
        {
            precise    = "" -- default
        ,   fast       = "-ffast-math"
        ,   strict     = {"-frounding-math", "-ftrapping-math"}
        ,   except     = "-ftrapping-math"
        ,   noexcept   = "-fno-trapping-math"
        }
    end
    return maps[level]
end

[waruqi]

I have added fp-models for intel compiler