Hi,

I'm wondering why lib/AsmParser/LLParser handles fast-math flags in the

following IR:

...

%val = fmul nnan double 1.0, 1.0

...

but doesn't allow any flags if "fmul" is inside "phi":

...

%val = phi double [ fmul (double 1.0, double 1.0), %cond.true ],

[ fmul (double 1.0, double 1.0), %cond.false ]

...

LLParser::ParseValID(...) could call EatFastMathFlagsIfPresent() to

handle fast-math flags, but it doesn't. Is this intended or a bug?

Regards,

Sergey

Doesn't look like a bug, more like a limitation of constant expressions

as llvm::BinaryConstantExpr doesn't have FastMastFlags.

Out of curiosity, how would you envision fast-math flags interacting with constant expressions? Off the top of my head, I can’t think of any flags that would be relevant if the expression can just be constant-folded away at full precision anyways.

Out of curiosity, how would you envision fast-math flags

interacting with constant expressions?

They could prevent constant-folding when it leads to loosing

floating-point exceptions at runtime.

Off the top of my head, I can’t think of any flags that would be

relevant if the expression can just be constant-folded away at

full precision anyways.

I'm adding them. It worked fine with function attributes, but replacing

attributes with instruction flags revealed this inconvenience. At the

end it doesn't seem to be an issue as front-end can just emit normal

instructions rather than constant expression when FPEnv access is

enabled.

That's the opposite of what fast math flags do.

If you want to solve that problem, I believe you want to prevent the folding of floating point instructions into constant expressions. The direction you're going seems like a pretty major violation of the intended functionality of constant expressions.

-Owen

That's the opposite of what fast math flags do.

Well, still quite close. Function arguments turned out to be a bad

choice, so Hal suggested using fast-math flags instead. I guess there

isn't many other options.

If you want to solve that problem, I believe you want to prevent the

folding of floating point instructions into constant expressions.

Yes, that's what I did at the end. Probably wasn't clear enough in my

previous email.

The direction you're going seems like a pretty major violation of the

intended functionality of constant expressions.

If you're talking about adding fast-math flags to constant expressions,

then I'm not going to try that. It just that Language Reference doesn't

note this difference for binary operations inside/outside constant

expressions (maybe I didn't find it, but I was looking there).