Skip to content

Commit a7687df

Browse files
gengjiawengengjiawen
committed
revert fafb4769984690ac87f0183d09973b934b0b74dd
1 parent 95ef061 commit a7687df

8 files changed

+26
-137
lines changed

‎deps/v8/src/compiler/backend/arm64/code-generator-arm64.cc

Lines changed: 11 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1520,32 +1520,24 @@ CodeGenerator::CodeGenResult CodeGenerator::AssembleArchInstruction(
15201520
case kArm64Float64ToFloat32:
15211521
__ Fcvt(i.OutputDoubleRegister().S(), i.InputDoubleRegister(0));
15221522
break;
1523-
case kArm64Float32ToInt32: {
1523+
case kArm64Float32ToInt32:
15241524
__ Fcvtzs(i.OutputRegister32(), i.InputFloat32Register(0));
1525-
bool set_overflow_to_min_i32 = MiscField::decode(instr->opcode());
1526-
if (set_overflow_to_min_i32) {
1527-
// Avoid INT32_MAX as an overflow indicator and use INT32_MIN instead,
1528-
// because INT32_MIN allows easier out-of-bounds detection.
1529-
__ Cmn(i.OutputRegister32(), 1);
1530-
__ Csinc(i.OutputRegister32(), i.OutputRegister32(),
1531-
i.OutputRegister32(), vc);
1532-
}
1525+
// Avoid INT32_MAX as an overflow indicator and use INT32_MIN instead,
1526+
// because INT32_MIN allows easier out-of-bounds detection.
1527+
__ Cmn(i.OutputRegister32(), 1);
1528+
__ Csinc(i.OutputRegister32(), i.OutputRegister32(), i.OutputRegister32(),
1529+
vc);
15331530
break;
1534-
}
15351531
case kArm64Float64ToInt32:
15361532
__ Fcvtzs(i.OutputRegister32(), i.InputDoubleRegister(0));
15371533
break;
1538-
case kArm64Float32ToUint32: {
1534+
case kArm64Float32ToUint32:
15391535
__ Fcvtzu(i.OutputRegister32(), i.InputFloat32Register(0));
1540-
bool set_overflow_to_min_u32 = MiscField::decode(instr->opcode());
1541-
if (set_overflow_to_min_u32) {
1542-
// Avoid UINT32_MAX as an overflow indicator and use 0 instead,
1543-
// because 0 allows easier out-of-bounds detection.
1544-
__ Cmn(i.OutputRegister32(), 1);
1545-
__ Adc(i.OutputRegister32(), i.OutputRegister32(), Operand(0));
1546-
}
1536+
// Avoid UINT32_MAX as an overflow indicator and use 0 instead,
1537+
// because 0 allows easier out-of-bounds detection.
1538+
__ Cmn(i.OutputRegister32(), 1);
1539+
__ Adc(i.OutputRegister32(), i.OutputRegister32(), Operand(0));
15471540
break;
1548-
}
15491541
case kArm64Float64ToUint32:
15501542
__ Fcvtzu(i.OutputRegister32(), i.InputDoubleRegister(0));
15511543
break;

‎deps/v8/src/compiler/backend/arm64/instruction-selector-arm64.cc

Lines changed: 3 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1336,8 +1336,10 @@ void InstructionSelector::VisitWord64Ror(Node* node) {
13361336
V(ChangeInt32ToFloat64, kArm64Int32ToFloat64) \
13371337
V(ChangeInt64ToFloat64, kArm64Int64ToFloat64) \
13381338
V(ChangeUint32ToFloat64, kArm64Uint32ToFloat64) \
1339+
V(TruncateFloat32ToInt32, kArm64Float32ToInt32) \
13391340
V(ChangeFloat64ToInt32, kArm64Float64ToInt32) \
13401341
V(ChangeFloat64ToInt64, kArm64Float64ToInt64) \
1342+
V(TruncateFloat32ToUint32, kArm64Float32ToUint32) \
13411343
V(ChangeFloat64ToUint32, kArm64Float64ToUint32) \
13421344
V(ChangeFloat64ToUint64, kArm64Float64ToUint64) \
13431345
V(TruncateFloat64ToInt64, kArm64Float64ToInt64) \
@@ -1638,28 +1640,6 @@ void InstructionSelector::VisitUint32MulHigh(Node* node) {
16381640
Emit(kArm64Lsr, g.DefineAsRegister(node), smull_operand, g.TempImmediate(32));
16391641
}
16401642

1641-
void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
1642-
Arm64OperandGenerator g(this);
1643-
1644-
InstructionCode opcode = kArm64Float32ToInt32;
1645-
TruncateKind kind = OpParameter<TruncateKind>(node->op());
1646-
opcode |= MiscField::encode(kind == TruncateKind::kSetOverflowToMin);
1647-
1648-
Emit(opcode, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
1649-
}
1650-
1651-
void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
1652-
Arm64OperandGenerator g(this);
1653-
1654-
InstructionCode opcode = kArm64Float32ToUint32;
1655-
TruncateKind kind = OpParameter<TruncateKind>(node->op());
1656-
if (kind == TruncateKind::kSetOverflowToMin) {
1657-
opcode |= MiscField::encode(true);
1658-
}
1659-
1660-
Emit(opcode, g.DefineAsRegister(node), g.UseRegister(node->InputAt(0)));
1661-
}
1662-
16631643
void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
16641644
Arm64OperandGenerator g(this);
16651645

@@ -3718,8 +3698,7 @@ InstructionSelector::SupportedMachineOperatorFlags() {
37183698
MachineOperatorBuilder::kInt32DivIsSafe |
37193699
MachineOperatorBuilder::kUint32DivIsSafe |
37203700
MachineOperatorBuilder::kWord32ReverseBits |
3721-
MachineOperatorBuilder::kWord64ReverseBits |
3722-
MachineOperatorBuilder::kSatConversionIsSafe;
3701+
MachineOperatorBuilder::kWord64ReverseBits;
37233702
}
37243703

37253704
// static

‎deps/v8/src/compiler/code-assembler.cc

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -635,11 +635,6 @@ TNode<Float64T> CodeAssembler::RoundIntPtrToFloat64(Node* value) {
635635
return UncheckedCast<Float64T>(raw_assembler()->ChangeInt32ToFloat64(value));
636636
}
637637

638-
TNode<Int32T> CodeAssembler::TruncateFloat32ToInt32(
639-
SloppyTNode<Float32T> value) {
640-
return UncheckedCast<Int32T>(raw_assembler()->TruncateFloat32ToInt32(
641-
value, TruncateKind::kSetOverflowToMin));
642-
}
643638
#define DEFINE_CODE_ASSEMBLER_UNARY_OP(name, ResType, ArgType) \
644639
TNode<ResType> CodeAssembler::name(SloppyTNode<ArgType> a) { \
645640
return UncheckedCast<ResType>(raw_assembler()->name(a)); \

‎deps/v8/src/compiler/code-assembler.h

Lines changed: 1 addition & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -323,6 +323,7 @@ TNode<Float64T> Float64Add(TNode<Float64T> a, TNode<Float64T> b);
323323
V(BitcastMaybeObjectToWord, IntPtrT, MaybeObject) \
324324
V(BitcastWordToTagged, Object, WordT) \
325325
V(BitcastWordToTaggedSigned, Smi, WordT) \
326+
V(TruncateFloat32ToInt32, Int32T, Float32T) \
326327
V(TruncateFloat64ToFloat32, Float32T, Float64T) \
327328
V(TruncateFloat64ToWord32, Uint32T, Float64T) \
328329
V(TruncateInt64ToInt32, Int32T, Int64T) \
@@ -958,12 +959,6 @@ class V8_EXPORT_PRIVATE CodeAssembler {
958959
// No-op on 32-bit, otherwise sign extend.
959960
TNode<IntPtrT> ChangeInt32ToIntPtr(TNode<Word32T> value);
960961

961-
// Truncates a float to a 32-bit integer. If the float is outside of 32-bit
962-
// range, make sure that overflow detection is easy. In particular, return
963-
// int_min instead of int_max on arm platforms by using parameter
964-
// kSetOverflowToMin.
965-
TNode<Int32T> TruncateFloat32ToInt32(SloppyTNode<Float32T> value);
966-
967962
// No-op that guarantees that the value is kept alive till this point even
968963
// if GC happens.
969964
Node* Retain(Node* value);

‎deps/v8/src/compiler/machine-operator.cc

Lines changed: 2 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -235,6 +235,8 @@ ShiftKind ShiftKindOf(Operator const* op) {
235235
V(ChangeFloat64ToUint64, Operator::kNoProperties, 1, 0, 1) \
236236
V(TruncateFloat64ToInt64, Operator::kNoProperties, 1, 0, 1) \
237237
V(TruncateFloat64ToUint32, Operator::kNoProperties, 1, 0, 1) \
238+
V(TruncateFloat32ToInt32, Operator::kNoProperties, 1, 0, 1) \
239+
V(TruncateFloat32ToUint32, Operator::kNoProperties, 1, 0, 1) \
238240
V(TryTruncateFloat32ToInt64, Operator::kNoProperties, 1, 0, 2) \
239241
V(TryTruncateFloat64ToInt64, Operator::kNoProperties, 1, 0, 2) \
240242
V(TryTruncateFloat32ToUint64, Operator::kNoProperties, 1, 0, 2) \
@@ -1012,55 +1014,6 @@ const Operator* MachineOperatorBuilder::UnalignedStore(
10121014
UNREACHABLE();
10131015
}
10141016

1015-
template <TruncateKind kind>
1016-
struct TruncateFloat32ToUint32Operator : Operator1<TruncateKind> {
1017-
TruncateFloat32ToUint32Operator()
1018-
: Operator1(IrOpcode::kTruncateFloat32ToUint32, Operator::kPure,
1019-
"TruncateFloat32ToUint32", 1, 0, 0, 1, 0, 0, kind) {}
1020-
};
1021-
1022-
const Operator* MachineOperatorBuilder::TruncateFloat32ToUint32(
1023-
TruncateKind kind) {
1024-
switch (kind) {
1025-
case TruncateKind::kArchitectureDefault:
1026-
return GetCachedOperator<TruncateFloat32ToUint32Operator<
1027-
TruncateKind::kArchitectureDefault>>();
1028-
case TruncateKind::kSetOverflowToMin:
1029-
return GetCachedOperator<
1030-
TruncateFloat32ToUint32Operator<TruncateKind::kSetOverflowToMin>>();
1031-
}
1032-
}
1033-
1034-
template <TruncateKind kind>
1035-
struct TruncateFloat32ToInt32Operator : Operator1<TruncateKind> {
1036-
TruncateFloat32ToInt32Operator()
1037-
: Operator1(IrOpcode::kTruncateFloat32ToInt32, Operator::kPure,
1038-
"TruncateFloat32ToInt32", 1, 0, 0, 1, 0, 0, kind) {}
1039-
};
1040-
1041-
const Operator* MachineOperatorBuilder::TruncateFloat32ToInt32(
1042-
TruncateKind kind) {
1043-
switch (kind) {
1044-
case TruncateKind::kArchitectureDefault:
1045-
return GetCachedOperator<
1046-
TruncateFloat32ToInt32Operator<TruncateKind::kArchitectureDefault>>();
1047-
case TruncateKind::kSetOverflowToMin:
1048-
return GetCachedOperator<
1049-
TruncateFloat32ToInt32Operator<TruncateKind::kSetOverflowToMin>>();
1050-
}
1051-
}
1052-
1053-
size_t hash_value(TruncateKind kind) { return static_cast<size_t>(kind); }
1054-
1055-
std::ostream& operator<<(std::ostream& os, TruncateKind kind) {
1056-
switch (kind) {
1057-
case TruncateKind::kArchitectureDefault:
1058-
return os << "kArchitectureDefault";
1059-
case TruncateKind::kSetOverflowToMin:
1060-
return os << "kSetOverflowToMin";
1061-
}
1062-
}
1063-
10641017
#define PURE(Name, properties, value_input_count, control_input_count, \
10651018
output_count) \
10661019
const Operator* MachineOperatorBuilder::Name() { \

‎deps/v8/src/compiler/machine-operator.h

Lines changed: 3 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -192,12 +192,6 @@ size_t hash_value(ShiftKind);
192192
V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, ShiftKind);
193193
ShiftKind ShiftKindOf(Operator const*) V8_WARN_UNUSED_RESULT;
194194

195-
// TruncateKind::kSetOverflowToMin sets the result of a saturating float-to-int
196-
// conversion to INT_MIN if the conversion returns INT_MAX due to overflow. This
197-
// makes it easier to detect an overflow. This parameter is ignored on platforms
198-
// like x64 and ia32 where a range overflow does not result in INT_MAX.
199-
enum class TruncateKind { kArchitectureDefault, kSetOverflowToMin };
200-
201195
// Interface for building machine-level operators. These operators are
202196
// machine-level but machine-independent and thus define a language suitable
203197
// for generating code to run on architectures such as ia32, x64, arm, etc.
@@ -230,14 +224,13 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
230224
kInt64AbsWithOverflow = 1u << 21,
231225
kWord32Rol = 1u << 22,
232226
kWord64Rol = 1u << 23,
233-
kSatConversionIsSafe = 1u << 24,
234227
kAllOptionalOps =
235228
kFloat32RoundDown | kFloat64RoundDown | kFloat32RoundUp |
236229
kFloat64RoundUp | kFloat32RoundTruncate | kFloat64RoundTruncate |
237230
kFloat64RoundTiesAway | kFloat32RoundTiesEven | kFloat64RoundTiesEven |
238231
kWord32Ctz | kWord64Ctz | kWord32Popcnt | kWord64Popcnt |
239232
kWord32ReverseBits | kWord64ReverseBits | kInt32AbsWithOverflow |
240-
kInt64AbsWithOverflow | kWord32Rol | kWord64Rol | kSatConversionIsSafe
233+
kInt64AbsWithOverflow | kWord32Rol | kWord64Rol
241234
};
242235
using Flags = base::Flags<Flag, unsigned>;
243236

@@ -339,11 +332,6 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
339332
// generate a mask with 0x1f on the amount ahead of generating the shift.
340333
bool Word32ShiftIsSafe() const { return flags_ & kWord32ShiftIsSafe; }
341334

342-
// Return true if the target's implementation of float-to-int-conversions is a
343-
// saturating conversion rounding towards 0. Otherwise, we have to manually
344-
// generate the correct value if a saturating conversion is requested.
345-
bool SatConversionIsSafe() const { return flags_ & kSatConversionIsSafe; }
346-
347335
const Operator* Word64And();
348336
const Operator* Word64Or();
349337
const Operator* Word64Xor();
@@ -429,19 +417,15 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
429417
// in the target type and are *not* defined for other inputs.
430418
// Use narrowing change operators only when there is a static guarantee that
431419
// the input value is representable in the target value.
432-
//
433-
// Some operators can have the behaviour on overflow change through specifying
434-
// TruncateKind. The exact semantics are documented in the tests in
435-
// test/cctest/compiler/test-run-machops.cc .
436420
const Operator* ChangeFloat32ToFloat64();
437421
const Operator* ChangeFloat64ToInt32(); // narrowing
438422
const Operator* ChangeFloat64ToInt64();
439423
const Operator* ChangeFloat64ToUint32(); // narrowing
440424
const Operator* ChangeFloat64ToUint64();
441425
const Operator* TruncateFloat64ToInt64();
442426
const Operator* TruncateFloat64ToUint32();
443-
const Operator* TruncateFloat32ToInt32(TruncateKind kind);
444-
const Operator* TruncateFloat32ToUint32(TruncateKind kind);
427+
const Operator* TruncateFloat32ToInt32();
428+
const Operator* TruncateFloat32ToUint32();
445429
const Operator* TryTruncateFloat32ToInt64();
446430
const Operator* TryTruncateFloat64ToInt64();
447431
const Operator* TryTruncateFloat32ToUint64();

‎deps/v8/src/compiler/raw-machine-assembler.h

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -721,11 +721,11 @@ class V8_EXPORT_PRIVATE RawMachineAssembler {
721721
Node* TruncateFloat64ToUint32(Node* a) {
722722
return AddNode(machine()->TruncateFloat64ToUint32(), a);
723723
}
724-
Node* TruncateFloat32ToInt32(Node* a, TruncateKind kind) {
725-
return AddNode(machine()->TruncateFloat32ToInt32(kind), a);
724+
Node* TruncateFloat32ToInt32(Node* a) {
725+
return AddNode(machine()->TruncateFloat32ToInt32(), a);
726726
}
727-
Node* TruncateFloat32ToUint32(Node* a, TruncateKind kind) {
728-
return AddNode(machine()->TruncateFloat32ToUint32(kind), a);
727+
Node* TruncateFloat32ToUint32(Node* a) {
728+
return AddNode(machine()->TruncateFloat32ToUint32(), a);
729729
}
730730
Node* TryTruncateFloat32ToInt64(Node* a) {
731731
return AddNode(machine()->TryTruncateFloat32ToInt64(), a);

‎deps/v8/src/compiler/wasm-compiler.cc

Lines changed: 2 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1550,17 +1550,11 @@ MachineType FloatConvertType(wasm::WasmOpcode opcode) {
15501550
const Operator* ConvertOp(WasmGraphBuilder* builder, wasm::WasmOpcode opcode) {
15511551
switch (opcode) {
15521552
case wasm::kExprI32SConvertF32:
1553-
return builder->mcgraph()->machine()->TruncateFloat32ToInt32(
1554-
TruncateKind::kSetOverflowToMin);
15551553
case wasm::kExprI32SConvertSatF32:
1556-
return builder->mcgraph()->machine()->TruncateFloat32ToInt32(
1557-
TruncateKind::kArchitectureDefault);
1554+
return builder->mcgraph()->machine()->TruncateFloat32ToInt32();
15581555
case wasm::kExprI32UConvertF32:
1559-
return builder->mcgraph()->machine()->TruncateFloat32ToUint32(
1560-
TruncateKind::kSetOverflowToMin);
15611556
case wasm::kExprI32UConvertSatF32:
1562-
return builder->mcgraph()->machine()->TruncateFloat32ToUint32(
1563-
TruncateKind::kArchitectureDefault);
1557+
return builder->mcgraph()->machine()->TruncateFloat32ToUint32();
15641558
case wasm::kExprI32SConvertF64:
15651559
case wasm::kExprI32SConvertSatF64:
15661560
return builder->mcgraph()->machine()->ChangeFloat64ToInt32();
@@ -1759,9 +1753,6 @@ Node* WasmGraphBuilder::BuildIntConvertFloat(Node* input,
17591753
}
17601754
return converted_value;
17611755
}
1762-
if (mcgraph()->machine()->SatConversionIsSafe()) {
1763-
return converted_value;
1764-
}
17651756
Node* test = ConvertSaturateTest(this, opcode, int_ty, float_ty, trunc,
17661757
converted_value);
17671758
Diamond tl_d(graph(), mcgraph()->common(), test, BranchHint::kFalse);

0 commit comments

Comments
 (0)