This is an archive of the discontinued LLVM Phabricator instance.

docs/LangRef.rst
2346	This is precisely the definition of undef: an arbitrary value that may yield a different value each time it's used. But the intention was to avoid undef and poison. I'm not familiar enough with floats to make any concrete suggestion; I'm just type checking.

Clarify that the value produced isn't undef. (It's more like freeze(undef).)

This reads clearer to me by avoiding the potential to confuse with UB. Should the same blurb apply to nsz with -0.0?

I don't think this is right. Saying the result is undefined seems like what we intend. We might choose, as an implementation technique, to limit how we take advantage of that undefinedness in certain cases, but the violating the constraint still produces logical inconsistencies that can transfer to other parts of the code, and in general, turn into any other kind of undefined behavior (depending on the structure of the code).

It has to be one of undefined behavior, poison, undef, or an unspecified value as described here; there is no other way for something to be "undefined" in LLVM IR, unless you're proposing to introduce a new form of undefined-ness specifically for nnan/ninf.

I think we should have these produce poison -- if we have them produce undef we'll have the same kinds of problems as we have with regular undef.

nnan and ninf affect fcmp

Only if the fcmp is marked with nnan or ninf right?

a.elovikov added a subscriber: a.elovikov.Jun 18 2018, 12:19 AM

Only if the fcmp is marked with nnan or ninf right?

Yes, but it's inconvenient in C because fast-math flags work on a per-file basis.

If the consensus is that we need to produce poison for nnan/ninf instead of an unspecified value, I can change that. I guess it allows more aggressive fcmp transforms in some cases?

Okay, switched to poison.

spatel mentioned this in rL336562: [InstCombine] avoid extra poison when moving shift above shuffle.Jul 9 2018, 10:25 AM

Ping

LGTM

This revision is now accepted and ready to land.Jul 13 2018, 7:57 PM

Closed by commit rL337323: [LangRef] nnan and ninf produce poison. (authored by efriedma). · Explain WhyJul 17 2018, 1:36 PM

This revision was automatically updated to reflect the committed changes.

Revision Contents

Path

Size

docs/

LangRef.rst

8 lines

Diff 154461

docs/LangRef.rst

This file is larger than 256 KB, so syntax highlighting is disabled by default.

	Show First 20 Lines • Show All 2,336 Lines • ▼ Show 20 Lines
	LLVM IR floating-point operations (:ref:`fadd <i_fadd>`,			LLVM IR floating-point operations (:ref:`fadd <i_fadd>`,
	:ref:`fsub <i_fsub>`, :ref:`fmul <i_fmul>`, :ref:`fdiv <i_fdiv>`,			:ref:`fsub <i_fsub>`, :ref:`fmul <i_fmul>`, :ref:`fdiv <i_fdiv>`,
	:ref:`frem <i_frem>`, :ref:`fcmp <i_fcmp>`) and :ref:`call <i_call>`			:ref:`frem <i_frem>`, :ref:`fcmp <i_fcmp>`) and :ref:`call <i_call>`
	may use the following flags to enable otherwise unsafe			may use the following flags to enable otherwise unsafe
	floating-point transformations.			floating-point transformations.

	``nnan``			``nnan``
	No NaNs - Allow optimizations to assume the arguments and result are not			No NaNs - Allow optimizations to assume the arguments and result are not
	NaN. Such optimizations are required to retain defined behavior over			NaN. If an argument is a nan, or the result would be a nan, it produces
	NaNs, but the value of the result is undefined.			a :ref:`poison value <poisonvalues>` instead.
				nlopesUnsubmitted Not Done Reply Inline Actions This is precisely the definition of undef: an arbitrary value that may yield a different value each time it's used. But the intention was to avoid undef and poison. I'm not familiar enough with floats to make any concrete suggestion; I'm just type checking. nlopes: This is precisely the definition of undef: an arbitrary value that may yield a different value…

	``ninf``			``ninf``
	No Infs - Allow optimizations to assume the arguments and result are not			No Infs - Allow optimizations to assume the arguments and result are not
	+/-Inf. Such optimizations are required to retain defined behavior over			+/-Inf. If an argument is +/-Inf, or the result would be +/-Inf, it
	+/-Inf, but the value of the result is undefined.			produces a :ref:`poison value <poisonvalues>` instead.

	``nsz``			``nsz``
	No Signed Zeros - Allow optimizations to treat the sign of a zero			No Signed Zeros - Allow optimizations to treat the sign of a zero
	argument or result as insignificant.			argument or result as insignificant.

	``arcp``			``arcp``
	Allow Reciprocal - Allow optimizations to use the reciprocal of an			Allow Reciprocal - Allow optimizations to use the reciprocal of an
	argument rather than perform division.			argument rather than perform division.
	▲ Show 20 Lines • Show All 12,703 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[LangRef] nnan and ninf produce poison.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 154461

docs/LangRef.rst

[LangRef] nnan and ninf produce poison.
ClosedPublic