wuggy/Dactyloidae
wuggy/Dactyloidae
1
0
Fork 0
mirror of https://repo.dactyloidae.xyz/Dactyloidae/UXP.git synced 2026-09-08 00:38:39 +09:00
Code Issues Projects Releases Packages Wiki Activity

Merge remote-tracking branch 'origin/tracking' into custom

Browse source
This commit is contained in:
roytam1 2023-09-26 16:14:15 +08:00
commit e9d4ea8fbf
37 changed files with 444 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

6
js/src/jit/CodeGenerator.cpp
View file

@ -12117,16 +12117,16 @@ CodeGenerator::visitRandom(LRandom* ins)
}
void
CodeGenerator::visitSignExtend(LSignExtend* ins)
CodeGenerator::visitSignExtendInt32(LSignExtendInt32* ins)
{
Register input = ToRegister(ins->input());
Register output = ToRegister(ins->output());
switch (ins->mode()) {
case MSignExtend::Byte:
case MSignExtendInt32::Byte:
masm.move8SignExtend(input, output);
break;
case MSignExtend::Half:
case MSignExtendInt32::Half:
masm.move16SignExtend(input, output);
break;
}

2
js/src/jit/CodeGenerator.h
View file

@ -440,7 +440,7 @@ class CodeGenerator final : public CodeGeneratorSpecific
void visitRotate(LRotate* ins);
void visitRandom(LRandom* ins);
void visitSignExtend(LSignExtend* ins);
void visitSignExtendInt32(LSignExtendInt32* ins);
void visitModuleMetadata(LModuleMetadata* lir);
void visitDynamicImport(LDynamicImport* lir);

8
js/src/jit/Lowering.cpp
View file

@ -1328,14 +1328,14 @@ LIRGenerator::visitUrsh(MUrsh* ins)
}
void
LIRGenerator::visitSignExtend(MSignExtend* ins)
LIRGenerator::visitSignExtendInt32(MSignExtendInt32* ins)
{
LInstructionHelper<1, 1, 0>* lir;
if (ins->mode() == MSignExtend::Byte)
lir = new(alloc()) LSignExtend(useByteOpRegisterAtStart(ins->input()), ins->mode());
if (ins->mode() == MSignExtendInt32::Byte)
lir = new(alloc()) LSignExtendInt32(useByteOpRegisterAtStart(ins->input()), ins->mode());
else
lir = new(alloc()) LSignExtend(useRegisterAtStart(ins->input()), ins->mode());
lir = new(alloc()) LSignExtendInt32(useRegisterAtStart(ins->input()), ins->mode());
define(lir, ins);
}

2
js/src/jit/Lowering.h
View file

@ -130,7 +130,7 @@ class LIRGenerator : public LIRGeneratorSpecific
void visitLsh(MLsh* ins);
void visitRsh(MRsh* ins);
void visitUrsh(MUrsh* ins);
void visitSignExtend(MSignExtend* ins);
void visitSignExtendInt32(MSignExtendInt32* ins);
void visitRotate(MRotate* ins);
void visitFloor(MFloor* ins);
void visitCeil(MCeil* ins);

39
js/src/jit/MIR.cpp
View file

