AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[ptr-compr] Remove Compressed mentions from in the pipeline

Browse Source 
Including but not limiting to removing:
 * BitcastCompressedXXX
 * CheckedCompressedXXX
 * ChangeXXXToCompressedYYY
 * ChangeCompressedXXX

As a note, ChangeTaggedToCompressed can't be removed just yet as it
is still in use.

Bug: v8:7703
Change-Id: I98cf88a32adfa976d419e69702d1cac4d3e811a5
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1903435
Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Cr-Commit-Position: refs/heads/master@{#64880}
This commit is contained in:
Santiago Aboy Solanes 2019-11-11 11:36:04 +00:00 committed by Commit Bot
parent 9d2629c8b7
commit 6e90f2f292
31 changed files with 60 additions and 1271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

81
src/compiler/backend/arm64/instruction-selector-arm64.cc
View File

@ -1698,87 +1698,6 @@ void InstructionSelector::VisitChangeTaggedToCompressed(Node* node) {
EmitIdentity(node);
}
void InstructionSelector::VisitChangeTaggedPointerToCompressedPointer(
Node* node) {
// The top 32 bits in the 64-bit register will be undefined, and
// must not be used by a dependent node.
EmitIdentity(node);
}
void InstructionSelector::VisitChangeTaggedSignedToCompressedSigned(
Node* node) {
// The top 32 bits in the 64-bit register will be undefined, and
// must not be used by a dependent node.
EmitIdentity(node);
}
void InstructionSelector::VisitChangeCompressedToTagged(Node* node) {
Arm64OperandGenerator g(this);
Node* const value = node->InputAt(0);
if ((value->opcode() == IrOpcode::kLoad ||
value->opcode() == IrOpcode::kPoisonedLoad) &&
CanCover(node, value)) {
DCHECK_EQ(LoadRepresentationOf(value->op()).representation(),
MachineRepresentation::kCompressed);
InstructionCode opcode = kArm64LdrDecompressAnyTagged;
if (value->opcode() == IrOpcode::kPoisonedLoad) {
CHECK_NE(poisoning_level_, PoisoningMitigationLevel::kDontPoison);
opcode |= MiscField::encode(kMemoryAccessPoisoned);
}
ImmediateMode immediate_mode = kLoadStoreImm32;
MachineRepresentation rep = MachineRepresentation::kCompressed;
EmitLoad(this, value, opcode, immediate_mode, rep, node);
} else {
Emit(kArm64DecompressAny, g.DefineAsRegister(node), g.UseRegister(value));
}
}
void InstructionSelector::VisitChangeCompressedPointerToTaggedPointer(
Node* node) {
Arm64OperandGenerator g(this);
Node* const value = node->InputAt(0);
if ((value->opcode() == IrOpcode::kLoad ||
value->opcode() == IrOpcode::kPoisonedLoad) &&
CanCover(node, value)) {
DCHECK_EQ(LoadRepresentationOf(value->op()).representation(),
MachineRepresentation::kCompressedPointer);
InstructionCode opcode = kArm64LdrDecompressTaggedPointer;
if (value->opcode() == IrOpcode::kPoisonedLoad) {
CHECK_NE(poisoning_level_, PoisoningMitigationLevel::kDontPoison);
opcode |= MiscField::encode(kMemoryAccessPoisoned);
}
ImmediateMode immediate_mode = kLoadStoreImm32;
MachineRepresentation rep = MachineRepresentation::kCompressedPointer;
EmitLoad(this, value, opcode, immediate_mode, rep, node);
} else {
Emit(kArm64DecompressPointer, g.DefineAsRegister(node),
g.UseRegister(value));
}
}
void InstructionSelector::VisitChangeCompressedSignedToTaggedSigned(
Node* node) {
Arm64OperandGenerator g(this);
Node* const value = node->InputAt(0);
if ((value->opcode() == IrOpcode::kLoad ||
value->opcode() == IrOpcode::kPoisonedLoad) &&
CanCover(node, value)) {
DCHECK_EQ(LoadRepresentationOf(value->op()).representation(),
MachineRepresentation::kCompressedSigned);
InstructionCode opcode = kArm64LdrDecompressTaggedSigned;
if (value->opcode() == IrOpcode::kPoisonedLoad) {
CHECK_NE(poisoning_level_, PoisoningMitigationLevel::kDontPoison);
opcode |= MiscField::encode(kMemoryAccessPoisoned);
}
ImmediateMode immediate_mode = kLoadStoreImm32;
MachineRepresentation rep = MachineRepresentation::kCompressedSigned;
EmitLoad(this, value, opcode, immediate_mode, rep, node);
} else {
Emit(kArm64DecompressSigned, g.DefineAsRegister(node),
g.UseRegister(value));
}
}
void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
Arm64OperandGenerator g(this);
// The top 32 bits in the 64-bit register will be undefined, and

52
src/compiler/backend/instruction-selector.cc
View File

@ -1531,12 +1531,6 @@ void InstructionSelector::VisitNode(Node* node) {
case IrOpcode::kBitcastWordToTaggedSigned:
return MarkAsRepresentation(MachineRepresentation::kTaggedSigned, node),
EmitIdentity(node);
case IrOpcode::kBitcastWord32ToCompressedSigned:
return MarkAsRepresentation(MachineRepresentation::kCompressedSigned,
node),
EmitIdentity(node);
case IrOpcode::kBitcastCompressedSignedToWord32:
return MarkAsWord32(node), EmitIdentity(node);
case IrOpcode::kChangeFloat32ToFloat64:
return MarkAsFloat64(node), VisitChangeFloat32ToFloat64(node);
case IrOpcode::kChangeInt32ToFloat64:
@ -1580,27 +1574,8 @@ void InstructionSelector::VisitNode(Node* node) {
return MarkAsWord64(node), VisitChangeInt32ToInt64(node);
case IrOpcode::kChangeUint32ToUint64:
return MarkAsWord64(node), VisitChangeUint32ToUint64(node);
// TODO(mips-team): Support compress pointers.
#ifdef V8_COMPRESS_POINTERS
case IrOpcode::kChangeTaggedToCompressed:
return MarkAsCompressed(node), VisitChangeTaggedToCompressed(node);
case IrOpcode::kChangeTaggedPointerToCompressedPointer:
return MarkAsRepresentation(MachineRepresentation::kCompressedPointer,
node),
VisitChangeTaggedPointerToCompressedPointer(node);
case IrOpcode::kChangeTaggedSignedToCompressedSigned:
return MarkAsRepresentation(MachineRepresentation::kCompressedSigned,
node),
VisitChangeTaggedSignedToCompressedSigned(node);
case IrOpcode::kChangeCompressedToTagged:
return MarkAsTagged(node), VisitChangeCompressedToTagged(node);
case IrOpcode::kChangeCompressedPointerToTaggedPointer:
return MarkAsRepresentation(MachineRepresentation::kTaggedPointer, node),
VisitChangeCompressedPointerToTaggedPointer(node);
case IrOpcode::kChangeCompressedSignedToTaggedSigned:
return MarkAsRepresentation(MachineRepresentation::kTaggedSigned, node),
VisitChangeCompressedSignedToTaggedSigned(node);
#endif
case IrOpcode::kTruncateFloat64ToFloat32:
return MarkAsFloat32(node), VisitTruncateFloat64ToFloat32(node);
case IrOpcode::kTruncateFloat64ToWord32:
@ -2474,37 +2449,10 @@ void InstructionSelector::VisitChangeUint32ToUint64(Node* node) {
UNIMPLEMENTED();
}
// TODO(mips-team): Support compress pointers.
#ifdef V8_COMPRESS_POINTERS
void InstructionSelector::VisitChangeTaggedToCompressed(Node* node) {
UNIMPLEMENTED();
}
void InstructionSelector::VisitChangeTaggedPointerToCompressedPointer(
Node* node) {
UNIMPLEMENTED();
}
void InstructionSelector::VisitChangeTaggedSignedToCompressedSigned(
Node* node) {
UNIMPLEMENTED();
}
void InstructionSelector::VisitChangeCompressedToTagged(Node* node) {
UNIMPLEMENTED();
}
void InstructionSelector::VisitChangeCompressedPointerToTaggedPointer(
Node* node) {
UNIMPLEMENTED();
}
void InstructionSelector::VisitChangeCompressedSignedToTaggedSigned(
Node* node) {
UNIMPLEMENTED();
}
#endif
void InstructionSelector::VisitChangeFloat64ToInt64(Node* node) {
UNIMPLEMENTED();
}

58
src/compiler/backend/x64/instruction-selector-x64.cc
View File

@ -1329,64 +1329,6 @@ void InstructionSelector::VisitChangeTaggedToCompressed(Node* node) {
return EmitIdentity(node);
}
void InstructionSelector::VisitChangeTaggedPointerToCompressedPointer(
Node* node) {
// The top 32 bits in the 64-bit register will be undefined, and
// must not be used by a dependent node.
return EmitIdentity(node);
}
void InstructionSelector::VisitChangeTaggedSignedToCompressedSigned(
Node* node) {
// The top 32 bits in the 64-bit register will be undefined, and
// must not be used by a dependent node.
return EmitIdentity(node);
}
void InstructionSelector::VisitChangeCompressedToTagged(Node* node) {
Node* const value = node->InputAt(0);
if ((value->opcode() == IrOpcode::kLoad ||
value->opcode() == IrOpcode::kPoisonedLoad) &&
CanCover(node, value)) {
DCHECK_EQ(LoadRepresentationOf(value->op()).representation(),
MachineRepresentation::kCompressed);
VisitLoad(node, value, kX64MovqDecompressAnyTagged);
} else {
X64OperandGenerator g(this);
Emit(kX64DecompressAny, g.DefineAsRegister(node), g.Use(value));
}
}
void InstructionSelector::VisitChangeCompressedPointerToTaggedPointer(
Node* node) {
Node* const value = node->InputAt(0);
if ((value->opcode() == IrOpcode::kLoad ||
value->opcode() == IrOpcode::kPoisonedLoad) &&
CanCover(node, value)) {
DCHECK_EQ(LoadRepresentationOf(value->op()).representation(),
MachineRepresentation::kCompressedPointer);
VisitLoad(node, value, kX64MovqDecompressTaggedPointer);
} else {
X64OperandGenerator g(this);
Emit(kX64DecompressPointer, g.DefineAsRegister(node), g.Use(value));
}
}
void InstructionSelector::VisitChangeCompressedSignedToTaggedSigned(
Node* node) {
Node* const value = node->InputAt(0);
if ((value->opcode() == IrOpcode::kLoad ||
value->opcode() == IrOpcode::kPoisonedLoad) &&
CanCover(node, value)) {
DCHECK_EQ(LoadRepresentationOf(value->op()).representation(),
MachineRepresentation::kCompressedSigned);
VisitLoad(node, value, kX64MovqDecompressTaggedSigned);
} else {
X64OperandGenerator g(this);
Emit(kX64DecompressSigned, g.DefineAsRegister(node), g.Use(value));
}
}
namespace {
void VisitRO(InstructionSelector* selector, Node* node,

160
src/compiler/effect-control-linearizer.cc
View File

@ -56,7 +56,6 @@ class EffectControlLinearizer {
bool TryWireInStateEffect(Node* node, Node* frame_state);
Node* LowerChangeBitToTagged(Node* node);
Node* LowerChangeInt31ToCompressedSigned(Node* node);
Node* LowerChangeInt31ToTaggedSigned(Node* node);
Node* LowerChangeInt32ToTagged(Node* node);
Node* LowerChangeInt64ToTagged(Node* node);
@ -64,7 +63,6 @@ class EffectControlLinearizer {
Node* LowerChangeUint64ToTagged(Node* node);
Node* LowerChangeFloat64ToTagged(Node* node);
Node* LowerChangeFloat64ToTaggedPointer(Node* node);
Node* LowerChangeCompressedSignedToInt32(Node* node);
Node* LowerChangeTaggedSignedToInt32(Node* node);
Node* LowerChangeTaggedSignedToInt64(Node* node);
Node* LowerChangeTaggedToBit(Node* node);
@ -72,8 +70,6 @@ class EffectControlLinearizer {
Node* LowerChangeTaggedToUint32(Node* node);
Node* LowerChangeTaggedToInt64(Node* node);
Node* LowerChangeTaggedToTaggedSigned(Node* node);
Node* LowerChangeCompressedToTaggedSigned(Node* node);
Node* LowerChangeTaggedToCompressedSigned(Node* node);
Node* LowerPoisonIndex(Node* node);
Node* LowerCheckInternalizedString(Node* node, Node* frame_state);
void LowerCheckMaps(Node* node, Node* frame_state);
@ -92,7 +88,6 @@ class EffectControlLinearizer {
Node* LowerCheckedUint32Div(Node* node, Node* frame_state);
Node* LowerCheckedUint32Mod(Node* node, Node* frame_state);
Node* LowerCheckedInt32Mul(Node* node, Node* frame_state);
Node* LowerCheckedInt32ToCompressedSigned(Node* node, Node* frame_state);
Node* LowerCheckedInt32ToTaggedSigned(Node* node, Node* frame_state);
Node* LowerCheckedInt64ToInt32(Node* node, Node* frame_state);
Node* LowerCheckedInt64ToTaggedSigned(Node* node, Node* frame_state);
@ -114,10 +109,6 @@ class EffectControlLinearizer {
Node* LowerBigIntAsUintN(Node* node, Node* frame_state);
Node* LowerChangeUint64ToBigInt(Node* node);
Node* LowerTruncateBigIntToUint64(Node* node);
Node* LowerCheckedCompressedToTaggedSigned(Node* node, Node* frame_state);
Node* LowerCheckedCompressedToTaggedPointer(Node* node, Node* frame_state);
Node* LowerCheckedTaggedToCompressedSigned(Node* node, Node* frame_state);
Node* LowerCheckedTaggedToCompressedPointer(Node* node, Node* frame_state);
Node* LowerChangeTaggedToFloat64(Node* node);
void TruncateTaggedPointerToBit(Node* node, GraphAssemblerLabel<1>* done);
Node* LowerTruncateTaggedToBit(Node* node);
@ -236,7 +227,6 @@ class EffectControlLinearizer {
Node* BuildTypedArrayDataPointer(Node* base, Node* external);
Node* ChangeInt32ToCompressedSmi(Node* value);
Node* ChangeInt32ToSmi(Node* value);
Node* ChangeInt32ToIntPtr(Node* value);
Node* ChangeInt64ToSmi(Node* value);
@ -245,7 +235,6 @@ class EffectControlLinearizer {
Node* ChangeUint32ToUintPtr(Node* value);
Node* ChangeUint32ToSmi(Node* value);
Node* ChangeSmiToIntPtr(Node* value);
Node* ChangeCompressedSmiToInt32(Node* value);
Node* ChangeSmiToInt32(Node* value);
Node* ChangeSmiToInt64(Node* value);
Node* ObjectIsSmi(Node* value);
@ -843,9 +832,6 @@ bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
case IrOpcode::kChangeBitToTagged:
result = LowerChangeBitToTagged(node);
break;
case IrOpcode::kChangeInt31ToCompressedSigned:
result = LowerChangeInt31ToCompressedSigned(node);
break;
case IrOpcode::kChangeInt31ToTaggedSigned:
result = LowerChangeInt31ToTaggedSigned(node);
break;
@ -867,9 +853,6 @@ bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
case IrOpcode::kChangeFloat64ToTaggedPointer:
result = LowerChangeFloat64ToTaggedPointer(node);
break;
case IrOpcode::kChangeCompressedSignedToInt32:
result = LowerChangeCompressedSignedToInt32(node);
break;
case IrOpcode::kChangeTaggedSignedToInt32:
result = LowerChangeTaggedSignedToInt32(node);
break;
@ -894,12 +877,6 @@ bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
case IrOpcode::kChangeTaggedToTaggedSigned:
result = LowerChangeTaggedToTaggedSigned(node);
break;
case IrOpcode::kChangeCompressedToTaggedSigned:
result = LowerChangeCompressedToTaggedSigned(node);
break;
case IrOpcode::kChangeTaggedToCompressedSigned:
result = LowerChangeTaggedToCompressedSigned(node);
break;
case IrOpcode::kTruncateTaggedToBit:
result = LowerTruncateTaggedToBit(node);
break;
@ -963,9 +940,6 @@ bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
case IrOpcode::kCheckedInt32Mul:
result = LowerCheckedInt32Mul(node, frame_state);
break;
case IrOpcode::kCheckedInt32ToCompressedSigned:
result = LowerCheckedInt32ToCompressedSigned(node, frame_state);
break;
case IrOpcode::kCheckedInt32ToTaggedSigned:
result = LowerCheckedInt32ToTaggedSigned(node, frame_state);
break;
@ -1033,18 +1007,6 @@ bool EffectControlLinearizer::TryWireInStateEffect(Node* node,
case IrOpcode::kTruncateBigIntToUint64:
result = LowerTruncateBigIntToUint64(node);
break;
case IrOpcode::kCheckedCompressedToTaggedSigned:
result = LowerCheckedCompressedToTaggedSigned(node, frame_state);
break;
case IrOpcode::kCheckedCompressedToTaggedPointer:
result = LowerCheckedCompressedToTaggedPointer(node, frame_state);
break;
case IrOpcode::kCheckedTaggedToCompressedSigned:
result = LowerCheckedTaggedToCompressedSigned(node, frame_state);
break;
case IrOpcode::kCheckedTaggedToCompressedPointer:
result = LowerCheckedTaggedToCompressedPointer(node, frame_state);
break;
case IrOpcode::kTruncateTaggedToWord32:
result = LowerTruncateTaggedToWord32(node);
break;
@ -1417,11 +1379,6 @@ Node* EffectControlLinearizer::LowerChangeBitToTagged(Node* node) {
return done.PhiAt(0);
}
Node* EffectControlLinearizer::LowerChangeInt31ToCompressedSigned(Node* node) {
Node* value = node->InputAt(0);
return ChangeInt32ToCompressedSmi(value);
}
Node* EffectControlLinearizer::LowerChangeInt31ToTaggedSigned(Node* node) {
Node* value = node->InputAt(0);
return ChangeInt32ToSmi(value);
@ -1526,11 +1483,6 @@ Node* EffectControlLinearizer::LowerChangeTaggedSignedToInt32(Node* node) {
return ChangeSmiToInt32(value);
}
Node* EffectControlLinearizer::LowerChangeCompressedSignedToInt32(Node* node) {
Node* value = node->InputAt(0);
return ChangeCompressedSmiToInt32(value);
}
Node* EffectControlLinearizer::LowerChangeTaggedSignedToInt64(Node* node) {
Node* value = node->InputAt(0);
return ChangeSmiToInt64(value);
@ -1718,49 +1670,6 @@ Node* EffectControlLinearizer::LowerChangeTaggedToTaggedSigned(Node* node) {
return done.PhiAt(0);
}
Node* EffectControlLinearizer::LowerChangeCompressedToTaggedSigned(Node* node) {
Node* value = node->InputAt(0);
auto if_not_smi = __ MakeDeferredLabel();
auto done = __ MakeLabel(MachineRepresentation::kWord32);
Node* check = ObjectIsSmi(value);
__ GotoIfNot(check, &if_not_smi);
__ Goto(&done, __ ChangeCompressedSignedToTaggedSigned(value));
__ Bind(&if_not_smi);
STATIC_ASSERT(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset);
Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(),
__ ChangeCompressedToTagged(value));
vfalse = __ ChangeFloat64ToInt32(vfalse);
vfalse = ChangeInt32ToSmi(vfalse);
__ Goto(&done, vfalse);
__ Bind(&done);
return done.PhiAt(0);
}
Node* EffectControlLinearizer::LowerChangeTaggedToCompressedSigned(Node* node) {
Node* value = node->InputAt(0);
auto if_not_smi = __ MakeDeferredLabel();
auto done = __ MakeLabel(MachineRepresentation::kWord32);
Node* check = ObjectIsSmi(value);
__ GotoIfNot(check, &if_not_smi);
__ Goto(&done, __ ChangeTaggedSignedToCompressedSigned(value));
__ Bind(&if_not_smi);
STATIC_ASSERT(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset);
Node* vfalse = __ LoadField(AccessBuilder::ForHeapNumberValue(), value);
vfalse = __ ChangeFloat64ToInt32(vfalse);
vfalse = ChangeInt32ToCompressedSmi(vfalse);
__ Goto(&done, vfalse);
__ Bind(&done);
return done.PhiAt(0);
}
Node* EffectControlLinearizer::LowerTruncateTaggedToFloat64(Node* node) {
Node* value = node->InputAt(0);
@ -2350,19 +2259,6 @@ Node* EffectControlLinearizer::LowerCheckedInt32Mul(Node* node,
return value;
}
Node* EffectControlLinearizer::LowerCheckedInt32ToCompressedSigned(
Node* node, Node* frame_state) {
DCHECK(SmiValuesAre31Bits());
Node* value = node->InputAt(0);
const CheckParameters& params = CheckParametersOf(node->op());
Node* add = __ Int32AddWithOverflow(value, value);
Node* check = __ Projection(1, add);
__ DeoptimizeIf(DeoptimizeReason::kLostPrecision, params.feedback(), check,
frame_state);
return __ Projection(0, add);
}
Node* EffectControlLinearizer::LowerCheckedInt32ToTaggedSigned(
Node* node, Node* frame_state) {
DCHECK(SmiValuesAre31Bits());
@ -2878,52 +2774,6 @@ Node* EffectControlLinearizer::LowerTruncateBigIntToUint64(Node* node) {
return done.PhiAt(0);
}
Node* EffectControlLinearizer::LowerCheckedCompressedToTaggedSigned(
Node* node, Node* frame_state) {
Node* value = node->InputAt(0);
const CheckParameters& params = CheckParametersOf(node->op());
Node* check = ObjectIsSmi(value);
__ DeoptimizeIfNot(DeoptimizeReason::kNotASmi, params.feedback(), check,
frame_state);
return __ ChangeCompressedSignedToTaggedSigned(value);
}
Node* EffectControlLinearizer::LowerCheckedCompressedToTaggedPointer(
Node* node, Node* frame_state) {
Node* value = node->InputAt(0);
const CheckParameters& params = CheckParametersOf(node->op());
Node* check = ObjectIsSmi(value);
__ DeoptimizeIf(DeoptimizeReason::kSmi, params.feedback(), check,
frame_state);
return __ ChangeCompressedPointerToTaggedPointer(value);
}
Node* EffectControlLinearizer::LowerCheckedTaggedToCompressedSigned(
Node* node, Node* frame_state) {
Node* value = node->InputAt(0);
const CheckParameters& params = CheckParametersOf(node->op());
Node* check = ObjectIsSmi(value);
__ DeoptimizeIfNot(DeoptimizeReason::kNotASmi, params.feedback(), check,
frame_state);
return __ ChangeTaggedSignedToCompressedSigned(value);
}
Node* EffectControlLinearizer::LowerCheckedTaggedToCompressedPointer(
Node* node, Node* frame_state) {
Node* value = node->InputAt(0);
const CheckParameters& params = CheckParametersOf(node->op());
Node* check = ObjectIsSmi(value);
__ DeoptimizeIf(DeoptimizeReason::kSmi, params.feedback(), check,
frame_state);
return __ ChangeTaggedPointerToCompressedPointer(value);
}
Node* EffectControlLinearizer::LowerTruncateTaggedToWord32(Node* node) {
Node* value = node->InputAt(0);
@ -4524,11 +4374,6 @@ Node* EffectControlLinearizer::ChangeIntPtrToInt32(Node* value) {
return value;
}
Node* EffectControlLinearizer::ChangeInt32ToCompressedSmi(Node* value) {
CHECK(machine()->Is64() && SmiValuesAre31Bits());
return __ Word32Shl(value, SmiShiftBitsConstant());
}
Node* EffectControlLinearizer::ChangeInt32ToSmi(Node* value) {
// Do shift on 32bit values if Smis are stored in the lower word.
if (machine()->Is64() && SmiValuesAre31Bits()) {
@ -4578,11 +4423,6 @@ Node* EffectControlLinearizer::ChangeSmiToInt32(Node* value) {
return ChangeSmiToIntPtr(value);
}
Node* EffectControlLinearizer::ChangeCompressedSmiToInt32(Node* value) {
CHECK(machine()->Is64() && SmiValuesAre31Bits());
return __ Word32Sar(value, SmiShiftBitsConstant());
}
Node* EffectControlLinearizer::ChangeSmiToInt64(Node* value) {
CHECK(machine()->Is64());
return ChangeSmiToIntPtr(value);

54
src/compiler/graph-assembler.h
View File

@ -21,35 +21,31 @@ namespace compiler {
class Schedule;
class BasicBlock;
#define PURE_ASSEMBLER_MACH_UNOP_LIST(V) \
V(ChangeInt32ToInt64) \
V(ChangeInt32ToFloat64) \
V(ChangeInt64ToFloat64) \
V(ChangeUint32ToFloat64) \
V(ChangeUint32ToUint64) \
V(ChangeFloat64ToInt32) \
V(ChangeFloat64ToInt64) \
V(ChangeFloat64ToUint32) \
V(TruncateInt64ToInt32) \
V(RoundFloat64ToInt32) \
V(TruncateFloat64ToInt64) \
V(TruncateFloat64ToWord32) \
V(Float64ExtractLowWord32) \
V(Float64ExtractHighWord32) \
V(BitcastInt32ToFloat32) \
V(BitcastInt64ToFloat64) \
V(BitcastFloat32ToInt32) \
V(BitcastFloat64ToInt64) \
V(Float64Abs) \
V(Word32ReverseBytes) \
V(Word64ReverseBytes) \
V(Float64SilenceNaN) \
V(ChangeCompressedToTagged) \
V(ChangeTaggedToCompressed) \
V(ChangeTaggedSignedToCompressedSigned) \
V(ChangeCompressedSignedToTaggedSigned) \
V(ChangeTaggedPointerToCompressedPointer) \
V(ChangeCompressedPointerToTaggedPointer)
#define PURE_ASSEMBLER_MACH_UNOP_LIST(V) \
V(ChangeInt32ToInt64) \
V(ChangeInt32ToFloat64) \
V(ChangeInt64ToFloat64) \
V(ChangeUint32ToFloat64) \
V(ChangeUint32ToUint64) \
V(ChangeFloat64ToInt32) \
V(ChangeFloat64ToInt64) \
V(ChangeFloat64ToUint32) \
V(TruncateInt64ToInt32) \
V(RoundFloat64ToInt32) \
V(TruncateFloat64ToInt64) \
V(TruncateFloat64ToWord32) \
V(Float64ExtractLowWord32) \
V(Float64ExtractHighWord32) \
V(BitcastInt32ToFloat32) \
V(BitcastInt64ToFloat64) \
V(BitcastFloat32ToInt32) \
V(BitcastFloat64ToInt64) \
V(Float64Abs) \
V(Word32ReverseBytes) \
V(Word64ReverseBytes) \
V(Float64SilenceNaN) \
V(ChangeTaggedToCompressed)
#define PURE_ASSEMBLER_MACH_BINOP_LIST(V) \
V(WordShl) \
V(WordSar) \

22
src/compiler/js-native-context-specialization.cc
View File

@ -748,11 +748,9 @@ FieldAccess ForPropertyCellValue(MachineRepresentation representation,
Type type, MaybeHandle<Map> map,
NameRef const& name) {
WriteBarrierKind kind = kFullWriteBarrier;
if (representation == MachineRepresentation::kTaggedSigned ||
representation == MachineRepresentation::kCompressedSigned) {
if (representation == MachineRepresentation::kTaggedSigned) {
kind = kNoWriteBarrier;
} else if (representation == MachineRepresentation::kTaggedPointer ||
representation == MachineRepresentation::kCompressedPointer) {
} else if (representation == MachineRepresentation::kTaggedPointer) {
kind = kPointerWriteBarrier;
}
MachineType r = MachineType::TypeForRepresentation(representation);
@ -2396,9 +2394,6 @@ JSNativeContextSpecialization::BuildPropertyStore(
case MachineRepresentation::kTaggedSigned:
case MachineRepresentation::kTaggedPointer:
case MachineRepresentation::kTagged:
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
if (store_to_existing_constant_field) {
DCHECK(!access_info.HasTransitionMap());
// If the field is constant check that the value we are going
@ -2414,16 +2409,13 @@ JSNativeContextSpecialization::BuildPropertyStore(
return ValueEffectControl(value, effect, control);
}
if (field_representation == MachineRepresentation::kTaggedSigned ||
field_representation == MachineRepresentation::kCompressedSigned) {
if (field_representation == MachineRepresentation::kTaggedSigned) {
value = effect = graph()->NewNode(
simplified()->CheckSmi(FeedbackSource()), value, effect, control);
field_access.write_barrier_kind = kNoWriteBarrier;
} else if (field_representation ==
MachineRepresentation::kTaggedPointer ||
field_representation ==
MachineRepresentation::kCompressedPointer) {
MachineRepresentation::kTaggedPointer) {
Handle<Map> field_map;
if (access_info.field_map().ToHandle(&field_map)) {
// Emit a map check for the value.
@ -2439,12 +2431,14 @@ JSNativeContextSpecialization::BuildPropertyStore(
field_access.write_barrier_kind = kPointerWriteBarrier;
} else {
DCHECK(field_representation == MachineRepresentation::kTagged ||
field_representation == MachineRepresentation::kCompressed);
DCHECK(field_representation == MachineRepresentation::kTagged);
}
break;
case MachineRepresentation::kNone:
case MachineRepresentation::kBit:
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
case MachineRepresentation::kWord8:
case MachineRepresentation::kWord16:
case MachineRepresentation::kWord32:

12
src/compiler/load-elimination.cc
View File

@ -1069,6 +1069,9 @@ Reduction LoadElimination::ReduceLoadElement(Node* node) {
case MachineRepresentation::kWord32:
case MachineRepresentation::kWord64:
case MachineRepresentation::kFloat32:
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
// TODO(turbofan): Add support for doing the truncations.
break;
case MachineRepresentation::kFloat64:
@ -1076,9 +1079,6 @@ Reduction LoadElimination::ReduceLoadElement(Node* node) {
case MachineRepresentation::kTaggedSigned:
case MachineRepresentation::kTaggedPointer:
case MachineRepresentation::kTagged:
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
if (Node* replacement = state->LookupElement(
object, index, access.machine_type.representation())) {
// Make sure we don't resurrect dead {replacement} nodes.
@ -1124,6 +1124,9 @@ Reduction LoadElimination::ReduceStoreElement(Node* node) {
case MachineRepresentation::kWord32:
case MachineRepresentation::kWord64:
case MachineRepresentation::kFloat32:
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
// TODO(turbofan): Add support for doing the truncations.
break;
case MachineRepresentation::kFloat64:
@ -1131,9 +1134,6 @@ Reduction LoadElimination::ReduceStoreElement(Node* node) {
case MachineRepresentation::kTaggedSigned:
case MachineRepresentation::kTaggedPointer:
case MachineRepresentation::kTagged:
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
state = state->AddElement(object, index, new_value,
access.machine_type.representation(), zone());
break;

59
src/compiler/machine-graph-verifier.cc
View File

@ -194,6 +194,9 @@ class MachineRepresentationInferrer {
UnalignedStoreRepresentationOf(node->op()));
break;
case IrOpcode::kHeapConstant:
representation_vector_[node->id()] =
MachineRepresentation::kTaggedPointer;
break;
case IrOpcode::kNumberConstant:
case IrOpcode::kDelayedStringConstant:
case IrOpcode::kChangeBitToTagged:
@ -203,29 +206,12 @@ class MachineRepresentationInferrer {
case IrOpcode::kChangeUint32ToTagged:
case IrOpcode::kBitcastWordToTagged:
case IrOpcode::kTaggedPoisonOnSpeculation:
case IrOpcode::kChangeCompressedToTagged:
representation_vector_[node->id()] = MachineRepresentation::kTagged;
break;
case IrOpcode::kChangeCompressedPointerToTaggedPointer:
representation_vector_[node->id()] =
MachineRepresentation::kTaggedPointer;
break;
case IrOpcode::kChangeCompressedSignedToTaggedSigned:
representation_vector_[node->id()] =
MachineRepresentation::kTaggedSigned;
break;
case IrOpcode::kChangeTaggedToCompressed:
representation_vector_[node->id()] =
MachineRepresentation::kCompressed;
break;
case IrOpcode::kChangeTaggedPointerToCompressedPointer:
representation_vector_[node->id()] =
MachineRepresentation::kCompressedPointer;
break;
case IrOpcode::kChangeTaggedSignedToCompressedSigned:
representation_vector_[node->id()] =
MachineRepresentation::kCompressedSigned;
break;
case IrOpcode::kWord32PoisonOnSpeculation:
representation_vector_[node->id()] = MachineRepresentation::kWord32;
break;
@ -249,13 +235,6 @@ class MachineRepresentationInferrer {
representation_vector_[node->id()] =
MachineRepresentation::kTaggedSigned;
break;
case IrOpcode::kBitcastWord32ToCompressedSigned:
representation_vector_[node->id()] =
MachineRepresentation::kCompressedSigned;
break;
case IrOpcode::kBitcastCompressedSignedToWord32:
representation_vector_[node->id()] = MachineRepresentation::kWord32;
break;
case IrOpcode::kWord32Equal:
case IrOpcode::kInt32LessThan:
case IrOpcode::kInt32LessThanOrEqual:
@ -393,29 +372,9 @@ class MachineRepresentationChecker {
CHECK_EQ(MachineRepresentation::kTagged,
inferrer_->GetRepresentation(node->InputAt(0)));
break;
case IrOpcode::kChangeCompressedToTagged:
CHECK(IsAnyCompressed(
inferrer_->GetRepresentation(node->InputAt(0))));
break;
case IrOpcode::kChangeCompressedPointerToTaggedPointer:
CHECK(CanBeCompressedPointer(
inferrer_->GetRepresentation(node->InputAt(0))));
break;
case IrOpcode::kChangeCompressedSignedToTaggedSigned:
CHECK(CanBeCompressedSigned(
inferrer_->GetRepresentation(node->InputAt(0))));
break;
case IrOpcode::kChangeTaggedToCompressed:
CheckValueInputIsCompressedOrTagged(node, 0);
break;
case IrOpcode::kChangeTaggedPointerToCompressedPointer:
CHECK(CanBeTaggedPointer(
inferrer_->GetRepresentation(node->InputAt(0))));
break;
case IrOpcode::kChangeTaggedSignedToCompressedSigned:
CHECK(CanBeTaggedSigned(
inferrer_->GetRepresentation(node->InputAt(0))));
break;
case IrOpcode::kRoundInt64ToFloat64:
case IrOpcode::kRoundUint64ToFloat64:
case IrOpcode::kRoundInt64ToFloat32:
@ -441,13 +400,6 @@ class MachineRepresentationChecker {
case IrOpcode::kTaggedPoisonOnSpeculation:
CheckValueInputIsTagged(node, 0);
break;
case IrOpcode::kBitcastWord32ToCompressedSigned:
CheckValueInputRepresentationIs(node, 0,
MachineRepresentation::kWord32);
break;
case IrOpcode::kBitcastCompressedSignedToWord32:
CheckValueInputIsCompressed(node, 0);
break;
case IrOpcode::kTruncateFloat64ToWord32:
case IrOpcode::kTruncateFloat64ToUint32:
case IrOpcode::kTruncateFloat64ToFloat32:
@ -626,11 +578,6 @@ class MachineRepresentationChecker {
CheckValueInputIsTagged(node, 2);
}
break;
case MachineRepresentation::kCompressed:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressedSigned:
CheckValueInputIsCompressed(node, 2);
break;
default:
CheckValueInputRepresentationIs(
node, 2, inferrer_->GetRepresentation(node));

23
src/compiler/machine-operator-reducer.cc
View File

@ -81,14 +81,6 @@ Node* MachineOperatorReducer::Word32Equal(Node* lhs, Node* rhs) {
return graph()->NewNode(machine()->Word32Equal(), lhs, rhs);
}
Node* MachineOperatorReducer::BitcastWord32ToCompressedSigned(Node* value) {
return graph()->NewNode(machine()->BitcastWord32ToCompressedSigned(), value);
}
Node* MachineOperatorReducer::BitcastCompressedSignedToWord32(Node* value) {
return graph()->NewNode(machine()->BitcastCompressedSignedToWord32(), value);
}
Node* MachineOperatorReducer::Int32Add(Node* lhs, Node* rhs) {
Node* const node = graph()->NewNode(machine()->Int32Add(), lhs, rhs);
Reduction const reduction = ReduceInt32Add(node);
@ -661,17 +653,6 @@ Reduction MachineOperatorReducer::Reduce(Node* node) {
if (m.HasValue()) return ReplaceInt64(static_cast<uint64_t>(m.Value()));
break;
}
case IrOpcode::kChangeTaggedToCompressed: {
Int64Matcher m(node->InputAt(0));
if (m.IsBitcastWordToTaggedSigned()) {
Int64Matcher n(m.node()->InputAt(0));
if (n.IsChangeInt32ToInt64()) {
DCHECK(machine()->Is64() && SmiValuesAre31Bits());
return Replace(BitcastWord32ToCompressedSigned(n.node()->InputAt(0)));
}
}
break;
}
case IrOpcode::kTruncateFloat64ToWord32: {
Float64Matcher m(node->InputAt(0));
if (m.HasValue()) return ReplaceInt32(DoubleToInt32(m.Value()));
@ -684,10 +665,6 @@ Reduction MachineOperatorReducer::Reduce(Node* node) {
if (m.IsChangeInt32ToInt64()) return Replace(m.node()->InputAt(0));
if (m.IsBitcastTaggedToWordForTagAndSmiBits()) {
Int64Matcher n(m.node()->InputAt(0));
if (n.IsChangeCompressedToTagged()) {
DCHECK(machine()->Is64() && SmiValuesAre31Bits());
return Replace(BitcastCompressedSignedToWord32(n.node()->InputAt(0)));
}
}
break;
}

2
src/compiler/machine-operator-reducer.h
View File

@ -51,8 +51,6 @@ class V8_EXPORT_PRIVATE MachineOperatorReducer final
Node* Word32Sar(Node* lhs, uint32_t rhs);
Node* Word32Shr(Node* lhs, uint32_t rhs);
Node* Word32Equal(Node* lhs, Node* rhs);
Node* BitcastWord32ToCompressedSigned(Node* value);
Node* BitcastCompressedSignedToWord32(Node* value);
Node* Int32Add(Node* lhs, Node* rhs);
Node* Int32Sub(Node* lhs, Node* rhs);
Node* Int32Mul(Node* lhs, Node* rhs);

7
src/compiler/machine-operator.cc
View File

@ -202,8 +202,6 @@ MachineType AtomicOpType(Operator const* op) {
V(Simd128ReverseBytes, Operator::kNoProperties, 1, 0, 1) \
V(BitcastTaggedToWordForTagAndSmiBits, Operator::kNoProperties, 1, 0, 1) \
V(BitcastWordToTaggedSigned, Operator::kNoProperties, 1, 0, 1) \
V(BitcastWord32ToCompressedSigned, Operator::kNoProperties, 1, 0, 1) \
V(BitcastCompressedSignedToWord32, Operator::kNoProperties, 1, 0, 1) \
V(TruncateFloat64ToWord32, Operator::kNoProperties, 1, 0, 1) \
V(ChangeFloat32ToFloat64, Operator::kNoProperties, 1, 0, 1) \
V(ChangeFloat64ToInt32, Operator::kNoProperties, 1, 0, 1) \
@ -232,11 +230,6 @@ MachineType AtomicOpType(Operator const* op) {
V(ChangeUint32ToFloat64, Operator::kNoProperties, 1, 0, 1) \
V(ChangeUint32ToUint64, Operator::kNoProperties, 1, 0, 1) \
V(ChangeTaggedToCompressed, Operator::kNoProperties, 1, 0, 1) \
V(ChangeTaggedPointerToCompressedPointer, Operator::kNoProperties, 1, 0, 1) \
V(ChangeTaggedSignedToCompressedSigned, Operator::kNoProperties, 1, 0, 1) \
V(ChangeCompressedToTagged, Operator::kNoProperties, 1, 0, 1) \
V(ChangeCompressedPointerToTaggedPointer, Operator::kNoProperties, 1, 0, 1) \
V(ChangeCompressedSignedToTaggedSigned, Operator::kNoProperties, 1, 0, 1) \
V(TruncateFloat64ToFloat32, Operator::kNoProperties, 1, 0, 1) \
V(TruncateInt64ToInt32, Operator::kNoProperties, 1, 0, 1) \
V(BitcastFloat32ToInt32, Operator::kNoProperties, 1, 0, 1) \

11
src/compiler/machine-operator.h
View File

@ -359,12 +359,6 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
// This operator reinterprets the bits of a word as a Smi.
const Operator* BitcastWordToTaggedSigned();
// This operator reinterprets the bits of a word32 as a Compressed Smi.
const Operator* BitcastWord32ToCompressedSigned();
// This operator reinterprets the bits of a Compressed Smi as a word32.
const Operator* BitcastCompressedSignedToWord32();
// JavaScript float64 to int32/uint32 truncation.
const Operator* TruncateFloat64ToWord32();
@ -392,11 +386,6 @@ class V8_EXPORT_PRIVATE MachineOperatorBuilder final
const Operator* ChangeUint32ToFloat64();
const Operator* ChangeUint32ToUint64();
const Operator* ChangeTaggedToCompressed();
const Operator* ChangeTaggedPointerToCompressedPointer();
const Operator* ChangeTaggedSignedToCompressedSigned();
const Operator* ChangeCompressedToTagged();
const Operator* ChangeCompressedPointerToTaggedPointer();
const Operator* ChangeCompressedSignedToTaggedSigned();
// These operators truncate or round numbers, both changing the representation
// of the number and mapping multiple input values onto the same output value.

3
src/compiler/memory-lowering.cc
View File

@ -401,10 +401,7 @@ bool ValueNeedsWriteBarrier(Node* value, Isolate* isolate) {
while (true) {
switch (value->opcode()) {
case IrOpcode::kBitcastWordToTaggedSigned:
case IrOpcode::kChangeTaggedSignedToCompressedSigned:
case IrOpcode::kChangeTaggedToCompressedSigned:
return false;
case IrOpcode::kChangeTaggedPointerToCompressedPointer:
case IrOpcode::kChangeTaggedToCompressed:
value = NodeProperties::GetValueInput(value, 0);
continue;

10
src/compiler/memory-optimizer.cc
View File

@ -24,11 +24,6 @@ bool CanAllocate(const Node* node) {
case IrOpcode::kAbortCSAAssert:
case IrOpcode::kBitcastTaggedToWord:
case IrOpcode::kBitcastWordToTagged:
case IrOpcode::kChangeCompressedPointerToTaggedPointer:
case IrOpcode::kChangeCompressedSignedToTaggedSigned:
case IrOpcode::kChangeCompressedToTagged:
case IrOpcode::kChangeTaggedPointerToCompressedPointer:
case IrOpcode::kChangeTaggedSignedToCompressedSigned:
case IrOpcode::kChangeTaggedToCompressed:
case IrOpcode::kComment:
case IrOpcode::kDebugBreak:
@ -245,7 +240,8 @@ void MemoryOptimizer::VisitNode(Node* node, AllocationState const* state) {
bool MemoryOptimizer::AllocationTypeNeedsUpdateToOld(Node* const node,
const Edge edge) {
if (COMPRESS_POINTERS_BOOL && IrOpcode::IsCompressOpcode(node->opcode())) {
if (COMPRESS_POINTERS_BOOL &&
node->opcode() == IrOpcode::kChangeTaggedToCompressed) {
// In Pointer Compression we might have a Compress node between an
// AllocateRaw and the value used as input. This case is trickier since we
// have to check all of the Compress node edges to test for a StoreField.
@ -291,7 +287,7 @@ void MemoryOptimizer::VisitAllocateRaw(Node* node,
// AllocateRaw and the value used as input. If so, we need to update
// child to point to the StoreField.
if (COMPRESS_POINTERS_BOOL &&
IrOpcode::IsCompressOpcode(child->opcode())) {
child->opcode() == IrOpcode::kChangeTaggedToCompressed) {
child = child->InputAt(0);
}

30
src/compiler/opcodes.h
View File

@ -234,7 +234,6 @@
// Opcodes for VirtuaMachine-level operators.
#define SIMPLIFIED_CHANGE_OP_LIST(V) \
V(ChangeCompressedSignedToInt32) \
V(ChangeTaggedSignedToInt32) \
V(ChangeTaggedSignedToInt64) \
V(ChangeTaggedToInt32) \
@ -242,9 +241,6 @@
V(ChangeTaggedToUint32) \
V(ChangeTaggedToFloat64) \
V(ChangeTaggedToTaggedSigned) \
V(ChangeCompressedToTaggedSigned) \
V(ChangeTaggedToCompressedSigned) \
V(ChangeInt31ToCompressedSigned) \
V(ChangeInt31ToTaggedSigned) \
V(ChangeInt32ToTagged) \
V(ChangeInt64ToTagged) \
@ -269,7 +265,6 @@
V(CheckedUint32Div) \
V(CheckedUint32Mod) \
V(CheckedInt32Mul) \
V(CheckedInt32ToCompressedSigned) \
V(CheckedInt32ToTaggedSigned) \
V(CheckedInt64ToInt32) \
V(CheckedInt64ToTaggedSigned) \
@ -288,11 +283,7 @@
V(CheckedTaggedToFloat64) \
V(CheckedTaggedToInt64) \
V(CheckedTaggedToTaggedSigned) \
V(CheckedTaggedToTaggedPointer) \
V(CheckedCompressedToTaggedSigned) \
V(CheckedCompressedToTaggedPointer) \
V(CheckedTaggedToCompressedSigned) \
V(CheckedTaggedToCompressedPointer)
V(CheckedTaggedToTaggedPointer)
#define SIMPLIFIED_COMPARE_BINOP_LIST(V) \
V(NumberEqual) \
@ -681,8 +672,6 @@
V(BitcastTaggedToWordForTagAndSmiBits) \
V(BitcastWordToTagged) \
V(BitcastWordToTaggedSigned) \
V(BitcastWord32ToCompressedSigned) \
V(BitcastCompressedSignedToWord32) \
V(TruncateFloat64ToWord32) \
V(ChangeFloat32ToFloat64) \
V(ChangeFloat64ToInt32) \
@ -704,11 +693,6 @@
V(ChangeUint32ToFloat64) \
V(ChangeUint32ToUint64) \
V(ChangeTaggedToCompressed) \
V(ChangeTaggedPointerToCompressedPointer) \
V(ChangeTaggedSignedToCompressedSigned) \
V(ChangeCompressedToTagged) \
V(ChangeCompressedPointerToTaggedPointer) \
V(ChangeCompressedSignedToTaggedSigned) \
V(TruncateFloat64ToFloat32) \
V(TruncateInt64ToInt32) \
V(RoundFloat64ToInt32) \
@ -1019,18 +1003,6 @@ class V8_EXPORT_PRIVATE IrOpcode {
(kWord32Equal <= value && value <= kFloat64LessThanOrEqual);
}
// Returns true if opcode for decompress operator.
static bool IsDecompressOpcode(Value value) {
return kChangeCompressedToTagged <= value &&
value <= kChangeCompressedSignedToTaggedSigned;
}
// Returns true if opcode for compress operator.
static bool IsCompressOpcode(Value value) {
return kChangeTaggedToCompressed <= value &&
value <= kChangeTaggedSignedToCompressedSigned;
}
static bool IsContextChainExtendingOpcode(Value value) {
return kJSCreateFunctionContext <= value && value <= kJSCreateBlockContext;
}

15
src/compiler/raw-machine-assembler.h
View File

@ -742,21 +742,6 @@ class V8_EXPORT_PRIVATE RawMachineAssembler {
Node* ChangeTaggedToCompressed(Node* a) {
return AddNode(machine()->ChangeTaggedToCompressed(), a);
}
Node* ChangeTaggedPointerToCompressedPointer(Node* a) {
return AddNode(machine()->ChangeTaggedPointerToCompressedPointer(), a);
}
Node* ChangeTaggedSignedToCompressedSigned(Node* a) {
return AddNode(machine()->ChangeTaggedSignedToCompressedSigned(), a);
}
Node* ChangeCompressedToTagged(Node* a) {
return AddNode(machine()->ChangeCompressedToTagged(), a);
}
Node* ChangeCompressedPointerToTaggedPointer(Node* a) {
return AddNode(machine()->ChangeCompressedPointerToTaggedPointer(), a);
}
Node* ChangeCompressedSignedToTaggedSigned(Node* a) {
return AddNode(machine()->ChangeCompressedSignedToTaggedSigned(), a);
}
Node* TruncateFloat64ToFloat32(Node* a) {
return AddNode(machine()->TruncateFloat64ToFloat32(), a);
}

5
src/compiler/redundancy-elimination.cc
View File

@ -157,7 +157,6 @@ bool CheckSubsumes(Node const* a, Node const* b) {
case IrOpcode::kCheckNumber:
case IrOpcode::kCheckBigInt:
break;
case IrOpcode::kCheckedInt32ToCompressedSigned:
case IrOpcode::kCheckedInt32ToTaggedSigned:
case IrOpcode::kCheckedInt64ToInt32:
case IrOpcode::kCheckedInt64ToTaggedSigned:
@ -165,10 +164,6 @@ bool CheckSubsumes(Node const* a, Node const* b) {
case IrOpcode::kCheckedTaggedToTaggedPointer:
case IrOpcode::kCheckedTaggedToTaggedSigned:
case IrOpcode::kCheckedTaggedToArrayIndex:
case IrOpcode::kCheckedCompressedToTaggedPointer:
case IrOpcode::kCheckedCompressedToTaggedSigned:
case IrOpcode::kCheckedTaggedToCompressedPointer:
case IrOpcode::kCheckedTaggedToCompressedSigned:
case IrOpcode::kCheckedUint32Bounds:
case IrOpcode::kCheckedUint32ToInt32:
case IrOpcode::kCheckedUint32ToTaggedSigned:

352
src/compiler/representation-change.cc
View File

@ -191,20 +191,6 @@ Node* RepresentationChanger::GetRepresentationFor(
DCHECK_EQ(TypeCheckKind::kNone, use_info.type_check());
return GetTaggedRepresentationFor(node, output_rep, output_type,
use_info.truncation());
case MachineRepresentation::kCompressedSigned:
DCHECK(use_info.type_check() == TypeCheckKind::kNone ||
use_info.type_check() == TypeCheckKind::kSignedSmall);
return GetCompressedSignedRepresentationFor(node, output_rep, output_type,
use_node, use_info);
case MachineRepresentation::kCompressedPointer:
DCHECK(use_info.type_check() == TypeCheckKind::kNone ||
use_info.type_check() == TypeCheckKind::kHeapObject);
return GetCompressedPointerRepresentationFor(
node, output_rep, output_type, use_node, use_info);
case MachineRepresentation::kCompressed:
DCHECK_EQ(TypeCheckKind::kNone, use_info.type_check());
return GetCompressedRepresentationFor(node, output_rep, output_type,
use_info.truncation());
case MachineRepresentation::kFloat32:
DCHECK_EQ(TypeCheckKind::kNone, use_info.type_check());
return GetFloat32RepresentationFor(node, output_rep, output_type,
@ -229,6 +215,10 @@ Node* RepresentationChanger::GetRepresentationFor(
case MachineRepresentation::kSimd128:
case MachineRepresentation::kNone:
return node;
case MachineRepresentation::kCompressed:
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
UNREACHABLE();
}
UNREACHABLE();
}
@ -368,17 +358,6 @@ Node* RepresentationChanger::GetTaggedSignedRepresentationFor(
return TypeError(node, output_rep, output_type,
MachineRepresentation::kTaggedSigned);
}
} else if (output_rep == MachineRepresentation::kCompressedSigned) {
op = machine()->ChangeCompressedSignedToTaggedSigned();
} else if (CanBeCompressedPointer(output_rep)) {
if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
op = simplified()->CheckedCompressedToTaggedSigned(use_info.feedback());
} else if (output_type.Is(Type::SignedSmall())) {
op = simplified()->ChangeCompressedToTaggedSigned();
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kTaggedSigned);
}
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kTaggedSigned);
@ -471,30 +450,6 @@ Node* RepresentationChanger::GetTaggedPointerRepresentationFor(
return node;
}
op = simplified()->CheckBigInt(use_info.feedback());
} else if (output_rep == MachineRepresentation::kCompressedPointer) {
if (use_info.type_check() == TypeCheckKind::kBigInt &&
!output_type.Is(Type::BigInt())) {
node = InsertChangeCompressedPointerToTaggedPointer(node);
op = simplified()->CheckBigInt(use_info.feedback());
} else {
op = machine()->ChangeCompressedPointerToTaggedPointer();
}
} else if (output_rep == MachineRepresentation::kCompressed &&
output_type.Is(Type::BigInt())) {
op = machine()->ChangeCompressedPointerToTaggedPointer();
} else if (output_rep == MachineRepresentation::kCompressed &&
use_info.type_check() == TypeCheckKind::kBigInt) {
node = InsertChangeCompressedToTagged(node);
op = simplified()->CheckBigInt(use_info.feedback());
} else if (CanBeCompressedSigned(output_rep) &&
use_info.type_check() == TypeCheckKind::kHeapObject) {
if (!output_type.Maybe(Type::SignedSmall())) {
op = machine()->ChangeCompressedPointerToTaggedPointer();
} else {
// TODO(turbofan): Consider adding a Bailout operator that just deopts
// for CompressedSigned output representation.
op = simplified()->CheckedCompressedToTaggedPointer(use_info.feedback());
}
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kTaggedPointer);
@ -610,12 +565,6 @@ Node* RepresentationChanger::GetTaggedRepresentationFor(
return TypeError(node, output_rep, output_type,
MachineRepresentation::kTagged);
}
} else if (output_rep == MachineRepresentation::kCompressedSigned) {
op = machine()->ChangeCompressedSignedToTaggedSigned();
} else if (output_rep == MachineRepresentation::kCompressedPointer) {
op = machine()->ChangeCompressedPointerToTaggedPointer();
} else if (output_rep == MachineRepresentation::kCompressed) {
op = machine()->ChangeCompressedToTagged();
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kTagged);
@ -623,197 +572,6 @@ Node* RepresentationChanger::GetTaggedRepresentationFor(
return jsgraph()->graph()->NewNode(op, node);
}
Node* RepresentationChanger::GetCompressedSignedRepresentationFor(
Node* node, MachineRepresentation output_rep, Type output_type,
Node* use_node, UseInfo use_info) {
// Select the correct X -> Compressed operator.
const Operator* op;
if (output_type.Is(Type::None())) {
// This is an impossible value; it should not be used at runtime.
return jsgraph()->graph()->NewNode(
jsgraph()->common()->DeadValue(
MachineRepresentation::kCompressedSigned),
node);
} else if (output_rep == MachineRepresentation::kTaggedSigned) {
op = machine()->ChangeTaggedSignedToCompressedSigned();
} else if (CanBeTaggedPointer(output_rep)) {
if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
op = simplified()->CheckedTaggedToCompressedSigned(use_info.feedback());
} else if (output_type.Is(Type::SignedSmall())) {
op = simplified()->ChangeTaggedToCompressedSigned();
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kTaggedSigned);
}
} else if (output_rep == MachineRepresentation::kBit) {
// TODO(v8:8977): specialize here and below
node = GetTaggedSignedRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedSignedToCompressedSigned();
} else if (IsWord(output_rep)) {
if (output_type.Is(Type::Signed31())) {
op = simplified()->ChangeInt31ToCompressedSigned();
} else if (output_type.Is(Type::Signed32())) {
if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
op = simplified()->CheckedInt32ToCompressedSigned(use_info.feedback());
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kCompressedSigned);
}
} else {
node = GetTaggedSignedRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedSignedToCompressedSigned();
}
} else if (output_rep == MachineRepresentation::kWord64) {
node = GetTaggedSignedRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedSignedToCompressedSigned();
} else if (output_rep == MachineRepresentation::kFloat32) {
// float 32 -> float64 -> int32 -> Compressed signed
if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
node = InsertChangeFloat32ToFloat64(node);
node = InsertCheckedFloat64ToInt32(
node,
output_type.Maybe(Type::MinusZero())
? CheckForMinusZeroMode::kCheckForMinusZero
: CheckForMinusZeroMode::kDontCheckForMinusZero,
use_info.feedback(), use_node);
op = simplified()->CheckedInt32ToCompressedSigned(use_info.feedback());
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kCompressedSigned);
}
} else if (output_rep == MachineRepresentation::kFloat64) {
if (output_type.Is(Type::Signed31())) {
// float64 -> int32 -> compressed signed
node = InsertChangeFloat64ToInt32(node);
op = simplified()->ChangeInt31ToCompressedSigned();
} else if (output_type.Is(Type::Signed32())) {
// float64 -> int32 -> compressed signed
node = InsertChangeFloat64ToInt32(node);
if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
op = simplified()->CheckedInt32ToCompressedSigned(use_info.feedback());
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kCompressedSigned);
}
} else if (use_info.type_check() == TypeCheckKind::kSignedSmall) {
node = InsertCheckedFloat64ToInt32(
node,
output_type.Maybe(Type::MinusZero())
? CheckForMinusZeroMode::kCheckForMinusZero
: CheckForMinusZeroMode::kDontCheckForMinusZero,
use_info.feedback(), use_node);
op = simplified()->CheckedInt32ToCompressedSigned(use_info.feedback());
} else {
// TODO(v8:8977): specialize here and below. Missing the unsigned case.
node = GetTaggedSignedRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedSignedToCompressedSigned();
}
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kCompressedSigned);
}
return InsertConversion(node, op, use_node);
}
Node* RepresentationChanger::GetCompressedPointerRepresentationFor(
Node* node, MachineRepresentation output_rep, Type output_type,
Node* use_node, UseInfo use_info) {
// Select the correct X -> CompressedPointer operator.
Operator const* op;
if (output_type.Is(Type::None())) {
// This is an impossible value; it should not be used at runtime.
return jsgraph()->graph()->NewNode(
jsgraph()->common()->DeadValue(
MachineRepresentation::kCompressedPointer),
node);
} else if (output_rep == MachineRepresentation::kTaggedPointer) {
op = machine()->ChangeTaggedPointerToCompressedPointer();
} else if (CanBeTaggedSigned(output_rep) &&
use_info.type_check() == TypeCheckKind::kHeapObject) {
if (!output_type.Maybe(Type::SignedSmall())) {
op = machine()->ChangeTaggedPointerToCompressedPointer();
} else {
// TODO(turbofan): Consider adding a Bailout operator that just deopts
// for TaggedSigned output representation.
op = simplified()->CheckedTaggedToCompressedPointer(use_info.feedback());
}
} else if (output_rep == MachineRepresentation::kBit) {
// TODO(v8:8977): specialize here and below
node = GetTaggedPointerRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedPointerToCompressedPointer();
} else if (IsWord(output_rep)) {
node = GetTaggedPointerRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedPointerToCompressedPointer();
} else if (output_rep == MachineRepresentation::kWord64) {
node = GetTaggedPointerRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedPointerToCompressedPointer();
} else if (output_rep == MachineRepresentation::kFloat32) {
node = GetTaggedPointerRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedPointerToCompressedPointer();
} else if (output_rep == MachineRepresentation::kFloat64) {
node = GetTaggedPointerRepresentationFor(node, output_rep, output_type,
use_node, use_info);
op = machine()->ChangeTaggedPointerToCompressedPointer();
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kCompressedPointer);
}
return InsertConversion(node, op, use_node);
}
Node* RepresentationChanger::GetCompressedRepresentationFor(
Node* node, MachineRepresentation output_rep, Type output_type,
Truncation truncation) {
if (output_rep == MachineRepresentation::kCompressedSigned ||
output_rep == MachineRepresentation::kCompressedPointer) {
// this is a no-op.
return node;
}
// Select the correct X -> Compressed operator.
const Operator* op;
if (output_type.Is(Type::None())) {
// This is an impossible value; it should not be used at runtime.
return jsgraph()->graph()->NewNode(
jsgraph()->common()->DeadValue(MachineRepresentation::kCompressed),
node);
} else if (output_rep == MachineRepresentation::kBit) {
// TODO(v8:8977): specialize here and below
node =
GetTaggedRepresentationFor(node, output_rep, output_type, truncation);
op = machine()->ChangeTaggedToCompressed();
} else if (IsWord(output_rep)) {
node =
GetTaggedRepresentationFor(node, output_rep, output_type, truncation);
op = machine()->ChangeTaggedToCompressed();
} else if (output_rep == MachineRepresentation::kWord64) {
node =
GetTaggedRepresentationFor(node, output_rep, output_type, truncation);
op = machine()->ChangeTaggedToCompressed();
} else if (output_rep == MachineRepresentation::kFloat32) {
node =
GetTaggedRepresentationFor(node, output_rep, output_type, truncation);
op = machine()->ChangeTaggedToCompressed();
} else if (output_rep == MachineRepresentation::kFloat64) {
node =
GetTaggedRepresentationFor(node, output_rep, output_type, truncation);
op = machine()->ChangeTaggedToCompressed();
} else if (IsAnyTagged(output_rep)) {
op = machine()->ChangeTaggedToCompressed();
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kCompressed);
}
return jsgraph()->graph()->NewNode(op, node);
}
Node* RepresentationChanger::GetFloat32RepresentationFor(
Node* node, MachineRepresentation output_rep, Type output_type,
Truncation truncation) {
@ -862,21 +620,6 @@ Node* RepresentationChanger::GetFloat32RepresentationFor(
node = jsgraph()->graph()->NewNode(op, node);
op = machine()->TruncateFloat64ToFloat32();
}
} else if (output_rep == MachineRepresentation::kCompressed) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedToTagged(node);
return GetFloat32RepresentationFor(node, MachineRepresentation::kTagged,
output_type, truncation);
} else if (output_rep == MachineRepresentation::kCompressedSigned) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedSignedToTaggedSigned(node);
return GetFloat32RepresentationFor(
node, MachineRepresentation::kTaggedSigned, output_type, truncation);
} else if (output_rep == MachineRepresentation::kCompressedPointer) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedPointerToTaggedPointer(node);
return GetFloat32RepresentationFor(
node, MachineRepresentation::kTaggedPointer, output_type, truncation);
} else if (output_rep == MachineRepresentation::kFloat64) {
op = machine()->TruncateFloat64ToFloat32();
} else if (output_rep == MachineRepresentation::kWord64) {
@ -978,23 +721,6 @@ Node* RepresentationChanger::GetFloat64RepresentationFor(
op = simplified()->CheckedTaggedToFloat64(
CheckTaggedInputMode::kNumberOrOddball, use_info.feedback());
}
} else if (output_rep == MachineRepresentation::kCompressed) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedToTagged(node);
return GetFloat64RepresentationFor(node, MachineRepresentation::kTagged,
output_type, use_node, use_info);
} else if (output_rep == MachineRepresentation::kCompressedSigned) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedSignedToTaggedSigned(node);
return GetFloat64RepresentationFor(node,
MachineRepresentation::kTaggedSigned,
output_type, use_node, use_info);
} else if (output_rep == MachineRepresentation::kCompressedPointer) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedPointerToTaggedPointer(node);
return GetFloat64RepresentationFor(node,
MachineRepresentation::kTaggedPointer,
output_type, use_node, use_info);
} else if (output_rep == MachineRepresentation::kFloat32) {
op = machine()->ChangeFloat32ToFloat64();
} else if (output_rep == MachineRepresentation::kWord64) {
@ -1148,27 +874,6 @@ Node* RepresentationChanger::GetWord32RepresentationFor(
return TypeError(node, output_rep, output_type,
MachineRepresentation::kWord32);
}
} else if (output_rep == MachineRepresentation::kCompressed) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedToTagged(node);
return GetWord32RepresentationFor(node, MachineRepresentation::kTagged,
output_type, use_node, use_info);
} else if (output_rep == MachineRepresentation::kCompressedSigned) {
// TODO(v8:8977): Specialise here
if (output_type.Is(Type::SignedSmall())) {
op = simplified()->ChangeCompressedSignedToInt32();
} else {
node = InsertChangeCompressedSignedToTaggedSigned(node);
return GetWord32RepresentationFor(node,
MachineRepresentation::kTaggedSigned,
output_type, use_node, use_info);
}
} else if (output_rep == MachineRepresentation::kCompressedPointer) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedPointerToTaggedPointer(node);
return GetWord32RepresentationFor(node,
MachineRepresentation::kTaggedPointer,
output_type, use_node, use_info);
} else if (output_rep == MachineRepresentation::kWord32) {
// Only the checked case should get here, the non-checked case is
// handled in GetRepresentationFor.
@ -1289,21 +994,6 @@ Node* RepresentationChanger::GetBitRepresentationFor(
}
return jsgraph()->graph()->NewNode(machine()->Word32Equal(), node,
jsgraph()->Int32Constant(0));
} else if (output_rep == MachineRepresentation::kCompressed) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedToTagged(node);
return GetBitRepresentationFor(node, MachineRepresentation::kTagged,
output_type);
} else if (output_rep == MachineRepresentation::kCompressedSigned) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedSignedToTaggedSigned(node);
return GetBitRepresentationFor(node, MachineRepresentation::kTaggedSigned,
output_type);
} else if (output_rep == MachineRepresentation::kCompressedPointer) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedPointerToTaggedPointer(node);
return GetBitRepresentationFor(node, MachineRepresentation::kTaggedPointer,
output_type);
} else if (IsWord(output_rep)) {
node = jsgraph()->graph()->NewNode(machine()->Word32Equal(), node,
jsgraph()->Int32Constant(0));
@ -1456,23 +1146,6 @@ Node* RepresentationChanger::GetWord64RepresentationFor(
return TypeError(node, output_rep, output_type,
MachineRepresentation::kWord64);
}
} else if (output_rep == MachineRepresentation::kCompressed) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedToTagged(node);
return GetWord64RepresentationFor(node, MachineRepresentation::kTagged,
output_type, use_node, use_info);
} else if (output_rep == MachineRepresentation::kCompressedSigned) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedSignedToTaggedSigned(node);
return GetWord64RepresentationFor(node,
MachineRepresentation::kTaggedSigned,
output_type, use_node, use_info);
} else if (output_rep == MachineRepresentation::kCompressedPointer) {
// TODO(v8:8977): Specialise here
node = InsertChangeCompressedPointerToTaggedPointer(node);
return GetWord64RepresentationFor(node,
MachineRepresentation::kTaggedPointer,
output_type, use_node, use_info);
} else {
return TypeError(node, output_rep, output_type,
MachineRepresentation::kWord64);
@ -1776,23 +1449,6 @@ Node* RepresentationChanger::InsertTruncateInt64ToInt32(Node* node) {
return jsgraph()->graph()->NewNode(machine()->TruncateInt64ToInt32(), node);
}
Node* RepresentationChanger::InsertChangeCompressedPointerToTaggedPointer(
Node* node) {
return jsgraph()->graph()->NewNode(
machine()->ChangeCompressedPointerToTaggedPointer(), node);
}
Node* RepresentationChanger::InsertChangeCompressedSignedToTaggedSigned(
Node* node) {
return jsgraph()->graph()->NewNode(
machine()->ChangeCompressedSignedToTaggedSigned(), node);
}
Node* RepresentationChanger::InsertChangeCompressedToTagged(Node* node) {
return jsgraph()->graph()->NewNode(machine()->ChangeCompressedToTagged(),
node);
}
Node* RepresentationChanger::InsertCheckedFloat64ToInt32(
Node* node, CheckForMinusZeroMode check, const FeedbackSource& feedback,
Node* use_node) {

24
src/compiler/representation-change.h
View File

@ -210,16 +210,6 @@ class UseInfo {
static UseInfo TaggedPointer() {
return UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any());
}
static UseInfo AnyCompressed() {
return UseInfo(MachineRepresentation::kCompressed, Truncation::Any());
}
static UseInfo CompressedSigned() {
return UseInfo(MachineRepresentation::kCompressedSigned, Truncation::Any());
}
static UseInfo CompressedPointer() {
return UseInfo(MachineRepresentation::kCompressedPointer,
Truncation::Any());
}
// Possibly deoptimizing conversions.
static UseInfo CheckedTaggedAsArrayIndex(const FeedbackSource& feedback) {
@ -367,17 +357,6 @@ class V8_EXPORT_PRIVATE RepresentationChanger final {
UseInfo use_info);
Node* GetTaggedRepresentationFor(Node* node, MachineRepresentation output_rep,
Type output_type, Truncation truncation);
Node* GetCompressedSignedRepresentationFor(Node* node,
MachineRepresentation output_rep,
Type output_type, Node* use_node,
UseInfo use_info);
Node* GetCompressedPointerRepresentationFor(Node* node,
MachineRepresentation output_rep,
Type output_type, Node* use_node,
UseInfo use_info);
Node* GetCompressedRepresentationFor(Node* node,
MachineRepresentation output_rep,
Type output_type, Truncation truncation);
Node* GetFloat32RepresentationFor(Node* node,
MachineRepresentation output_rep,
Type output_type, Truncation truncation);
@ -404,9 +383,6 @@ class V8_EXPORT_PRIVATE RepresentationChanger final {
Node* InsertChangeTaggedSignedToInt32(Node* node);
Node* InsertChangeTaggedToFloat64(Node* node);
Node* InsertChangeUint32ToFloat64(Node* node);
Node* InsertChangeCompressedPointerToTaggedPointer(Node* node);
Node* InsertChangeCompressedSignedToTaggedSigned(Node* node);
Node* InsertChangeCompressedToTagged(Node* node);
Node* InsertCheckedFloat64ToInt32(Node* node, CheckForMinusZeroMode check,
const FeedbackSource& feedback,
Node* use_node);

25
src/compiler/simplified-lowering.cc
View File

@ -132,11 +132,6 @@ UseInfo TruncatingUseInfoFromRepresentation(MachineRepresentation rep) {
case MachineRepresentation::kTaggedPointer:
case MachineRepresentation::kTagged:
return UseInfo::AnyTagged();
case MachineRepresentation::kCompressedSigned:
return UseInfo::CompressedSigned();
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
return UseInfo::AnyCompressed();
case MachineRepresentation::kFloat64:
return UseInfo::TruncatingFloat64();
case MachineRepresentation::kFloat32:
@ -149,6 +144,9 @@ UseInfo TruncatingUseInfoFromRepresentation(MachineRepresentation rep) {
return UseInfo::Word64();
case MachineRepresentation::kBit:
return UseInfo::Bool();
case MachineRepresentation::kCompressedSigned:
case MachineRepresentation::kCompressedPointer:
case MachineRepresentation::kCompressed:
case MachineRepresentation::kSimd128:
case MachineRepresentation::kNone:
break;
@ -1151,10 +1149,6 @@ class RepresentationSelector {
if (IsAnyTagged(rep)) {
return MachineType::AnyTagged();
}
// Do not distinguish between various Compressed variations.
if (IsAnyCompressed(rep)) {
return MachineType::AnyCompressed();
}
if (rep == MachineRepresentation::kWord64) {
if (type.Is(Type::BigInt())) {
return MachineType::AnyTagged();
@ -1308,10 +1302,9 @@ class RepresentationSelector {
MachineRepresentation field_representation, Type field_type,
MachineRepresentation value_representation, Node* value) {
if (base_taggedness == kTaggedBase &&
CanBeTaggedOrCompressedPointer(field_representation)) {
CanBeTaggedPointer(field_representation)) {
Type value_type = NodeProperties::GetType(value);
if (value_representation == MachineRepresentation::kTaggedSigned ||
value_representation == MachineRepresentation::kCompressedSigned) {
if (value_representation == MachineRepresentation::kTaggedSigned) {
// Write barriers are only for stores of heap objects.
return kNoWriteBarrier;
}
@ -1333,9 +1326,7 @@ class RepresentationSelector {
}
}
if (field_representation == MachineRepresentation::kTaggedPointer ||
value_representation == MachineRepresentation::kTaggedPointer ||
field_representation == MachineRepresentation::kCompressedPointer ||
value_representation == MachineRepresentation::kCompressedPointer) {
value_representation == MachineRepresentation::kTaggedPointer) {
// Write barriers for heap objects are cheaper.
return kPointerWriteBarrier;
}
@ -1821,10 +1812,6 @@ class RepresentationSelector {
// BooleanNot(x: kRepTagged) => WordEqual(x, #false)
node->AppendInput(jsgraph_->zone(), jsgraph_->FalseConstant());
NodeProperties::ChangeOp(node, lowering->machine()->WordEqual());
} else if (CanBeCompressedPointer(input_info->representation())) {
// BooleanNot(x: kRepCompressed) => Word32Equal(x, #false)
node->AppendInput(jsgraph_->zone(), jsgraph_->FalseConstant());
NodeProperties::ChangeOp(node, lowering->machine()->Word32Equal());
} else {
DCHECK(TypeOf(node->InputAt(0)).IsNone());
DeferReplacement(node, lowering->jsgraph()->Int32Constant(0));

30
src/compiler/simplified-operator-reducer.cc
View File

@ -106,11 +106,6 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
if (m.IsChangeInt31ToTaggedSigned() || m.IsChangeInt32ToTagged()) {
return Replace(m.InputAt(0));
}
if (m.IsChangeCompressedSignedToTaggedSigned()) {
Node* new_node = graph()->NewNode(
simplified()->ChangeCompressedSignedToInt32(), m.InputAt(0));
return Replace(new_node);
}
break;
}
case IrOpcode::kChangeTaggedToUint32: {
@ -148,23 +143,6 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
}
break;
}
case IrOpcode::kChangeTaggedSignedToCompressedSigned: {
DCHECK(COMPRESS_POINTERS_BOOL);
NodeMatcher m(node->InputAt(0));
if (m.IsChangeInt31ToTaggedSigned()) {
Node* new_node = graph()->NewNode(
simplified()->ChangeInt31ToCompressedSigned(), m.InputAt(0));
return Replace(new_node);
}
break;
}
case IrOpcode::kChangeCompressedSignedToInt32: {
NodeMatcher m(node->InputAt(0));
if (m.IsCheckedInt32ToCompressedSigned()) {
return Replace(m.InputAt(0));
}
break;
}
case IrOpcode::kCheckedTaggedToArrayIndex:
case IrOpcode::kCheckedTaggedToInt32:
case IrOpcode::kCheckedTaggedSignedToInt32: {
@ -175,14 +153,6 @@ Reduction SimplifiedOperatorReducer::Reduce(Node* node) {
}
break;
}
case IrOpcode::kCheckedTaggedToTaggedPointer: {
NodeMatcher m(node->InputAt(0));
if (m.IsChangeCompressedPointerToTaggedPointer()) {
RelaxEffectsAndControls(node);
return Replace(m.node());
}
break;
}
case IrOpcode::kCheckIf: {
HeapObjectMatcher m(node->InputAt(0));
if (m.Is(factory()->true_value())) {

9
src/compiler/simplified-operator.cc
View File

@ -732,7 +732,6 @@ bool operator==(CheckMinusZeroParameters const& lhs,
V(PlainPrimitiveToNumber, Operator::kNoProperties, 1, 0) \
V(PlainPrimitiveToWord32, Operator::kNoProperties, 1, 0) \
V(PlainPrimitiveToFloat64, Operator::kNoProperties, 1, 0) \
V(ChangeCompressedSignedToInt32, Operator::kNoProperties, 1, 0) \
V(ChangeTaggedSignedToInt32, Operator::kNoProperties, 1, 0) \
V(ChangeTaggedSignedToInt64, Operator::kNoProperties, 1, 0) \
V(ChangeTaggedToInt32, Operator::kNoProperties, 1, 0) \
@ -740,10 +739,7 @@ bool operator==(CheckMinusZeroParameters const& lhs,
V(ChangeTaggedToUint32, Operator::kNoProperties, 1, 0) \
V(ChangeTaggedToFloat64, Operator::kNoProperties, 1, 0) \
V(ChangeTaggedToTaggedSigned, Operator::kNoProperties, 1, 0) \
V(ChangeCompressedToTaggedSigned, Operator::kNoProperties, 1, 0) \
V(ChangeTaggedToCompressedSigned, Operator::kNoProperties, 1, 0) \
V(ChangeFloat64ToTaggedPointer, Operator::kNoProperties, 1, 0) \
V(ChangeInt31ToCompressedSigned, Operator::kNoProperties, 1, 0) \
V(ChangeInt31ToTaggedSigned, Operator::kNoProperties, 1, 0) \
V(ChangeInt32ToTagged, Operator::kNoProperties, 1, 0) \
V(ChangeInt64ToTagged, Operator::kNoProperties, 1, 0) \
@ -828,7 +824,6 @@ bool operator==(CheckMinusZeroParameters const& lhs,
V(CheckSmi, 1, 1) \
V(CheckString, 1, 1) \
V(CheckBigInt, 1, 1) \
V(CheckedInt32ToCompressedSigned, 1, 1) \
V(CheckedInt32ToTaggedSigned, 1, 1) \
V(CheckedInt64ToInt32, 1, 1) \
V(CheckedInt64ToTaggedSigned, 1, 1) \
@ -836,10 +831,6 @@ bool operator==(CheckMinusZeroParameters const& lhs,
V(CheckedTaggedSignedToInt32, 1, 1) \
V(CheckedTaggedToTaggedPointer, 1, 1) \
V(CheckedTaggedToTaggedSigned, 1, 1) \
V(CheckedCompressedToTaggedPointer, 1, 1) \
V(CheckedCompressedToTaggedSigned, 1, 1) \
V(CheckedTaggedToCompressedPointer, 1, 1) \
V(CheckedTaggedToCompressedSigned, 1, 1) \
V(CheckedUint32ToInt32, 1, 1) \
V(CheckedUint32ToTaggedSigned, 1, 1) \
V(CheckedUint64Bounds, 2, 1) \

14
src/compiler/simplified-operator.h
View File

@ -725,7 +725,6 @@ class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
const Operator* PlainPrimitiveToWord32();
const Operator* PlainPrimitiveToFloat64();
const Operator* ChangeCompressedSignedToInt32();
const Operator* ChangeTaggedSignedToInt32();
const Operator* ChangeTaggedSignedToInt64();
const Operator* ChangeTaggedToInt32();
@ -733,9 +732,6 @@ class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
const Operator* ChangeTaggedToUint32();
const Operator* ChangeTaggedToFloat64();
const Operator* ChangeTaggedToTaggedSigned();
const Operator* ChangeCompressedToTaggedSigned();
const Operator* ChangeTaggedToCompressedSigned();
const Operator* ChangeInt31ToCompressedSigned();
const Operator* ChangeInt31ToTaggedSigned();
const Operator* ChangeInt32ToTagged();
const Operator* ChangeInt64ToTagged();
@ -783,8 +779,6 @@ class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
const Operator* CheckedInt32Mod();
const Operator* CheckedInt32Mul(CheckForMinusZeroMode);
const Operator* CheckedInt32Sub();
const Operator* CheckedInt32ToCompressedSigned(
const FeedbackSource& feedback);
const Operator* CheckedInt32ToTaggedSigned(const FeedbackSource& feedback);
const Operator* CheckedInt64ToInt32(const FeedbackSource& feedback);
const Operator* CheckedInt64ToTaggedSigned(const FeedbackSource& feedback);
@ -799,14 +793,6 @@ class V8_EXPORT_PRIVATE SimplifiedOperatorBuilder final
const Operator* CheckedTaggedToTaggedPointer(const FeedbackSource& feedback);
const Operator* CheckedTaggedToTaggedSigned(const FeedbackSource& feedback);
const Operator* CheckBigInt(const FeedbackSource& feedback);
const Operator* CheckedCompressedToTaggedPointer(
const FeedbackSource& feedback);
const Operator* CheckedCompressedToTaggedSigned(
const FeedbackSource& feedback);
const Operator* CheckedTaggedToCompressedPointer(
const FeedbackSource& feedback);
const Operator* CheckedTaggedToCompressedSigned(
const FeedbackSource& feedback);
const Operator* CheckedTruncateTaggedToWord32(CheckTaggedInputMode,
const FeedbackSource& feedback);
const Operator* CheckedUint32Div();

16
src/compiler/verifier.cc
View File

@ -1356,7 +1356,6 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
CheckNotTyped(node);
break;
case IrOpcode::kChangeCompressedSignedToInt32:
case IrOpcode::kChangeTaggedSignedToInt32: {
// Signed32 /\ Tagged -> Signed32 /\ UntaggedInt32
// TODO(neis): Activate once ChangeRepresentation works in typer.
@ -1398,8 +1397,6 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
break;
}
case IrOpcode::kChangeTaggedToTaggedSigned: // Fall through.
case IrOpcode::kChangeCompressedToTaggedSigned: // Fall through.
case IrOpcode::kChangeTaggedToCompressedSigned:
break;
case IrOpcode::kTruncateTaggedToFloat64: {
// NumberOrUndefined /\ Tagged -> Number /\ UntaggedFloat64
@ -1411,7 +1408,6 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
// CheckTypeIs(node, to));
break;
}
case IrOpcode::kChangeInt31ToCompressedSigned:
case IrOpcode::kChangeInt31ToTaggedSigned: {
// Signed31 /\ UntaggedInt32 -> Signed31 /\ Tagged
// TODO(neis): Activate once ChangeRepresentation works in typer.
@ -1558,7 +1554,6 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
case IrOpcode::kCheckedUint32Div:
case IrOpcode::kCheckedUint32Mod:
case IrOpcode::kCheckedInt32Mul:
case IrOpcode::kCheckedInt32ToCompressedSigned:
case IrOpcode::kCheckedInt32ToTaggedSigned:
case IrOpcode::kCheckedInt64ToInt32:
case IrOpcode::kCheckedInt64ToTaggedSigned:
@ -1577,10 +1572,6 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
case IrOpcode::kCheckedTaggedToFloat64:
case IrOpcode::kCheckedTaggedToTaggedSigned:
case IrOpcode::kCheckedTaggedToTaggedPointer:
case IrOpcode::kCheckedCompressedToTaggedSigned:
case IrOpcode::kCheckedCompressedToTaggedPointer:
case IrOpcode::kCheckedTaggedToCompressedSigned:
case IrOpcode::kCheckedTaggedToCompressedPointer:
case IrOpcode::kCheckedTruncateTaggedToWord32:
case IrOpcode::kAssertType:
break;
@ -1829,16 +1820,9 @@ void Verifier::Visitor::Check(Node* node, const AllNodes& all) {
case IrOpcode::kBitcastTaggedToWordForTagAndSmiBits:
case IrOpcode::kBitcastWordToTagged:
case IrOpcode::kBitcastWordToTaggedSigned:
case IrOpcode::kBitcastWord32ToCompressedSigned:
case IrOpcode::kBitcastCompressedSignedToWord32:
case IrOpcode::kChangeInt32ToInt64:
case IrOpcode::kChangeUint32ToUint64:
case IrOpcode::kChangeTaggedToCompressed:
case IrOpcode::kChangeTaggedPointerToCompressedPointer:
case IrOpcode::kChangeTaggedSignedToCompressedSigned:
case IrOpcode::kChangeCompressedToTagged:
case IrOpcode::kChangeCompressedPointerToTaggedPointer:
case IrOpcode::kChangeCompressedSignedToTaggedSigned:
case IrOpcode::kChangeInt32ToFloat64:
case IrOpcode::kChangeInt64ToFloat64:
case IrOpcode::kChangeUint32ToFloat64:

59
test/cctest/compiler/test-representation-change.cc
View File

@ -123,12 +123,10 @@ class RepresentationChangerTester : public HandleAndZoneScope,
};
const MachineType kMachineTypes[] = {
MachineType::Float32(), MachineType::Float64(),
MachineType::Int8(), MachineType::Uint8(),
MachineType::Int16(), MachineType::Uint16(),
MachineType::Int32(), MachineType::Uint32(),
MachineType::Int64(), MachineType::Uint64(),
MachineType::AnyTagged(), MachineType::AnyCompressed()};
MachineType::Float32(), MachineType::Float64(), MachineType::Int8(),
MachineType::Uint8(), MachineType::Int16(), MachineType::Uint16(),
MachineType::Int32(), MachineType::Uint32(), MachineType::Int64(),
MachineType::Uint64(), MachineType::AnyTagged()};
TEST(BoolToBit_constant) {
RepresentationChangerTester r;
@ -526,9 +524,6 @@ TEST(SingleChanges) {
CheckChange(IrOpcode::kChangeBitToTagged, MachineRepresentation::kBit,
Type::Boolean(), MachineRepresentation::kTagged);
CheckChange(IrOpcode::kChangeInt31ToCompressedSigned,
MachineRepresentation::kWord32, Type::Signed31(),
MachineRepresentation::kCompressedSigned);
CheckChange(IrOpcode::kChangeInt31ToTaggedSigned,
MachineRepresentation::kWord32, Type::Signed31(),
MachineRepresentation::kTagged);
@ -647,52 +642,6 @@ TEST(SignednessInWord32) {
UseInfo::CheckedSigned32AsWord32(kIdentifyZeros, FeedbackSource()));
}
TEST(CompressedAndTagged) {
// Simple Tagged to Compressed
CheckChange(IrOpcode::kChangeTaggedToCompressed,
MachineRepresentation::kTagged, Type::Any(),
MachineRepresentation::kCompressed);
CheckChange(IrOpcode::kChangeTaggedPointerToCompressedPointer,
MachineRepresentation::kTaggedPointer, Type::Any(),
MachineRepresentation::kCompressedPointer);
CheckChange(IrOpcode::kChangeTaggedSignedToCompressedSigned,
MachineRepresentation::kTaggedSigned, Type::Any(),
MachineRepresentation::kCompressedSigned);
// Simple Compressed to Tagged
CheckChange(IrOpcode::kChangeCompressedToTagged,
MachineRepresentation::kCompressed, Type::Any(),
MachineRepresentation::kTagged);
CheckChange(IrOpcode::kChangeCompressedPointerToTaggedPointer,
MachineRepresentation::kCompressedPointer, Type::Any(),
MachineRepresentation::kTaggedPointer);
CheckChange(IrOpcode::kChangeCompressedSignedToTaggedSigned,
MachineRepresentation::kCompressedSigned, Type::Any(),
MachineRepresentation::kTaggedSigned);
// Compressed To TaggedSigned
CheckChange(IrOpcode::kChangeCompressedToTaggedSigned,
MachineRepresentation::kCompressed, Type::SignedSmall(),
MachineRepresentation::kTaggedSigned);
// Tagged To CompressedSigned
CheckChange(IrOpcode::kChangeTaggedToCompressedSigned,
MachineRepresentation::kTagged, Type::SignedSmall(),
MachineRepresentation::kCompressedSigned);
// TaggedSigned to CompressedPointer
CheckChange(IrOpcode::kCheckedTaggedToCompressedPointer,
MachineRepresentation::kTaggedSigned, Type::SignedSmall(),
UseInfo(MachineRepresentation::kCompressedPointer,
Truncation::Any(), TypeCheckKind::kHeapObject));
// CompressedSigned to TaggedPointer
CheckChange(IrOpcode::kCheckedCompressedToTaggedPointer,
MachineRepresentation::kCompressedSigned, Type::SignedSmall(),
UseInfo(MachineRepresentation::kTaggedPointer, Truncation::Any(),
TypeCheckKind::kHeapObject));
}
static void TestMinusZeroCheck(IrOpcode::Value expected, Type from_type) {
RepresentationChangerTester r;

51
test/cctest/compiler/test-run-machops.cc
View File

@ -397,57 +397,6 @@ TEST(RunWord64Popcnt) {
CHECK_EQ(18, m.Call(uint64_t(0x000DC107000DC107)));
}
#ifdef V8_COMPRESS_POINTERS
TEST(CompressDecompressTaggedAnyPointer) {
RawMachineAssemblerTester<void*> m;
Handle<HeapNumber> value = m.isolate()->factory()->NewHeapNumber(11.2);
Node* node = m.HeapConstant(value);
m.Return(m.ChangeCompressedToTagged(m.ChangeTaggedToCompressed(node)));
HeapObject result =
HeapObject::cast(Object(reinterpret_cast<Address>(m.Call())));
CHECK_EQ(result, *value);
}
TEST(CompressDecompressTaggedAnySigned) {
RawMachineAssemblerTester<void*> m;
Smi smi = Smi::FromInt(123);
Node* node = m.Int64Constant(static_cast<int64_t>(smi.ptr()));
m.Return(m.ChangeCompressedToTagged(m.ChangeTaggedToCompressed(node)));
Object result = Object(reinterpret_cast<Address>(m.Call()));
Address smiPointer =
DecompressTaggedAny(m.isolate(), CompressTagged(smi.ptr()));
CHECK_EQ(smiPointer, result.ptr());
}
TEST(CompressDecompressTaggedPointer) {
RawMachineAssemblerTester<void*> m;
Handle<HeapNumber> value = m.isolate()->factory()->NewHeapNumber(11.2);
Node* node = m.HeapConstant(value);
m.Return(m.ChangeCompressedPointerToTaggedPointer(
m.ChangeTaggedPointerToCompressedPointer(node)));
HeapObject result =
HeapObject::cast(Object(reinterpret_cast<Address>(m.Call())));
CHECK_EQ(result, *value);
}
TEST(CompressDecompressTaggedSigned) {
RawMachineAssemblerTester<void*> m;
Smi smi = Smi::FromInt(123);
Address smiPointer = smi.ptr();
Node* node = m.Int64Constant(static_cast<int64_t>(smiPointer));
m.Return(m.ChangeCompressedSignedToTaggedSigned(
m.ChangeTaggedSignedToCompressedSigned(node)));
Object result = Object(reinterpret_cast<Address>(m.Call()));
CHECK_EQ(smiPointer, result.ptr());
}
#endif // V8_COMPRESS_POINTERS
#endif // V8_TARGET_ARCH_64_BIT

3
test/unittests/compiler/decompression-optimizer-unittest.cc
View File

@ -373,9 +373,6 @@ TEST_F(DecompressionOptimizerTest, CascadingPhi) {
}
TEST_F(DecompressionOptimizerTest, PhiWithOneCompressedAndOneTagged) {
// If the phi is Compressed but one of the inputs is Tagged, then we insert a
// ChangeTaggedToCompressed node.
// Define variables.
Node* const control = graph()->start();
Node* object = Parameter(Type::Any(), 0);

2
test/unittests/compiler/node-test-utils.cc
View File

@ -2203,8 +2203,6 @@ IS_UNOP_MATCHER(ChangeInt32ToFloat64)
IS_UNOP_MATCHER(ChangeInt32ToInt64)
IS_UNOP_MATCHER(ChangeUint32ToFloat64)
IS_UNOP_MATCHER(ChangeUint32ToUint64)
IS_UNOP_MATCHER(ChangeCompressedToTagged)
IS_UNOP_MATCHER(ChangeCompressedPointerToTaggedPointer)
IS_UNOP_MATCHER(TruncateFloat64ToFloat32)
IS_UNOP_MATCHER(TruncateInt64ToInt32)
IS_UNOP_MATCHER(Float32Abs)

3
test/unittests/compiler/node-test-utils.h
View File

@ -426,9 +426,6 @@ Matcher<Node*> IsChangeInt32ToFloat64(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsChangeInt32ToInt64(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsChangeUint32ToFloat64(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsChangeUint32ToUint64(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsChangeCompressedToTagged(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsChangeCompressedPointerToTaggedPointer(
const Matcher<Node*>& input_matcher);
Matcher<Node*> IsTruncateFloat64ToFloat32(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsTruncateInt64ToInt32(const Matcher<Node*>& input_matcher);
Matcher<Node*> IsFloat32Abs(const Matcher<Node*>& input_matcher);

138
test/unittests/compiler/redundancy-elimination-unittest.cc
View File

@ -298,36 +298,6 @@ TEST_F(RedundancyEliminationTest, CheckedFloat64ToInt64) {
}
}
// -----------------------------------------------------------------------------
// CheckedInt32ToCompressedSigned
TEST_F(RedundancyEliminationTest, CheckedInt32ToCompressedSigned) {
if (!COMPRESS_POINTERS_BOOL) {
return;
}
TRACED_FOREACH(FeedbackSource, feedback1, vector_slot_pairs()) {
TRACED_FOREACH(FeedbackSource, feedback2, vector_slot_pairs()) {
Node* value = Parameter(0);
Node* effect = graph()->start();
Node* control = graph()->start();
Node* check1 = effect = graph()->NewNode(
simplified()->CheckedInt32ToCompressedSigned(feedback1), value,
effect, control);
Reduction r1 = Reduce(check1);
ASSERT_TRUE(r1.Changed());
EXPECT_EQ(r1.replacement(), check1);
Node* check2 = effect = graph()->NewNode(
simplified()->CheckedInt32ToCompressedSigned(feedback2), value,
effect, control);
Reduction r2 = Reduce(check2);
ASSERT_TRUE(r2.Changed());
EXPECT_EQ(r2.replacement(), check1);
}
}
}
// -----------------------------------------------------------------------------
// CheckedInt32ToTaggedSigned
@ -631,114 +601,6 @@ TEST_F(RedundancyEliminationTest, CheckedTaggedToTaggedSigned) {
}
}
// -----------------------------------------------------------------------------
// CheckedCompressedToTaggedPointer
TEST_F(RedundancyEliminationTest, CheckedCompressedToTaggedPointer) {
TRACED_FOREACH(FeedbackSource, feedback1, vector_slot_pairs()) {
TRACED_FOREACH(FeedbackSource, feedback2, vector_slot_pairs()) {
Node* value = Parameter(0);
Node* effect = graph()->start();
Node* control = graph()->start();
Node* check1 = effect = graph()->NewNode(
simplified()->CheckedCompressedToTaggedPointer(feedback1), value,
effect, control);
Reduction r1 = Reduce(check1);
ASSERT_TRUE(r1.Changed());
EXPECT_EQ(r1.replacement(), check1);
Node* check2 = effect = graph()->NewNode(
simplified()->CheckedCompressedToTaggedPointer(feedback2), value,
effect, control);
Reduction r2 = Reduce(check2);
ASSERT_TRUE(r2.Changed());
EXPECT_EQ(r2.replacement(), check1);
}
}
}
// -----------------------------------------------------------------------------
// CheckedCompressedToTaggedSigned
TEST_F(RedundancyEliminationTest, CheckedCompressedToTaggedSigned) {
TRACED_FOREACH(FeedbackSource, feedback1, vector_slot_pairs()) {
TRACED_FOREACH(FeedbackSource, feedback2, vector_slot_pairs()) {
Node* value = Parameter(0);
Node* effect = graph()->start();
Node* control = graph()->start();
Node* check1 = effect = graph()->NewNode(
simplified()->CheckedCompressedToTaggedSigned(feedback1), value,
effect, control);
Reduction r1 = Reduce(check1);
ASSERT_TRUE(r1.Changed());
EXPECT_EQ(r1.replacement(), check1);
Node* check2 = effect = graph()->NewNode(
simplified()->CheckedCompressedToTaggedSigned(feedback2), value,
effect, control);
Reduction r2 = Reduce(check2);
ASSERT_TRUE(r2.Changed());
EXPECT_EQ(r2.replacement(), check1);
}
}
}
// -----------------------------------------------------------------------------
// CheckedTaggedToCompressedPointer
TEST_F(RedundancyEliminationTest, CheckedTaggedToCompressedPointer) {
TRACED_FOREACH(FeedbackSource, feedback1, vector_slot_pairs()) {
TRACED_FOREACH(FeedbackSource, feedback2, vector_slot_pairs()) {
Node* value = Parameter(0);
Node* effect = graph()->start();
Node* control = graph()->start();
Node* check1 = effect = graph()->NewNode(
simplified()->CheckedTaggedToCompressedPointer(feedback1), value,
effect, control);
Reduction r1 = Reduce(check1);
ASSERT_TRUE(r1.Changed());
EXPECT_EQ(r1.replacement(), check1);
Node* check2 = effect = graph()->NewNode(
simplified()->CheckedTaggedToCompressedPointer(feedback2), value,
effect, control);
Reduction r2 = Reduce(check2);
ASSERT_TRUE(r2.Changed());
EXPECT_EQ(r2.replacement(), check1);
}
}
}
// -----------------------------------------------------------------------------
// CheckedTaggedToCompressedSigned
TEST_F(RedundancyEliminationTest, CheckedTaggedToCompressedSigned) {
TRACED_FOREACH(FeedbackSource, feedback1, vector_slot_pairs()) {
TRACED_FOREACH(FeedbackSource, feedback2, vector_slot_pairs()) {
Node* value = Parameter(0);
Node* effect = graph()->start();
Node* control = graph()->start();
Node* check1 = effect = graph()->NewNode(
simplified()->CheckedTaggedToCompressedSigned(feedback1), value,
effect, control);
Reduction r1 = Reduce(check1);
ASSERT_TRUE(r1.Changed());
EXPECT_EQ(r1.replacement(), check1);
Node* check2 = effect = graph()->NewNode(
simplified()->CheckedTaggedToCompressedSigned(feedback2), value,
effect, control);
Reduction r2 = Reduce(check2);
ASSERT_TRUE(r2.Changed());
EXPECT_EQ(r2.replacement(), check1);
}
}
}
// -----------------------------------------------------------------------------
// CheckedTruncateTaggedToWord32

1
test/unittests/compiler/simplified-operator-unittest.cc
View File

@ -53,7 +53,6 @@ const PureOperator kPureOperators[] = {
PURE(NumberShiftRightLogical, Operator::kNoProperties, 2),
PURE(NumberToInt32, Operator::kNoProperties, 1),
PURE(NumberToUint32, Operator::kNoProperties, 1),
PURE(ChangeCompressedSignedToInt32, Operator::kNoProperties, 1),
PURE(ChangeTaggedSignedToInt32, Operator::kNoProperties, 1),
PURE(ChangeTaggedToInt32, Operator::kNoProperties, 1),
PURE(ChangeTaggedToUint32, Operator::kNoProperties, 1),