Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-21 01:05:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1431698 - Change the IntConversion enumerations to enum classes. r=bbouvier

Browse Source
This commit is contained in:
Aanchal 2018-01-31 10:21:20 +05:30
parent fcdf6d6157
commit ad3adf7561
7 changed files with 53 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
js/src/jit/IonTypes.h
View File

@ -391,20 +391,20 @@ class SimdConstant {
}
};
enum IntConversionBehavior {
enum class IntConversionBehavior {
// These two try to convert the input to an int32 using ToNumber and
// will fail if the resulting int32 isn't strictly equal to the input.
IntConversion_Normal,
IntConversion_NegativeZeroCheck,
Normal,
NegativeZeroCheck,
// These two will convert the input to an int32 with loss of precision.
IntConversion_Truncate,
IntConversion_ClampToUint8,
Truncate,
ClampToUint8,
};
enum IntConversionInputKind {
IntConversion_NumbersOnly,
IntConversion_NumbersOrBoolsOnly,
IntConversion_Any
enum class IntConversionInputKind {
NumbersOnly,
NumbersOrBoolsOnly,
Any
};
// The ordering of this enumeration is important: Anything < Value is a

6
js/src/jit/Lowering.cpp
View File

@ -2197,13 +2197,13 @@ LIRGenerator::visitToNumberInt32(MToNumberInt32* convert)
}
case MIRType::Null:
MOZ_ASSERT(convert->conversion() == IntConversion_Any);
MOZ_ASSERT(convert->conversion() == IntConversionInputKind::Any);
define(new(alloc()) LInteger(0), convert);
break;
case MIRType::Boolean:
MOZ_ASSERT(convert->conversion() == IntConversion_Any ||
convert->conversion() == IntConversion_NumbersOrBoolsOnly);
MOZ_ASSERT(convert->conversion() == IntConversionInputKind::Any ||
convert->conversion() == IntConversionInputKind::NumbersOrBoolsOnly);
redefine(convert, opd);
break;

6
js/src/jit/MIR.cpp
View File

@ -4321,11 +4321,11 @@ MToNumberInt32::foldsTo(TempAllocator& alloc)
DebugOnly<IntConversionInputKind> convert = conversion();
switch (input->type()) {
case MIRType::Null:
MOZ_ASSERT(convert == IntConversion_Any);
MOZ_ASSERT(convert.value == IntConversionInputKind::Any);
return MConstant::New(alloc, Int32Value(0));
case MIRType::Boolean:
MOZ_ASSERT(convert == IntConversion_Any ||
convert == IntConversion_NumbersOrBoolsOnly);
MOZ_ASSERT(convert.value == IntConversionInputKind::Any ||
convert.value == IntConversionInputKind::NumbersOrBoolsOnly);
return MConstant::New(alloc, Int32Value(input->toConstant()->toBoolean()));
case MIRType::Int32:
return MConstant::New(alloc, Int32Value(input->toConstant()->toInt32()));

2
js/src/jit/MIR.h
View File

@ -5685,7 +5685,7 @@ class MToNumberInt32
IntConversionInputKind conversion_;
explicit MToNumberInt32(MDefinition* def, IntConversionInputKind conversion
= IntConversion_Any)
= IntConversionInputKind::Any)
: MUnaryInstruction(classOpcode, def),
canBeNegativeZero_(true),
conversion_(conversion)

44
js/src/jit/MacroAssembler.cpp
View File

@ -2151,14 +2151,14 @@ MacroAssembler::convertDoubleToInt(FloatRegister src, Register output, FloatRegi
IntConversionBehavior behavior)
{
switch (behavior) {
case IntConversion_Normal:
case IntConversion_NegativeZeroCheck:
convertDoubleToInt32(src, output, fail, behavior == IntConversion_NegativeZeroCheck);
case IntConversionBehavior::Normal:
case IntConversionBehavior::NegativeZeroCheck:
convertDoubleToInt32(src, output, fail, behavior == IntConversionBehavior::NegativeZeroCheck);
break;
case IntConversion_Truncate:
case IntConversionBehavior::Truncate:
branchTruncateDoubleMaybeModUint32(src, output, truncateFail ? truncateFail : fail);
break;
case IntConversion_ClampToUint8:
case IntConversionBehavior::ClampToUint8:
// Clamping clobbers the input register, so use a temp.
moveDouble(src, temp);
clampDoubleToUint8(temp, output);
@ -2175,31 +2175,31 @@ MacroAssembler::convertValueToInt(ValueOperand value, MDefinition* maybeInput,
IntConversionInputKind conversion)
{
Register tag = splitTagForTest(value);
bool handleStrings = (behavior == IntConversion_Truncate ||
behavior == IntConversion_ClampToUint8) &&
bool handleStrings = (behavior == IntConversionBehavior::Truncate ||
behavior == IntConversionBehavior::ClampToUint8) &&
handleStringEntry &&
handleStringRejoin;
MOZ_ASSERT_IF(handleStrings, conversion == IntConversion_Any);
MOZ_ASSERT_IF(handleStrings, conversion == IntConversionInputKind::Any);
Label done, isInt32, isBool, isDouble, isNull, isString;
maybeBranchTestType(MIRType::Int32, maybeInput, tag, &isInt32);
if (conversion == IntConversion_Any || conversion == IntConversion_NumbersOrBoolsOnly)
if (conversion == IntConversionInputKind::Any || conversion == IntConversionInputKind::NumbersOrBoolsOnly)
maybeBranchTestType(MIRType::Boolean, maybeInput, tag, &isBool);
maybeBranchTestType(MIRType::Double, maybeInput, tag, &isDouble);
if (conversion == IntConversion_Any) {
if (conversion == IntConversionInputKind::Any) {
// If we are not truncating, we fail for anything that's not
// null. Otherwise we might be able to handle strings and objects.
switch (behavior) {
case IntConversion_Normal:
case IntConversion_NegativeZeroCheck:
case IntConversionBehavior::Normal:
case IntConversionBehavior::NegativeZeroCheck:
branchTestNull(Assembler::NotEqual, tag, fail);
break;
case IntConversion_Truncate:
case IntConversion_ClampToUint8:
case IntConversionBehavior::Truncate:
case IntConversionBehavior::ClampToUint8:
maybeBranchTestType(MIRType::Null, maybeInput, tag, &isNull);
if (handleStrings)
maybeBranchTestType(MIRType::String, maybeInput, tag, &isString);
@ -2249,7 +2249,7 @@ MacroAssembler::convertValueToInt(ValueOperand value, MDefinition* maybeInput,
if (isInt32.used()) {
bind(&isInt32);
unboxInt32(value, output);
if (behavior == IntConversion_ClampToUint8)
if (behavior == IntConversionBehavior::ClampToUint8)
clampIntToUint8(output);
}
@ -2260,8 +2260,8 @@ bool
MacroAssembler::convertValueToInt(JSContext* cx, const Value& v, Register output, Label* fail,
IntConversionBehavior behavior)
{
bool handleStrings = (behavior == IntConversion_Truncate ||
behavior == IntConversion_ClampToUint8);
bool handleStrings = (behavior == IntConversionBehavior::Truncate ||
behavior == IntConversionBehavior::ClampToUint8);
if (v.isNumber() || (handleStrings && v.isString())) {
double d;
@ -2271,8 +2271,8 @@ MacroAssembler::convertValueToInt(JSContext* cx, const Value& v, Register output
return false;
switch (behavior) {
case IntConversion_Normal:
case IntConversion_NegativeZeroCheck: {
case IntConversionBehavior::Normal:
case IntConversionBehavior::NegativeZeroCheck: {
// -0 is checked anyways if we have a constant value.
int i;
if (mozilla::NumberIsInt32(d, &i))
@ -2281,10 +2281,10 @@ MacroAssembler::convertValueToInt(JSContext* cx, const Value& v, Register output
jump(fail);
break;
}
case IntConversion_Truncate:
case IntConversionBehavior::Truncate:
move32(Imm32(ToInt32(d)), output);
break;
case IntConversion_ClampToUint8:
case IntConversionBehavior::ClampToUint8:
move32(Imm32(ClampDoubleToUint8(d)), output);
break;
}
@ -2340,7 +2340,7 @@ MacroAssembler::convertTypedOrValueToInt(TypedOrValueRegister src, FloatRegister
case MIRType::Int32:
if (src.typedReg().gpr() != output)
move32(src.typedReg().gpr(), output);
if (src.type() == MIRType::Int32 && behavior == IntConversion_ClampToUint8)
if (src.type() == MIRType::Int32 && behavior == IntConversionBehavior::ClampToUint8)
clampIntToUint8(output);
break;
case MIRType::Double:

16
js/src/jit/MacroAssembler.h
View File

@ -2362,7 +2362,7 @@ class MacroAssembler : public MacroAssemblerSpecific
Label* truncateDoubleSlow,
Register stringReg, FloatRegister temp, Register output,
Label* fail, IntConversionBehavior behavior,
IntConversionInputKind conversion = IntConversion_Any);
IntConversionInputKind conversion = IntConversionInputKind::Any);
void convertValueToInt(ValueOperand value, FloatRegister temp, Register output, Label* fail,
IntConversionBehavior behavior)
{
@ -2383,12 +2383,12 @@ class MacroAssembler : public MacroAssemblerSpecific
void convertValueToInt32(ValueOperand value, MDefinition* input,
FloatRegister temp, Register output, Label* fail,
bool negativeZeroCheck,
IntConversionInputKind conversion = IntConversion_Any)
IntConversionInputKind conversion = IntConversionInputKind::Any)
{
convertValueToInt(value, input, nullptr, nullptr, nullptr, InvalidReg, temp, output, fail,
negativeZeroCheck
? IntConversion_NegativeZeroCheck
: IntConversion_Normal,
? IntConversionBehavior::NegativeZeroCheck
: IntConversionBehavior::Normal,
conversion);
}
@ -2400,7 +2400,7 @@ class MacroAssembler : public MacroAssemblerSpecific
Register stringReg, FloatRegister temp, Register output, Label* fail)
{
convertValueToInt(value, input, handleStringEntry, handleStringRejoin, truncateDoubleSlow,
stringReg, temp, output, fail, IntConversion_Truncate);
stringReg, temp, output, fail, IntConversionBehavior::Truncate);
}
void truncateValueToInt32(ValueOperand value, FloatRegister temp, Register output, Label* fail)
@ -2414,7 +2414,7 @@ class MacroAssembler : public MacroAssemblerSpecific
FloatRegister temp, Register output,
Label* fail)
{
return convertConstantOrRegisterToInt(cx, src, temp, output, fail, IntConversion_Truncate);
return convertConstantOrRegisterToInt(cx, src, temp, output, fail, IntConversionBehavior::Truncate);
}
// Convenience functions for clamping values to uint8.
@ -2423,7 +2423,7 @@ class MacroAssembler : public MacroAssemblerSpecific
Register stringReg, FloatRegister temp, Register output, Label* fail)
{
convertValueToInt(value, input, handleStringEntry, handleStringRejoin, nullptr,
stringReg, temp, output, fail, IntConversion_ClampToUint8);
stringReg, temp, output, fail, IntConversionBehavior::ClampToUint8);
}
MOZ_MUST_USE bool clampConstantOrRegisterToUint8(JSContext* cx,
@ -2432,7 +2432,7 @@ class MacroAssembler : public MacroAssemblerSpecific
Label* fail)
{
return convertConstantOrRegisterToInt(cx, src, temp, output, fail,
IntConversion_ClampToUint8);
IntConversionBehavior::ClampToUint8);
}
public:

14
js/src/jit/TypePolicy.cpp
View File

@ -235,12 +235,12 @@ ComparePolicy::adjustInputs(TempAllocator& alloc, MInstruction* def)
break;
}
case MIRType::Int32: {
IntConversionInputKind convert = IntConversion_NumbersOnly;
IntConversionInputKind convert = IntConversionInputKind::NumbersOnly;
if (compare->compareType() == MCompare::Compare_Int32MaybeCoerceBoth ||
(compare->compareType() == MCompare::Compare_Int32MaybeCoerceLHS && i == 0) ||
(compare->compareType() == MCompare::Compare_Int32MaybeCoerceRHS && i == 1))
{
convert = IntConversion_NumbersOrBoolsOnly;
convert = IntConversionInputKind::NumbersOrBoolsOnly;
}
replace = MToNumberInt32::New(alloc, in, convert);
break;
@ -728,7 +728,7 @@ ToInt32Policy::staticAdjustInputs(TempAllocator& alloc, MInstruction* ins)
{
MOZ_ASSERT(ins->isToNumberInt32() || ins->isTruncateToInt32());
IntConversionInputKind conversion = IntConversion_Any;
IntConversionInputKind conversion = IntConversionInputKind::Any;
if (ins->isToNumberInt32())
conversion = ins->toToNumberInt32()->conversion();
@ -747,14 +747,14 @@ ToInt32Policy::staticAdjustInputs(TempAllocator& alloc, MInstruction* ins)
break;
case MIRType::Null:
// No need for boxing, when we will convert.
if (conversion == IntConversion_Any)
if (conversion == IntConversionInputKind::Any)
return true;
break;
case MIRType::Boolean:
// No need for boxing, when we will convert.
if (conversion == IntConversion_Any)
if (conversion == IntConversionInputKind::Any)
return true;
if (conversion == IntConversion_NumbersOrBoolsOnly)
if (conversion == IntConversionInputKind::NumbersOrBoolsOnly)
return true;
break;
case MIRType::Object:
@ -857,7 +857,7 @@ SimdShufflePolicy::adjustInputs(TempAllocator& alloc, MInstruction* ins)
if (in->type() == MIRType::Int32)
continue;
auto* replace = MToNumberInt32::New(alloc, in, IntConversion_NumbersOnly);
auto* replace = MToNumberInt32::New(alloc, in, IntConversionInputKind::NumbersOnly);
ins->block()->insertBefore(ins, replace);
ins->replaceOperand(s->numVectors() + i, replace);
if (!replace->typePolicy()->adjustInputs(alloc, replace))