@ -2618,9 +2618,9 @@ MRsh::foldsTo(TempAllocator& alloc)
switch (shift) {
case 16:
return MSignExtend::New(alloc, lhs->getOperand(0), MSignExtend::Half);
return MSignExtendInt32::New(alloc, lhs->getOperand(0), MSignExtendInt32::Half);
case 24:
return MSignExtend::New(alloc, lhs->getOperand(0), MSignExtend::Byte);
return MSignExtendInt32::New(alloc, lhs->getOperand(0), MSignExtendInt32::Byte);
}
return this;
@ -3802,6 +3802,41 @@ MExtendInt32ToInt64::foldsTo(TempAllocator& alloc)
return this;
}
MDefinition*
MSignExtendInt32::foldsTo(TempAllocator& alloc)
{
MDefinition* input = this->input();
if (input->isConstant()) {
int32_t c = input->toConstant()->toInt32();
int32_t res;
switch (mode_) {
case Byte: res = int32_t(int8_t(c & 0xFF)); break;
case Half: res = int32_t(int16_t(c & 0xFFFF)); break;
}
return MConstant::New(alloc, Int32Value(res));
}
return this;
}
MDefinition*
MSignExtendInt64::foldsTo(TempAllocator& alloc)
{
MDefinition* input = this->input();
if (input->isConstant()) {
int64_t c = input->toConstant()->toInt64();
int64_t res;
switch (mode_) {
case Byte: res = int64_t(int8_t(c & 0xFF)); break;
case Half: res = int64_t(int16_t(c & 0xFFFF)); break;
case Word: res = int64_t(int32_t(c & 0xFFFFFFFFU)); break;
}
return MConstant::NewInt64(alloc, res);
}
return this;
}
MDefinition*
MToDouble::foldsTo(TempAllocator& alloc)
{

60
js/src/jit/MIR.h
View file

@ -4973,7 +4973,7 @@ class MUrsh : public MShiftInstruction
ALLOW_CLONE(MUrsh)
};
class MSignExtend
class MSignExtendInt32
: public MUnaryInstruction,
public NoTypePolicy::Data
{
@ -4986,7 +4986,7 @@ class MSignExtend
private:
Mode mode_;
MSignExtend(MDefinition* op, Mode mode)
MSignExtendInt32(MDefinition* op, Mode mode)
: MUnaryInstruction(op), mode_(mode)
{
setResultType(MIRType::Int32);
@ -4994,17 +4994,67 @@ class MSignExtend
}
public:
INSTRUCTION_HEADER(SignExtend)
INSTRUCTION_HEADER(SignExtendInt32)
TRIVIAL_NEW_WRAPPERS
Mode mode() { return mode_; }
Mode mode() const { return mode_; }
MDefinition* foldsTo(TempAllocator& alloc) override;
bool congruentTo(const MDefinition* ins) const override {
if (!congruentIfOperandsEqual(ins))
return false;
return ins->isSignExtendInt32() && ins->toSignExtendInt32()->mode_ == mode_;
}
AliasSet getAliasSet() const override {
return AliasSet::None();
}
MOZ_MUST_USE bool writeRecoverData(CompactBufferWriter& writer) const override;
bool canRecoverOnBailout() const override {
return true;
}
ALLOW_CLONE(MSignExtend)
ALLOW_CLONE(MSignExtendInt32)
};
class MSignExtendInt64
: public MUnaryInstruction,
public NoTypePolicy::Data
{
public:
enum Mode {
Byte,
Half,
Word
};
private:
Mode mode_;
MSignExtendInt64(MDefinition* op, Mode mode)
: MUnaryInstruction(op), mode_(mode)
{
setResultType(MIRType::Int64);
setMovable();
}
public:
INSTRUCTION_HEADER(SignExtendInt64)
TRIVIAL_NEW_WRAPPERS
Mode mode() const { return mode_; }
MDefinition* foldsTo(TempAllocator& alloc) override;
bool congruentTo(const MDefinition* ins) const override {
if (!congruentIfOperandsEqual(ins))
return false;
return ins->isSignExtendInt64() && ins->toSignExtendInt64()->mode_ == mode_;
}
AliasSet getAliasSet() const override {
return AliasSet::None();
}
ALLOW_CLONE(MSignExtendInt64)
};
class MBinaryArithInstruction

3
js/src/jit/MOpcodes.h
View file

@ -66,7 +66,8 @@ namespace jit {
_(Lsh) \
_(Rsh) \
_(Ursh) \
_(SignExtend) \
_(SignExtendInt32) \
_(SignExtendInt64) \
_(MinMax) \
_(Abs) \
_(Clz) \

14
js/src/jit/Recover.cpp
View file

@ -335,32 +335,32 @@ RUrsh::recover(JSContext* cx, SnapshotIterator& iter) const
}
bool
MSignExtend::writeRecoverData(CompactBufferWriter& writer) const
MSignExtendInt32::writeRecoverData(CompactBufferWriter& writer) const
{
MOZ_ASSERT(canRecoverOnBailout());
writer.writeUnsigned(uint32_t(RInstruction::Recover_SignExtend));
writer.writeUnsigned(uint32_t(RInstruction::Recover_SignExtendInt32));
MOZ_ASSERT(Mode(uint8_t(mode_)) == mode_);
writer.writeByte(uint8_t(mode_));
return true;
}
RSignExtend::RSignExtend(CompactBufferReader& reader)
RSignExtendInt32::RSignExtendInt32(CompactBufferReader& reader)
{
mode_ = reader.readByte();
}
bool
RSignExtend::recover(JSContext* cx, SnapshotIterator& iter) const
RSignExtendInt32::recover(JSContext* cx, SnapshotIterator& iter) const
{
RootedValue operand(cx, iter.read());
int32_t result;
switch (MSignExtend::Mode(mode_)) {
case MSignExtend::Byte:
switch (MSignExtendInt32::Mode(mode_)) {
case MSignExtendInt32::Byte:
if (!js::SignExtendOperation<int8_t>(cx, operand, &result))
return false;
break;
case MSignExtend::Half:
case MSignExtendInt32::Half:
if (!js::SignExtendOperation<int16_t>(cx, operand, &result))
return false;
break;

6
js/src/jit/Recover.h
View file

@ -64,7 +64,7 @@ namespace jit {
_(Lsh) \
_(Rsh) \
_(Ursh) \
_(SignExtend) \
_(SignExtendInt32) \
_(Add) \
_(Sub) \
_(Mul) \
@ -246,13 +246,13 @@ class RUrsh final : public RInstruction
MOZ_MUST_USE bool recover(JSContext* cx, SnapshotIterator& iter) const;
};
class RSignExtend final : public RInstruction
class RSignExtendInt32 final : public RInstruction
{
private:
uint8_t mode_;
public:
RINSTRUCTION_HEADER_NUM_OP_(SignExtend, 1)
RINSTRUCTION_HEADER_NUM_OP_(SignExtendInt32, 1)
MOZ_MUST_USE bool recover(JSContext* cx, SnapshotIterator& iter) const;
};

18
js/src/jit/arm/CodeGenerator-arm.cpp
View file

@ -3364,6 +3364,24 @@ CodeGeneratorARM::visitExtendInt32ToInt64(LExtendInt32ToInt64* lir)
masm.ma_asr(Imm32(31), output.low, output.high);
}
void
CodeGeneratorARM::visitSignExtendInt64(LSignExtendInt64* lir)
{
Register64 input = ToRegister64(lir->getInt64Operand(0));
Register64 output = ToOutRegister64(lir);
switch (lir->mode()) {
case MSignExtendInt64::Byte:
masm.move8SignExtend(input.low, output.low);
break;
case MSignExtendInt64::Half:
masm.move16SignExtend(input.low, output.low);
break;
case MSignExtendInt64::Word:
break;
}
masm.ma_asr(Imm32(31), output.low, output.high);
}
void
CodeGeneratorARM::visitDivOrModI64(LDivOrModI64* lir)
{

1
js/src/jit/arm/CodeGenerator-arm.h
View file

@ -168,6 +168,7 @@ class CodeGeneratorARM : public CodeGeneratorShared
virtual void visitWrapInt64ToInt32(LWrapInt64ToInt32* lir);
virtual void visitExtendInt32ToInt64(LExtendInt32ToInt64* lir);
virtual void visitSignExtendInt64(LSignExtendInt64* ins);
virtual void visitAddI64(LAddI64* lir);
virtual void visitSubI64(LSubI64* lir);
virtual void visitMulI64(LMulI64* lir);

6
js/src/jit/arm/Lowering-arm.cpp
View file

@ -1028,3 +1028,9 @@ LIRGeneratorARM::visitExtendInt32ToInt64(MExtendInt32ToInt64* ins)
lir->setDef(0, def);
}
void
LIRGeneratorARM::visitSignExtendInt64(MSignExtendInt64* ins)
{
defineInt64(new(alloc()) LSignExtendInt64(useInt64RegisterAtStart(ins->input())), ins);
}

1
js/src/jit/arm/Lowering-arm.h
View file

@ -110,6 +110,7 @@ class LIRGeneratorARM : public LIRGeneratorShared
void visitInt64ToFloatingPoint(MInt64ToFloatingPoint* ins);
void visitCopySign(MCopySign* ins);
void visitExtendInt32ToInt64(MExtendInt32ToInt64* ins);
void visitSignExtendInt64(MSignExtendInt64* ins);
};
typedef LIRGeneratorARM LIRGeneratorSpecific;

6
js/src/jit/arm64/Lowering-arm64.cpp
View file

@ -366,3 +366,9 @@ LIRGeneratorARM64::visitExtendInt32ToInt64(MExtendInt32ToInt64* ins)
{
MOZ_CRASH("NYI");
}
void
LIRGeneratorARM64::visitSignExtendInt64(MSignExtendInt64* ins)
{
MOZ_CRASH("NYI");
}

1
js/src/jit/arm64/Lowering-arm64.h
View file

@ -109,6 +109,7 @@ class LIRGeneratorARM64 : public LIRGeneratorShared
void visitInt64ToFloatingPoint(MInt64ToFloatingPoint* ins);
void visitCopySign(MCopySign* ins);
void visitExtendInt32ToInt64(MExtendInt32ToInt64* ins);
void visitSignExtendInt64(MSignExtendInt64* ins);
};
typedef LIRGeneratorARM64 LIRGeneratorSpecific;

1
js/src/jit/none/Lowering-none.h
View file

@ -92,6 +92,7 @@ class LIRGeneratorNone : public LIRGeneratorShared
void visitWasmTruncateToInt64(MWasmTruncateToInt64*) { MOZ_CRASH(); }
void visitInt64ToFloatingPoint(MInt64ToFloatingPoint*) { MOZ_CRASH(); }
void visitExtendInt32ToInt64(MExtendInt32ToInt64* ins) { MOZ_CRASH(); }
void visitSignExtendInt64(MSignExtendInt64* ins) { MOZ_CRASH(); }
};
typedef LIRGeneratorNone LIRGeneratorSpecific;

25
js/src/jit/shared/LIR-shared.h
View file

@ -2702,19 +2702,34 @@ class LShiftI64 : public LInstructionHelper<INT64_PIECES, INT64_PIECES + 1, 0>
};
// Sign extension
class LSignExtend : public LInstructionHelper<1, 1, 0>
class LSignExtendInt32 : public LInstructionHelper<1, 1, 0>
{
MSignExtend::Mode mode_;
MSignExtendInt32::Mode mode_;
public:
LIR_HEADER(SignExtend);
explicit LSignExtend(const LAllocation& num, MSignExtend::Mode mode)
LIR_HEADER(SignExtendInt32);
explicit LSignExtendInt32(const LAllocation& num, MSignExtendInt32::Mode mode)
: mode_(mode)
{
setOperand(0, num);
}
MSignExtend::Mode mode() { return mode_; }
MSignExtendInt32::Mode mode() { return mode_; }
};
class LSignExtendInt64 : public LInstructionHelper<INT64_PIECES, INT64_PIECES, 0>
{
public:
LIR_HEADER(SignExtendInt64)
explicit LSignExtendInt64(const LInt64Allocation& input) {
setInt64Operand(0, input);
}
const MSignExtendInt64* mir() const {
return mir_->toSignExtendInt64();
}
MSignExtendInt64::Mode mode() const { return mir()->mode(); }
};
class LUrshD : public LBinaryMath<1>

3
js/src/jit/shared/LOpcodes-shared.h
View file

@ -73,7 +73,8 @@
_(BitOpV) \
_(ShiftI) \
_(ShiftI64) \
_(SignExtend) \
_(SignExtendInt32) \
_(SignExtendInt64) \
_(UrshD) \
_(Return) \
_(Throw) \

6
js/src/jit/x64/Assembler-x64.h
View file

@ -472,6 +472,9 @@ class Assembler : public AssemblerX86Shared
void movsbq(const Operand& src, Register dest) {
switch (src.kind()) {
case Operand::REG:
masm.movsbq_rr(src.reg(), dest.encoding());
break;
case Operand::MEM_REG_DISP:
masm.movsbq_mr(src.disp(), src.base(), dest.encoding());
break;
@ -491,6 +494,9 @@ class Assembler : public AssemblerX86Shared
void movswq(const Operand& src, Register dest) {
switch (src.kind()) {
case Operand::REG:
masm.movswq_rr(src.reg(), dest.encoding());
break;
case Operand::MEM_REG_DISP:
masm.movswq_mr(src.disp(), src.base(), dest.encoding());
break;

10
js/src/jit/x64/BaseAssembler-x64.h
View file

@ -652,6 +652,11 @@ class BaseAssemblerX64 : public BaseAssembler
m_formatter.immediate64(imm);
}
void movsbq_rr(RegisterID src, RegisterID dst)
{
spew("movsbq %s, %s", GPReg32Name(src), GPReg64Name(dst));
m_formatter.twoByteOp64(OP2_MOVSX_GvEb, src, dst);
}
void movsbq_mr(int32_t offset, RegisterID base, RegisterID dst)
{
spew("movsbq " MEM_ob ", %s", ADDR_ob(offset, base), GPReg64Name(dst));
@ -663,6 +668,11 @@ class BaseAssemblerX64 : public BaseAssembler
m_formatter.twoByteOp64(OP2_MOVSX_GvEb, offset, base, index, scale, dst);
}
void movswq_rr(RegisterID src, RegisterID dst)
{
spew("movswq %s, %s", GPReg32Name(src), GPReg64Name(dst));
m_formatter.twoByteOp64(OP2_MOVSX_GvEw, src, dst);
}
void movswq_mr(int32_t offset, RegisterID base, RegisterID dst)
{
spew("movswq " MEM_ob ", %s", ADDR_ob(offset, base), GPReg64Name(dst));

18
js/src/jit/x64/CodeGenerator-x64.cpp
View file

@ -794,6 +794,24 @@ CodeGeneratorX64::visitExtendInt32ToInt64(LExtendInt32ToInt64* lir)
masm.movslq(ToOperand(input), output);
}
void
CodeGeneratorX64::visitSignExtendInt64(LSignExtendInt64* ins)
{
Register64 input = ToRegister64(ins->getInt64Operand(0));
Register64 output = ToOutRegister64(ins);
switch (ins->mode()) {
case MSignExtendInt64::Byte:
masm.movsbq(Operand(input.reg), output.reg);
break;
case MSignExtendInt64::Half:
masm.movswq(Operand(input.reg), output.reg);
break;
case MSignExtendInt64::Word:
masm.movslq(Operand(input.reg), output.reg);
break;
}
}
void
CodeGeneratorX64::visitWasmTruncateToInt64(LWasmTruncateToInt64* lir)
{

1
js/src/jit/x64/CodeGenerator-x64.h
View file

@ -52,6 +52,7 @@ class CodeGeneratorX64 : public CodeGeneratorX86Shared
void visitTruncateFToInt32(LTruncateFToInt32* ins);
void visitWrapInt64ToInt32(LWrapInt64ToInt32* lir);
void visitExtendInt32ToInt64(LExtendInt32ToInt64* lir);
void visitSignExtendInt64(LSignExtendInt64* ins);
void visitWasmTruncateToInt64(LWasmTruncateToInt64* lir);
void visitInt64ToFloatingPoint(LInt64ToFloatingPoint* lir);
void visitLoadTypedArrayElementStatic(LLoadTypedArrayElementStatic* ins);

7
js/src/jit/x64/Lowering-x64.cpp
View file

@ -486,3 +486,10 @@ LIRGeneratorX64::visitExtendInt32ToInt64(MExtendInt32ToInt64* ins)
{
defineInt64(new(alloc()) LExtendInt32ToInt64(useAtStart(ins->input())), ins);
}
void
LIRGeneratorX64::visitSignExtendInt64(MSignExtendInt64* ins)
{
defineInt64(new(alloc()) LSignExtendInt64(useInt64RegisterAtStart(ins->input())), ins);
}

1
js/src/jit/x64/Lowering-x64.h
View file

@ -69,6 +69,7 @@ class LIRGeneratorX64 : public LIRGeneratorX86Shared
void visitWasmTruncateToInt64(MWasmTruncateToInt64* ins);
void visitInt64ToFloatingPoint(MInt64ToFloatingPoint* ins);
void visitExtendInt32ToInt64(MExtendInt32ToInt64* ins);
void visitSignExtendInt64(MSignExtendInt64* ins);
};
typedef LIRGeneratorX64 LIRGeneratorSpecific;

22
js/src/jit/x86/CodeGenerator-x86.cpp
View file

@ -1180,6 +1180,28 @@ CodeGeneratorX86::visitExtendInt32ToInt64(LExtendInt32ToInt64* lir)
}
}
void
CodeGeneratorX86::visitSignExtendInt64(LSignExtendInt64* lir)
{
Register64 input = ToRegister64(lir->getInt64Operand(0));
Register64 output = ToOutRegister64(lir);
MOZ_ASSERT(input.low == eax);
MOZ_ASSERT(output.low == eax);
MOZ_ASSERT(input.high == edx);
MOZ_ASSERT(output.high == edx);
switch (lir->mode()) {
case MSignExtendInt64::Byte:
masm.move8SignExtend(eax, eax);
break;
case MSignExtendInt64::Half:
masm.move16SignExtend(eax, eax);
break;
case MSignExtendInt64::Word:
break;
}
masm.cdq();
}
void
CodeGeneratorX86::visitWrapInt64ToInt32(LWrapInt64ToInt32* lir)
{

1
js/src/jit/x86/CodeGenerator-x86.h
View file

@ -77,6 +77,7 @@ class CodeGeneratorX86 : public CodeGeneratorX86Shared
void visitWasmReinterpretFromI64(LWasmReinterpretFromI64* lir);
void visitWasmReinterpretToI64(LWasmReinterpretToI64* lir);
void visitExtendInt32ToInt64(LExtendInt32ToInt64* lir);
void visitSignExtendInt64(LSignExtendInt64* ins);
void visitWrapInt64ToInt32(LWrapInt64ToInt32* lir);
void visitClzI64(LClzI64* lir);
void visitCtzI64(LCtzI64* lir);

11
js/src/jit/x86/Lowering-x86.cpp
View file

@ -649,3 +649,14 @@ LIRGeneratorX86::visitExtendInt32ToInt64(MExtendInt32ToInt64* ins)
LAllocation(AnyRegister(eax))));
}
}
void
LIRGeneratorX86::visitSignExtendInt64(MSignExtendInt64* ins)
{
// Here we'll end up using cdq which requires input and output in (edx,eax).
LSignExtendInt64* lir =
new(alloc()) LSignExtendInt64(useInt64RegisterAtStart(ins->input()));
defineInt64Fixed(lir, ins, LInt64Allocation(LAllocation(AnyRegister(edx)),
LAllocation(AnyRegister(eax))));
}

1
js/src/jit/x86/Lowering-x86.h
View file

@ -76,6 +76,7 @@ class LIRGeneratorX86 : public LIRGeneratorX86Shared
void visitWasmTruncateToInt64(MWasmTruncateToInt64* ins);
void visitInt64ToFloatingPoint(MInt64ToFloatingPoint* ins);
void visitExtendInt32ToInt64(MExtendInt32ToInt64* ins);
void visitSignExtendInt64(MSignExtendInt64* ins);
void lowerPhi(MPhi* phi);
static bool allowTypedElementHoleCheck() {