Patch reviewed by Reid Kleckner and Jim Grosbach.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@194533
91177308-0d34-0410-b5e6-
96231b3b80d8
/// isSpillable - Can this interval be spilled?
bool isSpillable() const {
/// isSpillable - Can this interval be spilled?
bool isSpillable() const {
- return weight != HUGE_VALF;
+ return weight != llvm::huge_valf;
}
/// markNotSpillable - Mark interval as not spillable
void markNotSpillable() {
}
/// markNotSpillable - Mark interval as not spillable
void markNotSpillable() {
+ weight = llvm::huge_valf;
}
bool operator<(const LiveInterval& other) const {
}
bool operator<(const LiveInterval& other) const {
#include <cstring>
#ifdef _MSC_VER
#include <cstring>
#ifdef _MSC_VER
+#include <intrin.h>
+#include <limits>
return int64_t(X << (64 - B)) >> (64 - B);
}
return int64_t(X << (64 - B)) >> (64 - B);
}
+#if defined(_MSC_VER)
+ // Visual Studio defines the HUGE_VAL class of macros using purposeful
+ // constant arithmetic overflow, which it then warns on when encountered.
+ const float huge_valf = std::numeric_limits<float>::infinity();
+ const double huge_vald = std::numeric_limits<double>::infinity();
+ const long double huge_vall = std::numeric_limits<long double>::infinity();
+#else
+ const float huge_valf = HUGE_VALF;
+ const double huge_vald = HUGE_VALD;
+ const long double huge_vall = HUGE_VALL;
+#endif
} // End llvm namespace
#endif
} // End llvm namespace
#endif
#endif
LiveInterval* LiveIntervals::createInterval(unsigned reg) {
#endif
LiveInterval* LiveIntervals::createInterval(unsigned reg) {
- float Weight = TargetRegisterInfo::isPhysicalRegister(reg) ? HUGE_VALF : 0.0F;
+ float Weight = TargetRegisterInfo::isPhysicalRegister(reg) ?
+ llvm::huge_valf : 0.0F;
return new LiveInterval(reg, Weight);
}
return new LiveInterval(reg, Weight);
}
break;
for (; Gap != NumGaps; ++Gap) {
break;
for (; Gap != NumGaps; ++Gap) {
- GapWeight[Gap] = HUGE_VALF;
+ GapWeight[Gap] = llvm::huge_valf;
if (Uses[Gap+1].getBaseIndex() >= I->end)
break;
}
if (Uses[Gap+1].getBaseIndex() >= I->end)
break;
}
// Remove any gaps with regmask clobbers.
if (Matrix->checkRegMaskInterference(VirtReg, PhysReg))
for (unsigned i = 0, e = RegMaskGaps.size(); i != e; ++i)
// Remove any gaps with regmask clobbers.
if (Matrix->checkRegMaskInterference(VirtReg, PhysReg))
for (unsigned i = 0, e = RegMaskGaps.size(); i != e; ++i)
- GapWeight[RegMaskGaps[i]] = HUGE_VALF;
+ GapWeight[RegMaskGaps[i]] = llvm::huge_valf;
// Try to find the best sequence of gaps to close.
// The new spill weight must be larger than any gap interference.
// Try to find the best sequence of gaps to close.
// The new spill weight must be larger than any gap interference.
// Legally, without causing looping?
bool Legal = !ProgressRequired || NewGaps < NumGaps;
// Legally, without causing looping?
bool Legal = !ProgressRequired || NewGaps < NumGaps;
- if (Legal && MaxGap < HUGE_VALF) {
+ if (Legal && MaxGap < llvm::huge_valf) {
// Estimate the new spill weight. Each instruction reads or writes the
// register. Conservatively assume there are no read-modify-write
// instructions.
// Estimate the new spill weight. Each instruction reads or writes the
// register. Conservatively assume there are no read-modify-write
// instructions.
DEBUG(dbgs() << "Spilling everywhere " << *li << "\n");
DEBUG(dbgs() << "Spilling everywhere " << *li << "\n");
- assert(li->weight != HUGE_VALF &&
+ assert(li->weight != llvm::huge_valf &&
"Attempting to spill already spilled value.");
assert(!TargetRegisterInfo::isStackSlot(li->reg) &&
"Attempting to spill already spilled value.");
assert(!TargetRegisterInfo::isStackSlot(li->reg) &&