[DAG] Replace/Wrap SelectionDAG::isKnownNeverNaN with SelectionDAG::computeKnownFPClass

SelectionDAG is missing an equivalent to ValueTrackings's computeKnownFPClass, instead only having a basic implementation for isKnownNeverNaN.

We should create a full SelectionDAG::computeKnownFPClass implementation and then wrap inf/nan/signbit checks around it like ValueTracking does:

llvm-project/llvm/lib/Analysis/ValueTracking.cpp

Lines 6306 to 6348 in 04aa5a8

    
           bool llvm::cannotBeNegativeZero(const Value *V, unsigned Depth, 
        
                                           const SimplifyQuery &SQ) { 
        
             KnownFPClass Known = computeKnownFPClass(V, fcNegZero, Depth, SQ); 
        
             return Known.isKnownNeverNegZero(); 
        
           } 
        
           bool llvm::cannotBeOrderedLessThanZero(const Value *V, unsigned Depth, 
        
                                                  const SimplifyQuery &SQ) { 
        
             KnownFPClass Known = 
        
                 computeKnownFPClass(V, KnownFPClass::OrderedLessThanZeroMask, Depth, SQ); 
        
             return Known.cannotBeOrderedLessThanZero(); 
        
           } 
        
           bool llvm::isKnownNeverInfinity(const Value *V, unsigned Depth, 
        
                                           const SimplifyQuery &SQ) { 
        
             KnownFPClass Known = computeKnownFPClass(V, fcInf, Depth, SQ); 
        
             return Known.isKnownNeverInfinity(); 
        
           } 
        
           /// Return true if the floating-point value can never contain a NaN or infinity. 
        
           bool llvm::isKnownNeverInfOrNaN(const Value *V, unsigned Depth, 
        
                                           const SimplifyQuery &SQ) { 
        
             KnownFPClass Known = computeKnownFPClass(V, fcInf | fcNan, Depth, SQ); 
        
             return Known.isKnownNeverNaN() && Known.isKnownNeverInfinity(); 
        
           } 
        
           /// Return true if the floating-point scalar value is not a NaN or if the 
        
           /// floating-point vector value has no NaN elements. Return false if a value 
        
           /// could ever be NaN. 
        
           bool llvm::isKnownNeverNaN(const Value *V, unsigned Depth, 
        
                                      const SimplifyQuery &SQ) { 
        
             KnownFPClass Known = computeKnownFPClass(V, fcNan, Depth, SQ); 
        
             return Known.isKnownNeverNaN(); 
        
           } 
        
           /// Return false if we can prove that the specified FP value's sign bit is 0. 
        
           /// Return true if we can prove that the specified FP value's sign bit is 1. 
        
           /// Otherwise return std::nullopt. 
        
           std::optional<bool> llvm::computeKnownFPSignBit(const Value *V, unsigned Depth, 
        
                                                           const SimplifyQuery &SQ) { 
        
             KnownFPClass Known = computeKnownFPClass(V, fcAllFlags, Depth, SQ); 
        
             return Known.SignBit; 
        
           }

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

[DAG] Replace/Wrap SelectionDAG::isKnownNeverNaN with SelectionDAG::computeKnownFPClass #137943

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

	bool llvm::cannotBeNegativeZero(const Value *V, unsigned Depth,
	const SimplifyQuery &SQ) {
	KnownFPClass Known = computeKnownFPClass(V, fcNegZero, Depth, SQ);
	return Known.isKnownNeverNegZero();
	}

	bool llvm::cannotBeOrderedLessThanZero(const Value *V, unsigned Depth,
	const SimplifyQuery &SQ) {
	KnownFPClass Known =
	computeKnownFPClass(V, KnownFPClass::OrderedLessThanZeroMask, Depth, SQ);
	return Known.cannotBeOrderedLessThanZero();
	}

	bool llvm::isKnownNeverInfinity(const Value *V, unsigned Depth,
	const SimplifyQuery &SQ) {
	KnownFPClass Known = computeKnownFPClass(V, fcInf, Depth, SQ);
	return Known.isKnownNeverInfinity();
	}

	/// Return true if the floating-point value can never contain a NaN or infinity.
	bool llvm::isKnownNeverInfOrNaN(const Value *V, unsigned Depth,
	const SimplifyQuery &SQ) {
	KnownFPClass Known = computeKnownFPClass(V, fcInf \| fcNan, Depth, SQ);
	return Known.isKnownNeverNaN() && Known.isKnownNeverInfinity();
	}

	/// Return true if the floating-point scalar value is not a NaN or if the
	/// floating-point vector value has no NaN elements. Return false if a value
	/// could ever be NaN.
	bool llvm::isKnownNeverNaN(const Value *V, unsigned Depth,
	const SimplifyQuery &SQ) {
	KnownFPClass Known = computeKnownFPClass(V, fcNan, Depth, SQ);
	return Known.isKnownNeverNaN();
	}

	/// Return false if we can prove that the specified FP value's sign bit is 0.
	/// Return true if we can prove that the specified FP value's sign bit is 1.
	/// Otherwise return std::nullopt.
	std::optional<bool> llvm::computeKnownFPSignBit(const Value *V, unsigned Depth,
	const SimplifyQuery &SQ) {
	KnownFPClass Known = computeKnownFPClass(V, fcAllFlags, Depth, SQ);
	return Known.SignBit;
	}

Search code, repositories, users, issues, pull requests...

[DAG] Replace/Wrap SelectionDAG::isKnownNeverNaN with SelectionDAG::computeKnownFPClass #137943

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions