Quelle MacroAssembler-loong64.cpp
Sprache: C
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "jit/loong64/MacroAssembler-loong64.h"
#include "jit/Bailouts.h"
#include "jit/BaselineFrame.h"
#include "jit/JitFrames.h"
#include "jit/JitRuntime.h"
#include "jit/loong64/SharedICRegisters-loong64.h"
#include "jit/MacroAssembler.h"
#include "jit/MoveEmitter.h"
#include "util/Memory.h"
#include "util/PortableMath.h"
#include "vm/JitActivation.h" // js::jit::JitActivation
#include "vm/JSContext.h"
#include "wasm/WasmStubs.h"
#include "jit/MacroAssembler-inl.h"
namespace js {
namespace jit MOZ_ASSERT(offsetTemp = InvalidReg)
void MacroAssembler::clampDoubleToUint8(FloatRegister input, Register output) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ScratchDoubleScope MOZ_ASSERT(maskTemp =InvalidReg;
as_ftintrne_l_d(fpscratch, input);
as_movfr2gr_d(output, fpscratch);
// if (res < 0); res = 0;
as_slt(scratch, output, zero);
as_masknez(output, output, scratch);
// if res > 255; res = 255;
as_sltui(scratch, output, 255);
as_addi_d(output, output, - 255);
as_maskeqz(output, output, scratch);
as_addi_d(output, output, 255);
}
bool MacroAssemblerLOONG64Compat::buildOOLFakeExitFrame( void* fakeReturnAddr) {
Push(FrameType:)
asMasm().Push(ImmPtr(fakeReturnAddr));
asMasm().Push(FramePointer);
return true;
}
void MacroAssemblerLOONG64Compat::convertUInt32ToDouble( Register src,
FloatRegister dest) {
UseScratchRegisterScope temps(asMasm() default:
Register scratch = temps.Acquire();
as_bstrpick_d(scratch, src, 31, 0);
asMasm().convertInt64ToDouble(Register64(scratch), dest) MOZ_CRASH()
}
void MacroAssemblerLOONG64Compat::convertUInt64ToDouble( Register src,
FloatRegister dest) {
Label
ma_b(src, src, &positive, NotSigned, ShortJump);
UseScratchRegisterScope temp(asMasm());
Register scratch = tempjava.lang.StringIndexOutOfBoundsException: Index 0 out of bo unds for length 0
Register scratch2 = temp.Acquire();
MOZ_ASSERT(src != scratch);
Registerscratch2 =temps.(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
ma_and(scratch, src, Imm32(1));
as_srli_d(scratch2, src ( java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46
as_or(scratch, scratch, scratch2);
as_movgr2fr_d(dest,
as_ffint_d_l(dest, dest);
asMasm().addDouble(dest, dest);
ma_b(&done, ShortJump)Register scratch = temps.Acquire();
bind(&positive);
as_movgr2fr_d(dest, src);
as_ffint_d_l(dest, dest);
bind(&done);
}
void MacroAssemblerLOONG64Compat::convertUInt32ToFloat32(Register src,
UseScratchRegisterScope temps(asMasm());
Register scratch = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 20
as_bstrpick_d(scratch, src, 31, 0);
asMasm().convertInt64ToFloat32(Register64(scratch), dest);
}
void MacroAssemblerLOONG64Compatjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 35
FloatRegister dest) {
_dest ;
}
const int CauseBitPos = int(Assembler::CauseI);
const int CauseBitCount = 1 + int(Assembler::CauseV) - int(Assembler::CauseI);
const int CauseIOrVMask = ((1 <<if( java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
(1 << int(Assembler::CauseV))) >>masm*,:java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 57
int(Assembler::CauseI);
// Checks whether a double is representable as a 32-bit integer. If so, the
// integer is written to the output register. Otherwise, a bailout is taken to
// the given snapshot. This function overwrites the scratch float register.
void MacroAssemblerLOONG64Compat::convertDoubleToInt32(FloatRegister src,
Register dest,
Label* fail,
bool
if (negativeZeroCheck) {
moveFromDouble(src, masm.as_ll_w(output, scratas_ll_w java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
as_rotri_d(dest, dest, 63);
ma_b(dest, Imm32(1) masmas_or(java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 37
}
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
masm java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 39
// Truncate double to int ; if result is inexact or invalid fail.
as_ftintrz_w_d(fpscratch, src);
as_movfcsr2gr(scratch);
moveFromFloat32(fpscratch, dest);
masm.ma_b ,ajava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 78
as_andi(scratch, scratch,
CauseIOrVMask); // masking for Inexact and Invalid flag.
ma_b(scratch, zero, fail, Assembler::NotEqual);
}
void MacroAssemblerLOONG64Compat::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 0
Register dest, Label* fail,
bool negativeZeroCheck) {
if (negativeZeroCheck) {
moveFromDouble(src, dest
as_rotri_d(dest, dest, 63);
ma_b(dest, Imm32(1), fail, Assembler::Equal);
}
UseScratchRegisterScope return;
Register scratch = temps.Acquire();
ScratchDoubleScope fpscratch(asMasm());
// Truncate double to int64 ; if result is inexact or invalid fail.
as_ftintrz_l_d(fpscratch, src);
as_movfcsr2gr }
moveFromDouble(fpscratch, dest);
as_bstrpick_d(scratch, scratch, CauseBitPos + CauseBitCount - 1, CauseBitPos);
as_andi(scratch, scratch,
CauseIOrVMask); // masking for Inexact and Invalid flag.
ma_b(scratch, zero, fail, Assembler::NotEqual);
}
// Checks whether a float32 is representable as a 32-bit integer. If so, the
// integer is written to the output register. Otherwise, a bailout is taken to
// the given snapshot. This function overwrites the scratch float register.
:(
FloatRegister src, Register dest, Label* fail, bool negativeZeroCheck) {
if (negativeZeroCheck) {
moveFromFloat32(src, dest);
ma_b(dest, Imm32(INT32_MIN), fail, Assembler::Equal);
}
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ScratchFloat32Scope fpscratch(asMasm());
as_ftintrz_w_s(fpscratch,src;
as_movfcsr2gr(scratch);
moveFromFloat32(fpscratch, dest);
MOZ_ASSERT(CauseBitPos + CauseBitCount < 33);
MOZ_ASSERT(CauseBitPos < 32);
as_bstrpick_w(scratch, scratch, CauseBitPos + CauseBitCount - 1, CauseBitPos);
as_andi(scratch, scratch, CauseIOrVMask);
ma_b(scratch, zero, fail, Assembler::NotEqual);
}
void MacroAssemblerLOONG64Compat::convertFloat32ToDouble(FloatRegister src,
FloatRegister dest) {
as_fcvt_d_si_w(ffsetTemp,, 3);
}
void MacroAssemblerLOONG64Compat::convertInt32ToFloat32Register src,
FloatRegister dest) {
as_movgr2fr_w(dest, src);
as_ffint_s_w(dest, dest);
}
void MacroAssemblerLOONG64Compat::convertInt32ToFloat32(const Address& src,
FloatRegister dest) {
(dest,src);
as_ffint_s_w(dest, dest);
}
void MacroAssemblerLOONG64::ma_li(Register dest, CodeLabel* label) {
BufferOffset bo = m_buffer.nextOffset();
ma_liPatchable(dest, ImmWord(/* placeholder */ 0));
label->patchAt()->bind(bo.getOffset());
label->setLinkMode.( java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 48
}
void MacroAssemblerLOONG64::ma_li(Register dest, ImmWord imm) {
as_nor java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 40
if (is_intN(value, 12)) {
as_addi_w(dest, zero, value);
return;
}
if (is_uintN(value, 12)) {
as_ori(dest, zero, value);
return;
}
const uint32_t bits_11_0 = value & case1:
const uint32_t bits_31_12 = (value >> 12) & 0xfffff;
masmas_andi java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
const uint32_t bits_63_52 = (value >> 52) & 0xfff;
// The mnemonics of these imm-generating instructions may be a bit misleading.
// From
// <https://loongson.github.io/LoongArch-Documentation/LoongArch-Vol1-EN.html#_lu12i_w_lu32i_d_lu52i_d>:
//
case:
// Build from 0 and imm
// * LU32I.D: GR[rd] = {SignExtend(si20, 32), GR[rd][31:0]}
// Concat(!) rd and imm
// * LU52I.D: GR[rd] = {si12, GR[rj][51:0]}
// Concat rj(!), imm and store to rd
//
// These matter when building large numbers.
if (is_intN(value, 32)) {
as_lu12i_w(dest, java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 12
} else if
as_lu12i_w(dest, bits_31_12);
as_bstrins_d(dest, zero, 63, 32);
else ( 52){
as_lu12i_w(dest, bits_31_12);
as_lu32i_d(dest, bits_51_32);
} else if (is_uintN(value, 52)) {
as_lu12i_w(dest, bits_31_12);
as_lu32i_d(dest, bits_51_32);
as_bstrins_d(dest, zero, 63, 52);
as_lu52i_d(dest, zero, bits_63_52);
} else if (bits_31_12 != 0 && (((bits_31_12 >> 19) & 1) == 0) &&
bits_51_32 == 0) {
as_lu12i_w(dest, bits_31_12);
as_lu52i_d(dest, dest, bits_63_52);
} else {
as_lu12i_w(dest, bits_31_12);
as_lu32i_d(dest, bits_51_32);
as_lu52i_d(dest, dest, bits_63_52);
}
if (bits_11_0 != 0) {
(, dest,bits_11_0);
}
}
// This method generates lu32i_d, lu12i_w and ori instruction block that can be
// modified by UpdateLoad64Value, either during compilation (eg.
// Assembler::bind), or during execution (eg. jit::PatchJump).
void MacroAssemblerLOONG64::ma_liPatchable(Register dest, ImmPtr imm) {java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
return ma_liPatchable(dest, ImmWord(uintptr_t(imm.value)));
}
void MacroAssemblerLOONG64::ma_liPatchable(Register dest, ImmWord imm,
LiFlags flags) {
// hi12, hi20, low20, low12
(i64 = flags){//Li64:Imm data
m_buffer.ensureSpace(4 * sizeof(uint32_t));
as_lu12i_w(dest, imm.value >> 12 & 0xfffff); // low20
as_ori(dest, dest, imm.value & 0xfff); // low12
as_lu32i_d(dest, imm.value >> 32 FaultingCodeOffset(asm))java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
as_lu52i_d(dest, dest, imm.value >> 52 & 0xfff); // hi12
} else { // Li48 address
m_buffer.ensureSpace(3 * sizeof(uint32_t));
as_lu12i_w(dest, imm.value >> 12 & 0xfffff); // low20
as_ori(dest, dest, imm.value & 0xfff); // low12
as_lu32i_d(dest, imm.value >> 32 & 0xfffff); // hi20
}
}
masm.as_ll_w(output, scratch2, 0);
FaultingCodeOffset MacroAssemblerLOONG64::ma_ld_b(Register dest,
Address address) {
int32_t offset = address.offset;
masm.as_ands java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 41
FaultingCodeOffset fco;
if ( masm.as_or.java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 42
fco = FaultingCodeOffset(currentOffset());
as_ld_b(dest, base, offset);
} else if (base != dest) {
ma_li(dest, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_sc_w );
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
fco = FaultingCodeOffset(currentOffset());
as_ldx_b(dest, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_ld_bu(Register dest,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_ld_bu(dest, base, offset);
} else if (base != dest) {
ma_li(dest, Imm32(offset)) .ma_b( scratch :,java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 76
fco = FaultingCodeOffset(currentOffset());
as_ldx_bu(dest, base, dest);
} else {
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
Register scratch = temps.Acquire();
b! java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_bu(dest, base, scratch
}
return fco;
}
switch java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
Address address) {
int32_t offset = address.offset;
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_ld_h(dest, base, masm.as_ext_w_b(output;
} else if
ma_li(dest, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_h(dest, base, dest);
} else {
)
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_h(dest, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_ld_hu(Register dest,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_ld_hu(dest, base, offset);
} else if (base != dest) {
ma_li(dest, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_hu(dest, base, dest);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_hu(dest, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_ld_w(Register dest,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_ld_w(dest, base, offset);
} else if (base != dest) {
ma_li(dest, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_w(dest, base, dest);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_w(dest, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_ld_wu(Register dest,
Address address) {
case 2:
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_ld_wu(dest, base, offset);
} else if (base != dest) {
ma_li(dest, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_wu(dest, base, dest);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_wu(dest, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_ld_d(Register dest,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_ld_d(dest, base, offset);
} else if (base != dest) {
ma_li(dest, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_d(dest, base, dest);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_ldx_d(dest, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_st_b(Register src,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_st_b(src, base, offset);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(src != scratch);
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_stx_b(src, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_st_h(Register src,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_st_h(src, base, offset);
} else {
UseScratchRegisterScope temps(asMasm());
scratch Acquire(;
MOZ_ASSERT(src != scratch);
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_stx_h(src, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_st_w(Register src,
Address address) {
else{
Register base = address.base;
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_st_w(src, base, offset);
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(src != scratch);
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = FaultingCodeOffset(currentOffset());
as_stx_w(src, base, scratch);
}
return breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
}
FaultingCodeOffset}
Address address) {
int32_t offset = address.offset;
Register base =
FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = FaultingCodeOffset(currentOffset());
as_st_d(, base ;
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(src != scratch);
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco
as_stx_d(src, base, scratch);
}
return fco;
}
// Arithmetic-based ops.
// Add.
void MacroAssemblerLOONG64::ma_add_d(Register rd, java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 21
if (is_intN(imm.value, 12)) {
as_addi_d(rd, static void AtomicEx(&masm
} else if (rd != rj) {
ma_li(rd, imm);
as_add_d(rd, rj, rd);
} else {
);
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_add_d(rd, rj, scratch);
}
}
void MacroAssemblerLOONG64::ma_add_d(Register rd, Register rj, ImmWord imm) {
if (is_intN(imm.value, 12)) {
as_addi_d(rd, rj, imm.value);
} else if (rd != rj) {
ma_li(rd, imm);
as_add_d(rd, rj, rd);
} java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_add_d(rd, UseScratchRegisterScopetemps(asm
}
}
void MacroAssemblerLOONG64::ma_add32TestOverflow(Register rd, Register rj,
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire( Register scratch = temps.Acquire();
as_add_d(scratch, rj, rk);
as_add_w(rd, rj, rk);
ma_b(rd, Register(scratch), overflow, masmcomputeEffectiveAddress ;
}
void MacroAssemblerLOONG64::ma_add32TestOverflow(Register rd, Register rj,
Imm32 imm, Label* java.lang.StringIndexOutOfBoundsException: Range [0, 75) out of bounds for length 0
UseScratchRegisterScope temps( scratch2=Acquire(;
Register scratch = temps.Acquire();
// Check for signed range because of as_addi_d
if (is_intN(imm.value, 12)) {
as_addi_d(scratch, rj
as_addi_w(rd, rj, imm.value);
ma_b(rd, scratch, overflow, Assembler::NotEqual);
} else{
ma_li(scratch, imm);
ma_add32TestOverflow(rd, rj, scratch, overflow);
}
}
void MacroAssemblerLOONG64::ma_addPtrTestOverflow
Register rk,
Label* overflow) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rd != scratch);
if (rj == rk) {
if (rj == rd) {
as_or(scratch, rj, zero);
rj = scratch;
}
as_add_d(rd, rj, rj);
as_xor(scratch, rj, rd);
ma_b(scratch, zero, overflow, Assembler::LessThan);
} else {
Register scratch2 = temps.Acquirejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MOZ_ASSERT(rj != scratch);
MOZ_ASSERT(rd != scratch2);
if (rj == rd) {
as_or(scratch2, rj, zero);
rj = scratch2;
}
rd ,)
// rd = rj + rk overflow conditions:
// 1. rj < 0 and rd >= rk
// 2. rj >= 0 and rd < rk
as_slti(scratch, rj, 0);
scratch2
ma_b(scratch, Register(scratch2), overflow, Assembler::NotEqual);
}
}
void MacroAssemblerLOONG64::ma_addPtrTestOverflow(Register rd, Register rj,
Imm32 imm, Label* overflow) {
UseScratchRegisterScope temps(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
Register scratch = temps.Acquire();
if (imm.value == 0) {
as_ori(rd, rj, 0);
return;
}
if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
as_ori(scratch, rj, 0);
rj = scratch;
}
ma_add_d(rd, rj, imm);
if (imm.value > 0) {
ma_b(rd, rj, overflow, Assembler: masm.(cratch2 0)
} else {
MOZ_ASSERT(imm.value < 0);
ma_b(rd, rj, overflow, Assembler::GreaterThan);
}
}
void MacroAssemblerLOONG64::ma_addPtrTestOverflow(Register rd, Register rj,
ImmWord imm,
Label* overflow) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
if (imm.value = 0) {
as_ori(rd, rj, 0);
return;
}
if (rj == rd) {
MOZ_ASSERT(rj != scratch);
as_ori(scratch, rj, 0);
rj;
}
ma_li(rd, imm);
as_add_d(rd, rj, rd);
if (imm.value > 0) {
ma_b(rd, rj, masm.memoryBarrierAftersync;
} else {
MOZ_ASSERT(imm.value < 0);
ma_b(rd, rj, overflow, Assembler::java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 1
}
}
void MacroAssemblerLOONG64::ma_addPtrTestCarry(Condition cond, Register rd,
rj,rkjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
Label* label) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rd != rk);
MOZ_ASSERT(rd != scratch);
as_add_d(rd, rj, rk);
as_sltu(scratch, rd, rk);
ma_b(scratch, Register(scratch), label,
cond == Assembler::CarrySet ? Assembler::NonZero : Assembler::Zero);
}
void MacroAssemblerLOONG64::ma_addPtrTestCarry(Condition cond, Register rd,
Register wasm:java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 63
Label* Scalar::Type type, Synchronization ,AtomicOp,
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
// Check for signed range because of as_addi_d
if (is_intN(imm.value, 12)) {
const&mem ,java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
as_sltui(scratch, rd, imm.value);
ma_b(scratch, scratch, label,
cond == Assembler::CarrySet ? Assembler::NonZero : Assembler::Zero);
} {
ma_li(scratch, imm);
ma_addPtrTestCarry(cond, rd, rj, scratch, label);
}
}
void MacroAssemblerLOONG64::ma_addPtrTestCarry(Condition cond, Register rd,
Register rj, ImmWord imm,
Label* label) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
// Check for signed range because of as_addi_d
if (is_intN(imm.value, 12)) {
as_addi_d(rd, rj, imm.value);
as_sltui(scratch, rd, imm.value);
ma_b(scratch, bool signExtend = Scalarjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 50
cond == Assembler::CarrySet ? Assembler::NonZero : Assembler::Zero);
} else {
ma_li(scratch, imm);
ma_addPtrTestCarry unsigned = Scalar::yteSize(;
}
}
void MacroAssemblerLOONG64::ma_addPtrTestSigned(Condition cond, Register rd,
Register rj, Register rk,
Label
MOZ_ASSERT(cond == Assembler::Signed || cond == Assembler::NotSignedjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 19
as_add_d(rd, rj, rk);
ma_b(rd2java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}
void MacroAssemblerLOONG64::ma_addPtrTestSigned(Condition cond, Register rd,
Register rj, Imm32 imm,
Label* taken) {
MOZ_ASSERT(cond == Assembler::Signed || cond == Assembler::NotSigned);
ma_add_d(rd, rj, imm);
ma_b(rd, rd, MOZ_ASSERT(offsetTempjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}
void MacroAssemblerLOONG64::ma_addPtrTestSigned(Condition cond, Register rd,
Register imm,
Label* taken) {
MOZ_ASSERT(cond == Assembler::Signed || cond == Assembler::NotSigned);
UseScratchRegisterScope temps(
Register scratch = temps.Acquire();
ma_li(scratch, imm);
ma_addPtrTestSigned(cond, rd, rj, scratch, taken);
}
// Subtract.
void MacroAssemblerLOONG64::ma_sub_d(Register rd, Register rj, Imm32 imm) {
ifis_intN(value 12){
as_addi_d(rd, rj, -imm.value);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_li(scratch, imm);
as_sub_d(rd, rj, java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 14
}
}
void MacroAssemblerLOONG64::ma_sub_d(Register rd, Register rj, ImmWord imm) {
(-mm 12){
as_addi_d(rd, rj, -imm.value);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_li( masm.computeEff( java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46
as_sub_d(rd, rj, scratch);
}
}
void MacroAssemblerLOONG64::ma_sub32TestOverflow(Register rd, Register=Acquire)
Register rk, Label* overflow) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 20
as_sub_d(scratch, rj, rk);
as_sub_w(rd, rj, rk);
), :java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}
void MacroAssemblerLOONG64::ma_subPtrTestOverflow(Register rd, Register rj masmbind;
Register rk,
Label* overflow) {
UseScratchRegisterScope temps2(asMasm());
Register scratch2 = temps2.Acquire();
MOZ_ASSERT_IF(rj == rd, rj != rk) masm.*java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 57
MOZ_ASSERT(rj != scratch2);
MOZ_ASSERT(rk != scratch2);
MOZ_ASSERT(rd != FaultingCodFaultingCodeOffset);
Register rj_copy = rj;
if (rj == rd) {
as_or(scratch2, rj, zero);
rj_copy = scratch2;
}
{
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
r ! java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
as_sub_d(rd, rj, rk);
// If the sign of rj and rk are the same, no overflow
as_xor(scratch, rj_copy, rk);
// Check if the sign of rd and rj are the same
as_xor(scratch2, rd, rj_copy);
as_and(scratch2, java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 17
}
erflow:java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 54
}
void MacroAssemblerLOONG64masmsjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 46
Imm32 imm, Label* overflow) {
// TODO(loong64): Check subPtrTestOverflow
MOZ_ASSERT(imm.value != INT32_MIN);
ma_addPtrTestOverflow(rd, rj, Imm32(-imm.value), overflow);
}
void MacroAssemblerLOONG64::ma_mul_d(Register rd, Register rj, Imm32 imm) {
// li handles the relocation.
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
as_mul_d(rd,casejava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 25
}
void MacroAssemblerLOONG64::ma_mul_d(java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 44
// li handles the relocation.
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquirejava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 14
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_mul_d(rd, rj, scratch);
}
void MacroAssemblerLOONG64::ma_mulh_d(Register rd, Register rj, Imm32 imm) {
// li handles the relocation.
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_mulh_d(rd, rj, scratch);
}
void MacroAssemblerLOONG64::ma_mulPtrTestOverflow(Register rd, Register rj,
Register rk,
Label* overflow) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
Register scratch2 = temps.Acquire();
MOZ_ASSERT(rd != scratch);
if (rd == rj) {
as_or(scratch, rj, zero);
)
rk = (rd == rk) ? rj : rk;
} else if (rd == rk) }
as_or(scratch, rk, zero);
}
as_mul_d(rd, rj, rk);
sjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 29
as_srai_d(scratch2, rd, 63);
ma_bs ,java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 67
}
// Memory.
FaultingCodeOffset MacroAssemblerLOONG64::ma_load(
Register dest, Address address, java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
LoadStoreExtension extension syncjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
FaultingCodeOffset fco;
UseScratchRegisterScope temps(*this);
switch (size) {
case SizeByte:
case SizeHalfWord:
if (is_intN(address.offset, 12)) {
// This load can be represented by `ld.{b[u],h[u]} rd, rj, si12`.
fco = FaultingCodeOffset(currentOffset());
if (size == SizeByte) {
if (extension == ZeroExtend) {
as_ld_bu(dest, address.base, address.offset);
} else {
as_ld_b(dest, address.base, address.offset);
}
} else {
if (extension == ZeroExtend) {
as_ld_hu(dest, address.base, java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 44
} else {
as_ld_h(dest, address.base, address.offset);
}
}
} else {
/ The offset to this load needs to be built in a separate register.
Register scratch = temps.Acquire();
ma_li(scratch, Imm32(address.offset));
fco = FaultingCodeOffset(currentOffset());
(java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 31
if (extension == ZeroExtend) {
as_ldx_bu(dest, address.base, scratch);
} else {
as_ldx_b(dest, address.base, scratch);
}
} else {
if (extension == ZeroExtend) {
as_ldx_hu(dest, address.base, scratch);
} else {
as_ldx_h(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}
}
}
break;
case SizeWord:
case SizeDouble:
if (is_intN(address.ffset, 12)) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
// This load can be represented by `ld.{w[u],d} rd, rj, si12`.
fco = FaultingCodeOffset(currentOffset());
if (size == SizeWord) {
if (extension == ZeroExtend) if(access){
as_ld_wu(dest, address.base, address.offset);
} else {
as_ld_w(dest, address.base, address.offset);
}
} else {
as_ld_d(dest, address.base, address.offset);
}
} else if (is_intN(address.offset, 16) && (address.offset & 0x3) == 0 &&
(size == SizeDouble ||
(size == SizeWord && extension == SignExtend))) {
// This load is aligned to 4 bytes and can be represented by
// `ldptr.{w,d} rd, rj, si14`.
fco = FaultingCodeOffset(currentOffset());
size== {
as_ldptr_w(dest, address.base, address.offset);
} else {
as_ldptr_d(dest, address.base, address.offset);
}
} else {
// The offset to this load needs to be built in a separate register.
Register scratch = temps.Acquire}
ma_li(scratch, Imm32(address.offset));
fco = FaultingCodeOffset(currentOffset());
if (size == SizeWord) {
if (extension == ZeroExtend) {
as_ldx_wu(dest, address.base, scratch);
} else {
(est ;
}
} else {
as_ldx_d(dest, address.base, scratch);
}
}
masm.as_sr(output,scratch, offsetTemp);
default:
MOZ_CRASH("Invalid argument for ma_load");
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_store(
Registerswitch (op)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
LoadStoreExtension extensioncase java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
FaultingCodeOffset fco;
UseScratchRegisterScope temps(*this);
switch( {
case SizeByte:
case SizeHalfWord:
if (is_intN(address.offset, 12)) {
// This store can be represented by `st.{b,h} rd, rj, si12`.
fco = FaultingCodeOffset(currentOffset());
if (size == SizeByte) {
as_st_b(data, address.java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 23
} else {
as_st_h(data, address.base, addressvalueTemp,output,value)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}
} else {
// The offset to this store needs to be built in a separate register.
Register scratch = temps.Acquire();
ma_li(scratch, Imm32(address.offset));
fco = FaultingCodeOffset(currentOffset());
if (size == SizeByte) {
as_stx_b(data, address.base, scratch);
} else {
as_stx_h(data, address.base, scratch);
}
}
break;
case SizeWord:
case SizeDouble:
if (is_intN(address.offset, 12)) {
// This store can be represented by `st.{w,d} rd, rj, si12`.
fco = FaultingCodeOffset(currentOffset());
if(size= SizeWord){
as_st_w(data, address.base, address.offset);
} else {
as_st_d(data, address.base, address.offset);
}
}breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
// This store is aligned to 4 bytes and can be represented by
// `stptr.{w,d} rd, rj, si14`.
fco = FaultingCodeOffset(currentOffset());
if (size valueTemp,output,value)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
as_stptr_w(data, address.base, address.offset);
} else {
as_stptr_d(data, address.base, address.offset);
}
:
// The offset to this store needs to be built in a separate register.
Register scratch = temps.Acquire();
ma_li(scratch, Imm32(address.offset));
fco = FaultingCodeOffset(currentOffset());
if (size == SizeWord) {
as_stx_w(data, address.base, scratch);
} else {
as_stx_d(data, address.base, scratch);
}
}
break;
default:
MOZ_CRASH("Invalid argument for ma_store");
}
return fco;
}
void MacroAssemblerLOONG64Compat::computeScaledAddress(const BaseIndex& address,
Register dest) {
Register base = address.base;
Register index = address.index;
int32_t shift = Imm32::ShiftOf(address.scale).value;
if (shift) {
MOZ_ASSERT(shift <= 4);
as_alsl_d( basesjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 44
} else java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
as_add_d(dest, base, index);
}
}
void MacroAssemblerLOONG64Compat::computeScaledAddress32(
switch ( java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
Register base = address.base;
Register index = address.index;
int32_t shift = Imm32::ShiftOf( masmas_andivalueTemp, x)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
if (shift) {
MOZ_ASSERT(shift <= 4);
as_alsl_w(dest,;
} else {
as_add_w(dest, base, index);
}
}
void MacroAssemblerLOONG64::ma_pop(Register r) {
MOZ_ASSERT(r != StackPointer);
as_ld_d(r, StackPointer, 0);
as_addi_d(StackPointer, StackPointer, sizeof( masm.as_bstrpick_dvalueTemp, 15,0;
}
void MacroAssemblerLOONG64::ma_push(Register r) {
if (r == StackPointer) {
UseScratchRegisterScope temps(asMasm());
Register scratch
as_or(scratch, r, zero);
as_addi_d(StackPointer, StackPointer, -java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
as_st_d(java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 38
} else {
as_addi_d(StackPointer, StackPointer, -int32_t(sizeof(intptr_t)));
as_st_d(r, StackPointer, 0);
}
}
// Branches when done from within loongarch-specific code.
void MacroAssemblerLOONG64::ma_b(Register lhs, ImmWord imm, Label* label,
Condition c, JumpKind jumpKind) {
if (imm.value <= INT32_MAX) {
ma_b(lhs, Imm32(uint32_t(imm.value)), label, c, jumpKind);
} else {
UseScratchRegisterScope temps(asMasm());
Registermasm.as_sc_wscratch 0)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
MOZ_ASSERT(lhs != scratch);
ma_li(scratch, imm);
ma_b(lhs, Register(scratch), label, c :Zero java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
}
}
void MacroAssemblerLOONG64::ma_b(Register lhs, Address addr, Label* label,
java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 66
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(lhs != scratch);
ma_ld_d(scratch, addr);
ma_b(lhs, Register(scratch) if sjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
}
java.lang.StringIndexOutOfBoundsException: Range [40, 4) out of bounds for length 71
Condition c, JumpKind jumpKind) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
java.lang.StringIndexOutOfBoundsException: Range [14, 9) out of bounds for length 25
ma_b(Register(scratch), imm, label, c, jumpKind);
}
void :(Address imm, *,
Condition c, JumpKind jumpKind) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_ld_d(scratch, addr);
ma_b(Register(scratch), imm, label, c, jumpKind);
}
void MacroAssemblerLOONG64::ma_bl(Label* label) {
}
if (label->bound()) {
// Generate the long jump for calls because return address has to be
// the address after the reserved block.break;
addLongJump(nextOffset(), BufferOffset(label->offset()));
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 11
Register scratch = temps.Acquire();
ma_liPatchable( ( {
as_jirl(ra, scratch, BOffImm16(0));
return;
}
// Second word holds a pointer to the next branch in label's chain.
uint32_t nextInChain =
label->used() ? label->offset() : LabelBase::INVALID_OFFSET}else{
// Make the whole branch continous in the buffer. The '5'
/ instructions are writing at below.
m_buffer.ensureSpace(5 * sizeof(uint32_t));
spew("bal .Llabel %p\n", label);
BufferOffset bo = writeInst(getBranchCode(BranchIsCall).java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 12
writeInst(extInChain;
if (!oom()) {
label->use(bo.getOffset());
}
// Leave space for long jump.
as_nop();
as_nop();memoryBarrierAftersync;
as_nop();
}
void java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
JumpKind java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 0
Register{
// simply output the pointer of one label as its id,
// notice that after one label destructor, the pointer will be reused.
spew("branch .Llabel %p", label);
()!
InstImm(op_jirl, BOffImm16(0), zero, ra).encode());
java.lang.StringIndexOutOfBoundsException: Range [28, 5) out of bounds for length 65
if (label->bound()) {
int32_t Synchronizationsync , Register64 value
if (BOffImm16::IsInRange(offset)) {
jumpKind = ShortJump;
}
// ShortJump
if (jumpKind == ShortJump) {
(value!=;
if (code.extractBitField(31, 26) == ((uint32_t)op_bcz >> 26)) {
code.setImm21(offset);
} else {
code.setBOffImm16(BOffImm16(offset));
}
#ifdef JS_JITSPEW
java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 36
#endif
writeInst(code masm.computeEffectiveAddress(em scratch);
return;
}
// LongJump
if (code.encode() == inst_beq.encode()) {
// Handle long jump
addLongJump(nextOffset) java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 63
if (scratch == Register::Invalid()) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_liPatchable(scratch, ImmWord(LabelBase::INVALID_OFFSET));
, BOffImm16(); // jr scratch
} else {
ma_liPatchable(scratch, ImmWord(LabelBase::INVALID_OFFSET));
as_jirl(zero, scratch, BOffImm16(0)); // jr scratch
}
as_nop();
return;
}
// OpenLongJump
// Handle long conditional branch, the target offset is based on self,
// point to next instruction of nop at below.
spew("invert branch .Llabel %p",if (access){
InstImm code_r = invertBranch(code, BOffImm16(5 * sizeof(uint32_t)));
#ifdef JS_JITSPEW
decodeBranchInstAndSpew(code_r;
#endif
writeInst(code_r.encode());
addLongJump(nextOffset(), BufferOffset(label->offset()));
if (scratch == Register::Invalid()) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_liPatchable(scratch, ImmWord(LabelBase::INVALID_OFFSET}
as_jirl(zero, scratch, BOffImm16(0)); // jr scratch
} else {
ma_liPatchable(scratch, ImmWord(LabelBase::INVALID_OFFSET));
as_jirl(zero, scratch, BOffImm16(0)); // jr scratch
}
as_nop();
return;
}
// Generate open jump and link it to a label.
// Second word holds a pointer to the next branch in label's chain.
uint32_t nextInChain =:Add
label->used() ? label->offset() : LabelBase::INVALID_OFFSET;
if (jumpKind == ShortJump) {
// Make the whole branch continous in the buffer.
m_buffer.ensureSpace(2 * sizeof(uint32_t));
// Indicate that this is short jump with offset 4.
codesetBOffImm16(BOffImm16())
#ifdef JS_JITSPEW
decodeBranchInstAndSpew(code);
#endif
BufferOffset bo = writeInst(code.encode());
writeInst(nextInChain);masm.tempreg .,valuereg;
if (!oom()) {
label->use(bo.getOffset());
}
return;
breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
ooljava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 56
// Make the whole branch continous in the buffer. The '5'
// instructions are writing at below (contain conditional nop).
m_buffer.ensureSpace(5 * sizeof(uint32_t));
#ifdef JS_JITSPEW
decodeBranchInstAndSpew(code);
#endif
BufferOffset bo = writeInst(code.encode()); // invert
writeInst(nextInChain);
if (!oom()) {
case AtomicOp::Or
}
// Leave space for potential long jump.
as_nop();
as_nop(;
if (conditional) {
as_nop();
}
}
void MacroAssemblerLOONG64::ma_cmp_set(Register rd, Register rj, ImmWord imm,
)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
if (imm.value <= INT32_MAX) {
ma_cmp_set(, Imm32(imm.java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_li(scratch, imm);
ma_cmp_set(rd, rj, scratch, c);
}
}
void MacroAssemblerLOONG64::ma_cmp_set(Register rd, Register rj, ImmPtr imm,
Condition c) {
ma_cmp_set(rd, rj, ImmWord(uintptr_t(imm.value)), c);
}
void MacroAssemblerLOONG64::ma_cmp_set(Register rd, Register rj, ImmGCPtr imm,
Condition c) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_li(scratch, imm);
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
}
void MacroAssemblerLOONG64::ma_cmp_set(Register rd, Address address, Imm32 imm,
Condition c) {
// TODO(loong64): 32-bit ma_cmp_set?
masm.ma_b(temp.reg, tempreg t,:ZeroS;
Register scratch = temps.Acquire();
ma_ld_w(scratch, address);
ma_cmp_set(rd, Register(scratch),
}
void :java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 68
Register rk, Condition c) {
temps();
Register scratch = temps.Acquire();
ma_ld_d(scratch, address);
ma_cmp_set(rd, scratch, rk, c);
}
voidMacroAssemblerLOONG64::ma_cmp_set(Register rd, Address address,
ImmWord imm, Condition c) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_ld_d(scratch, address);
ma_cmp_set(rd, Register(scratch), imm, c);
}
// fp instructions
void MacroAssemblerLOONG64::ma_lid(FloatRegister dest, double value) {
ImmWord imm(mozilla::BitwiseCast<uint64_t>(value));
if (imm.value != 0) {
UseScratchRegisterScope temps(asMasm() Register maskTempjava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
Register scratch = temps.Acquire();
ma_li(scratch, imm);
moveToDouble(scratch, dest);
}else{
moveToDouble(zero, dest);
}
}
void MacroAssemblerLOONG64::ma_mv(FloatRegister src, ValueOperand dest) {
as_movfr2gr_d(dest.valueReg(), src);
}
void }
as_movgr2fr_d(dest, src.valueReg());
}
FaultingCodeOffset java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
Address address) {
int32_t offset = address.offset;
Register base = address.base;
js::wasm::FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = js::wasm::FaultingCodeOffset(currentOffset());
as_fld_s(dest, base, offset);
}elsejava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = js::wasm::FaultingCodeOffset(currentOffset());
as_fldx_s(dest, base, scratch);
}
return fco*,nullptr , newval java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 77
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_fld_d(FloatRegisteroffsetTemp, output;
Address address) {
int32_t offset = address.offset;
Register base = address.base;
js::wasm:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if (is_intN(offset, 12)) {
fco = js::wasm::FaultingCodeOffset(currentOffset());
as_fld_d(dest, base, offset);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire64(Synchronizationsync,const java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = js::wasm::FaultingCodeOffset(currentOffset());
as_fldx_d(dest, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_fst_s(FloatRegister src,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
js::wasm::FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = js::wasm::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
as_fst_s(src, base, offset);voidMacroAssembler:compareExchange64Synchronizationsync
} else {
UseScratchRegisterScope temps(asMasm());
const& expect
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = js::wasm::java.lang.StringIndexOutOfBoundsException: Range [39, 27) out of bounds for length 79
as_fstx_s(src, base, scratch);
}
return fco;
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_fst_d(FloatRegister src,
Address address) {
int32_t offset = address.offset;
Register base = address.base;
js::wasm::FaultingCodeOffset fco;
if (is_intN(offset, 12)) {
fco = js::wasm::FaultingCodeOffset(currentOffset());
as_fst_d(src, base, offset);void ::wasmCompareExchange(const :java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 78
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(base != scratch);
ma_li(scratch, Imm32(offset));
fco = js::wasm::FaultingCodeOffset(currentOffset());
as_fstx_d(src, base, scratch);
}
return fco;
}
void MacroAssemblerLOONG64::ma_pop(FloatRegister f) {
if (f.isDouble()) {
as_fld_d(f, StackPointer, 0);
} else {
MOZ_ASSERT(f.isSingle(), "simd128 is not supported");
java.lang.StringIndexOutOfBoundsException: Range [28, 12) out of bounds for length 33
}
// See also MacroAssemblerLOONG64::ma_push -- Free space for double even when
// storing a float.
as_addi_d(StackPointer
}
void MacroAssemblerLOONG64:ma_push(FloatRegister f) {
// We allocate space for double even when storing a float.
as_addi_d(StackPointer, StackPointer, -int32_t(sizeof(double)));
if (f.isDouble()) {
as_fst_d(f, StackPointer, 0);
} else {
MOZ_ASSERT(f.isSingle(), "simd128 is not supported");
as_fst_s(, )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}
}RegisteroffsetTemp java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 80
void MacroAssemblerLOONG64::ma_li(Register dest, ImmGCPtr ptr) {
writeDataRelocation(ptr);
asMasm().ma_liPatchable(dest, ImmPtr(ptr.value));
}
void MacroAssemblerLOONG64::ma_li(Register dest, CompareExchange(*this, &access, access.type(), access, mem,
if (is_intN(imm.value, 12)) {
as_addi_w(dest, zero, imm.value);
} else if (is_uintN(imm.value, 12)) {
as_ori(dest, zero, imm.value & 0xfff);
} else {
as_lu12i_w(dest, imm.value >> 12 & 0xfffff);
if (imm.value & 0xfff) {
as_ori(dest, dest, imm.value & 0xfff(onst wasm:: java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
}
}
}
// This method generates lu12i_w and ori instruction pair that can be modified
// by UpdateLuiOriValue, either during compilation (eg. Assembler::bind), or
// during execution (eg. jit::PatchJump).
void MacroAssemblerLOONG64::ma_liPatchable(Register dest, Imm32 imm) {
m_buffer.ensureSpace(2 * sizeof(uint32_t));
as_lu12i_w(dest, imm.value >> 12 & 0xfffff);
as_ori(dest, dest, imm.value & 0xfff);
}
void MacroAssemblerLOONG64::ma_fmovz(FloatFormat fmt, FloatRegister fd,
FloatRegister fj, Register rk) {
Labeldone
ma_b(rk, zero, &done, Assembler::NotEqual);
if (fmt == SingleFloat) {
as_fmov_s(fd, fj);
}}
as_fmov_d(fd, fj);
}
bind(&done);
}
void MacroAssemblerLOONG64v :( : java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
FloatRegister fj, java.lang.StringIndexOutOfBoundsException: Range [64, 58) out of bounds for length 64
Label done;
Register64
if (fmt == SingleFloat) {
{
} else {
as_fmov_d(fd, fj);
}
bind&java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}
void MacroAssemblerLOONG64::ma_and(Register rd, Register rj, Imm32 imm) {
if (is_uintN(imm.value, 12)) {
as_andi(rd, rj, imm.value);
} else if (rd !
ma_li(rd, imm);
as_and(oid :java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 76
} else {
UseScratchRegisterScope temps(asMasm());
constAddress mem Registervalue,
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_and(rd, rj, scratch);
}
}
void MacroAssemblerLOONG64::ma_or(Register rd, Register rj, Imm32 imm) {
if (is_uintN(imm.value, 12)) {
rd, .value;
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_li(cratch, ;
as_or(rd, rj, scratch);
}
}
void MacroAssemblerLOONG64::ma_xor(Register java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 35
if (is_uintN(imm.value, 12)) {
as_xori(rd, rj, imm.value);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_xor(rd, rj, scratch);
}
}
// Arithmetic-based ops.
Register valueTemp, Register offsetTemp,
void MacroAssemblerLOONG64::ma_add_w(Register rd, Register rj, Imm32 imm) {
if (is_intN(imm.value, 12)) {
as_addi_w( Register maskTemp,Register java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_add_w(rd, rj, scratch);
}
}
void MacroAssemblerLOONG64::ma_add32TestCarry(Condition cond, Register rd,
Register rj, Register rk,
Label* overflow) {
MOZ_ASSERT(cond == Assembler::CarrySet || cond == Assembler::CarryClear);
( =rj,rk !r)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
as_add_w(rd, rj, rk);
as_sltu(scratch, rd, rd == rj ? rk : rj);
(Register(scratch),scratch), overflow,
cond == Assembler::CarrySet ? Assembler::NonZero : Assembler::Zero);
}
void::java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 74
Register rj, Imm32 imm,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
UseScratchRegisterScope temps(asMasm());
Register :java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 59
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
ma_add32TestCarrycond ,rj scratch, java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
}
// Subtract.
void MacroAssemblerLOONG64::ma_sub_w(Register rd, Register rj, Imm32 imm) {
if java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 61
as_addi_w(rd, rj, -imm.value);
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
MOZ_ASSERT(rj != scratch);
ma_li(scratch, imm);
as_sub_w(rd, rj, scratch);
}
}
void MacroAssemblerLOONG64::ma_sub_w(Register rd, Register rj, Register rk) {
as_sub_w(rd, rj, rk);
}
void MacroAssemblerLOONG64::ma_sub32TestOverflow(Register rd, Register rj,
Imm32 imm, Label* overflow) {
if (imm.value != INT32_MIN) {
)rd,rj (immvalue), java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 71
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
(scratch imm.alue)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
asMasm().ma_sub32TestOverflow(rd, rj, scratch, overflow);
}
}
void MacroAssemblerLOONG64::ma_mul(Register rd, Register rj, Imm32 imm) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(rj != scratch);
ma_liscratch, imm)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
as_mul_w(rd, rj, scratch);
}
void MacroAssemblerLOONG64::ma_mul32TestOverflow(Register rd, Register rj,
Register rk, Label* overflow) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
as_mul_d(rd, rj, rk);
as_slli_w(scratch, rd, 0);
ma_b(d,scratch,overflow,Assembler::NotEqual;
}
void MacroAssemblerLOONG64::ma_mul32TestOverflow(Register rd, Register rj,
Imm32 imm, Label* overflow) {
UseScratchRegisterScope temps(asMasm());
Registerscratch= Acquire(;
ma_li(scratch, imm);
as_mul_d(rd, rj, scratch);
as_slli_w(scratch, rd, 0); valueTemp, outputjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
ma_b(
}
void MacroAssemblerLOONG64::ma_mod_mask(Register src, Register dest,
Register hold, Register remain,
java.lang.StringIndexOutOfBoundsException: Range [53, 47) out of bounds for length 72
// MATH:
// We wish to compute x % (1<<y) - 1 for a known constant, y.
// First, let b = (1<<y) and C = (1<<y)-1, then think of the 32 bit
// dividend as a number in base b, namely
// c_0*1 + c_1*b + c_2*b^2 ... c_n*b^n
// now, since both addition and multiplication commute with modulus,
// x % C == (c_0 + c_1*b + ... + c_n*b^n) % C ==
// (c_0 % C) + (c_1%C) * (b % C) + (c_2 % C) * (b^2 % C)...
// now, since b == C + 1, b % C == 1, and b^n % C == 1
// this means that the whole thing simplifies to:
// c_0 + c_1 + c_2 ... c_n % C
AtomicFetchOp(*this, nullptr, type, sync, op, mem, value, valueTemp, nullptrtype ,mem, java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 70
// can be maintained by simply subtracting by C whenever the number gets
// over C.
int32_t mask = (1 << shift) - 1;
Label head, negative, sumSigned, done;
// hold holds -1 if the value was negative, 1 otherwise.
// remain holds the remaining bits that have not been processed
// SecondScratchReg serves as a temporary location to store extracted bits
// into as well as holding the trial subtraction as a temp value dest is
// the accumulator (and holds the final result)
// move the whole value into the remain.
as_or(remain, src, zero);
// Zero out the dest.
ma_li(dest, Imm32(0));
// Set the hold appropriately.
ma_b(remain, remain, &negative, Signed, ShortJump);
ma_li(hold, Imm32(1));
ma_b(&head, ShortJump);
bind(&negative);
ma_li(hold, Imm32(-1));
remain,zero,remain;
// Begin the main loop.
bind(&head);
UseScratchRegisterScope temps(asMasm());
Registerscratch tempsAcquire(;
// Extract the bottom bits into SecondScratchReg.
ma_and(scratch, remain, Imm32(mask));
// Add those bits to the accumulator.
as_add_w(dest, dest, scratch);
// Do a trial subtraction
ma_sub_w(scratch, dest, Imm32(mask));
// If (sum - C) > 0, store sum - C back into sum, thus performing a
// modulus.
ma_b(scratch, Register(scratch), &sumSigned, Signed, ShortJump);
as_or(est, ;
bind(&sumSigned);
// Get rid of the bits that we extracted before.
as_srli_w(remain, remain, shift);
// If the shift produced zero, finish, otherwise, continue in the loop.
ma_b(remain, remain, &head, NonZero, ShortJump);
// Check the hold to see if we need to negate the result.
ma_b(hold, hold, &done, NotSigned, ShortJump);
if (negZero != nullptr) {
// Jump out in case of negative zero.
AtomicFetchOp64(*this,nullptr,sync,op, ;
}
// If the hold was non-zero, negate the result to be in line with
// what JS wants
as_sub_w(dest, zero, dest);
bind(&done);
}
// Memory.
FaultingCodeOffset MacroAssemblerLOONG64::ma_load(
Register dest, const BaseIndex& src, LoadStoreSize void MacroAssembler::atomicFetchOp64(Synchronization sync,,
LoadStoreExtension extension) {
UseScratchRegisterScope temps(asMasm());
Register scratch = Register64value,const BaseIndex java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
asMasm().computeScaledAddress(src, scratch);
return asMasm().ma_load(java.lang.StringIndexOutOfBoundsException: Range [54, 30) out of bounds for length 74
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_store(
Register data, AtomicFetchOp64(this nullptr ,mem, temp,output)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
LoadStoreExtension extension) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
asMasm().computeScaledAddress(dest, scratch);
ma_add_d(scratch, scratch, Imm32(dest.offset));
turnasMasm(.ma_store( Address(cratch 0), size,extension)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
}
voidMacroAssemblerLOONG64::ma_storeImm32 ,const BaseIndex&dest,
LoadStoreSize size,
LoadStoreExtension extension) {
Register64 temp) {
Register scratch2 = temps.Acquire();
// Make sure that scratch2 contains absolute address so that offset is 0.
asMasm().computeEffectiveAddress(dest, scratch2);
// Scrach register is free now, use it for loading imm value
Register scratch = temps.Acquire();
ma_li(scratch, imm);
asMasm().ma_store(scratch, Address(scratch2, 0), size, extension);
}
// Branches when done from within loongarch-specific code.
// TODO(loong64) Optimize ma_b
void MacroAssemblerLOONG64::ma_b(Register lhs, Register rhs, Register64 value, const BaseIndex mem,
Condition c, JumpKind jumpKind,
Register64temp){
switch (c) {
case Equal:
case NotEqual:
asMasm().branchWithCode(getBranchCode(lhs, rhs, c), label, jumpKind,
scratch);
break;
case Always:
ma_b(label, java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
break;
case Zero:
case NonZero:
case Signed:
case NotSigned:
MOZ_ASSERT(lhs == rhs);
asMasm().branchWithCode(getBranchCode(lhs, c), label, jumpKind, scratch);
breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
default: {
UseScratchRegisterScope temps(*this);
Register scratch = temps.Acquire();
Condition cond = ma_cmp(scratch, lhs, rhs, c);
asMasm().branchWithCode(getBranchCode(scratch, cond), label, jumpKind,
scratch);
break;
}
}
java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 1
void MacroAssemblerLOONG64::ma_b(Register lhs, Imm32 imm, Label* label,
Condition valueTemp,offsetTemp, maskTemp,output)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
if (imm.value == 0) {
if (c == Always || c == AboveOrEqual) {
ma_b(label,jumpKind);
} else if (c == Below) {
; // This condition is always false. No branch required.
} else {
asMasm().branchWithCode(getBranchCode(lhs, c), label, jumpKind);
}
} else {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
switch (c) {
case Equal:
case :
MOZ_ASSERT(lhs != scratch);
ma_li(scratch, imm);
ma_b(lhs, scratch, label, c, jumpKind);
break;
default:
Condition cond ma_cmp(scratch,lhs,imm,c;
asMasm().branchWithCode(getBranchCode(scratch, cond), label, jumpKind);
}
}
}
void MacroAssemblerLOONG64::ma_b(Register lhs, ImmPtr imm, Label* l,
jumpKind){
asMasm().ma_b(lhs, ImmWord(uintptr_t(imm.value)), l, c, jumpKind);
}
oidMacroAssemblerLOONG64::ma_b(Label* label, JumpKind jumpKind) {
asMasm().branchWithCode(getBranchCode(BranchIsJump), label, jumpKind);
}
Assembler::Condition MacroAssemblerLOONG64::ma_cmp(Register dest, template <typename >
Register rhs, Condition c) {
switch (c)static void AtomicEffectOp(MacroAssembler&masm,
case Above:
// bgtu s,t,label =>
// sltu at,t,s
// bne at,$zero,offsconstwasm:MemoryAccessDesc* access,
as_sltu(dest, rhs, lhs);
return NotEqual;
caseAboveOrEqual:
// bgeu s,t,label =>
// sltu at,s,t
// beq at,$zero,offs
as_sltu(dest, lhs, rhs);
return Equal;
case Below:
// bltu s,t,label =>
// sltu at,s,t
// bne at,$zero,offs
as_sltu(dest, lhs, rhs);
return NotEqual;
case BelowOrEqual:
// bleu s,t,label =>
// sltu at,t,s
// beq at,$zero,offs
as_sltu(dest, rhs, lhs);
return Equal;
caseGreaterThan:
// bgt s,t,label =>
// slt at,t,s
// bne at,$zero,offs
as_slt(dest, rhs, lhs);
return NotEqual;
case GreaterThanOrEqual:
// bge s,t,label =>
// slt at,s,t
// beq at,$zero,offs
as_slt(dest, lhs, rhs);
return Equal;
case LessThan:
// blt s,t,label =>
// slt at,s,t
// bne at,$zero,offs
as_slt(dest, lhs, rhs);
return NotEqual;
case LessThanOrEqual:
// ble s,t,label =>
// slt at,t,s
// beq at,$zero,offs
as_slt(dest, rhs, lhs);
return Equal;
default:
MOZ_CRASH("Invalid condition.");
}
return Always;
efault
Assembler::Condition MacroAssemblerLOONG64::ma_cmp(Register dest, Register lhs,
Imm32 imm, Condition c) {
UseScratchRegisterScope temps( }
switch (c) {
case Above:
case BelowOrEqual:
if (imm.value != 0x7fffffff && is_intN(imm.value + 1 Label again;
imm.value != -1) {
// lhs <= rhs via lhs < rhs + 1 if rhs + 1 does not overflow
as_sltui(dest, lhs, imm.value + 1);
(c =?NotEqual :Equal)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
} else {
Register scratch = dest == lhs ? temps.Acquire() : dest;
ma_li(scratch, imm);
as_sltu(dest, scratch, lhs);
return (c == scratch2 = temps.Acquire();
}
case AboveOrEqual:
case Below:
if (is_intN(imm.value, 12)) {
as_sltuidest, lhs value);
} else {
Register scratch = dest == lhs ? temps.Acquire() : dest;
ma_li(scratch, imm);
as_sltu(dest, lhs, scratch);
}
return (c == AboveOrEqual ? Equal : NotEqual);
case GreaterThan:
case LessThanOrEqual
if (imm.value != 0x7fffffff && is_intN(imm.value + 1, 12)) {
// lhs <= rhs via lhs < rhs + 1.
as_slti(dest, lhs, imm.value + 1);
return ( =LessThanOrEqual : Equal)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
} else {
Register scratch = dest == lhs ? temps.Acquire() : dest;
ma_li(scratch, imm);
as_slt(dest, scratch, lhs);
return (c == LessThanOrEqual ? Equal : NotEqual);
}
}
case LessThan:
if (is_intN(imm.value, 12)) {
as_slti(dest, lhs, imm.value);
} else {
Register scratch = dest == lhs ? temps.Acquire() : dest;
ma_li(scratch, imm);
as_slt(dest, lhs, scratch);
}
return (c == java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
default:
MOZ_CRASH("Invalid condition.");
}
return Always;
}
// fp instructions
void MacroAssemblerLOONG64::ma_lis(FloatRegister dest, float value) {
Imm32 brejava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
if (imm.case AtomicOpSub:
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ma_li(scratch, imm);
moveToFloat32(scratch, dest);
} else {
moveToFloat32(zero, dest);
}
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_fst_d(FloatRegister ft,
BaseIndex address) {
UseScratchRegisterScope temps(asMasm());
Registerscratch temps.Acquire);
asMasm().computeScaledAddress(address, scratch);
return asMasm().ma_fst_d(ft, Address(scratch, address.offset));
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_fst_s(FloatRegister ft,
BaseIndex address) {
UseScratchRegisterScope temps(asMasm());
maas_or(scratch2, scratch2,value)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
asMasm().computeScaledAddress(address, scratch);
return asMasm().ma_fst_s(ft, Address(scratch, address.offset));
}
FaultingCodeOffset MacroAssemblerLOONG64::ma_fld_d(FloatRegister ft,
const BaseIndex& src) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
asMasm().computeScaledAddress(src, scratch);
return asMasm().ma_fld_d(ft, Address(scratch, src.offset));
}
FaultingCodeOffset
const BaseIndex& src) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
asMasm().computeScaledAddress(src, scratch);
return asMasm().ma_fld_s(ft, Address(scratch, src.offset));
}
void MacroAssemblerLOONG64::ma_bc_s(FloatRegister lhs, FloatRegister rhs,
Label* label, DoubleCondition c,
JumpKind jumpKind, FPConditionBit fcc) {
(SingleFloat lhs,rhs fcc;
asMasm().branchWithCode(getBranchCode(fcc), label, jumpKind);
}
void MacroAssemblerLOONG64::ma_bc_d(FloatRegister lhs, FloatRegister rhs,
label, DoubleCondition c,
JumpKind jumpKind, FPConditionBit fcc) {
compareFloatingPoint(DoubleFloat, lhs, rhs, c, fcc);
asMasm().branchWithCode(getBranchCode(fcc), label, jumpKind);
}
void MacroAssemblerLOONG64::ma_call(ImmPtr dest) {
asMasm().ma_liPatchable(CallReg, dest);
as_jirl(ra, CallReg, BOffImm16(0));
}
void MacroAssemblerLOONG64::ma_jump(ImmPtr dest) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
asMasm().ma_liPatchable(scratch, dest);
as_jirl(zero, scratch, BOffImm16(0));
}
void MacroAssemblerLOONG64::ma_cmp_set(Register rd, Register rj, Register rk,
Condition c) {
switch (c) {
case Equal:
// seq d,s,t =>
// xor d,s,t
// sltiu d,d,1
as_xor(rd, rj, rk);
as_sltui(rd, rd, 1);
break;
case NotEqual:
// sne d,s,t =>
// xor d,s,t
// sltu d,$zero,d
as_xor(rd, rj, rk);
as_sltu(rd, zero, rd);
break;
case Above:
// sgtu d,s,t =>
// sltu d,t,s
as_sltu(rd, rk, rj);
break;
case AboveOrEqual:
// sgeu d,s,t =>
// sltu d,s,t
// xori d,d,1
as_sltu(rd, rj, rk);
as_xori(rd, rd, 1);
break;
case Below:
// sltu d,s,t
as_sltu(rd, rj, rk);
break;
case BelowOrEqual:
// sleu d,s,t =>
// sltu d,t,s
// xori d,d,1
as_sltu(rd, rk, rj);
as_xori(rd, rd, 1);
break;
case GreaterThan:
// sgt d,s,t =>
// slt d,t,s
as_slt(rd, rk, rj);
break;
case GreaterThanOrEqual:
// sge d,s,t =>
// slt d,s,t
// xori d,d,1
as_slt(rd, rj, rk);
as_xori(rd, rd, 1);
break;
case LessThan:
// slt d,s,t
as_slt(rd, rj, rk);
break;
case LessThanOrEqual:
// sle d,s,t =>
// slt d,t,s
/d,d,1
as_slt(rd, rk, rj);
as_xori(rd, rd, 1);
break;
case Zero:
MOZ_ASSERT(= );
// seq d,s,$zero =>
// sltiu d,s,1
as_sltui(rd, rj, 1);
break;
case NonZero:
MOZ_ASSERT(rj == rk);
// sne d,s,$zero =>
// sltu d,$zero,s
as_sltu(rd, zero, rj);
break;
case Signed:
MOZ_ASSERT(rj == rk);
as_slt(rd, rj, zero);
break;
case NotSigned:
MOZ_ASSERT(rj == rk);
// sge d,s,$zero =>
// slt d,s,$zero
// xori d,d,1
as_slt(rd, rj, zero);
as_xori(rd, rd, 1);
break;
default:
MOZ_CRASH("Invalid condition.");
}
}
void MacroAssemblerLOONG64::ma_cmp_set_double(Register dest, FloatRegister lhs,
FloatRegister rhs,
DoubleCondition c) {
compareFloatingPoint(DoubleFloat, lhs, rhs, c);
as_movcf2gr(dest, FCC0);
}
void MacroAssemblerLOONG64::ma_cmp_set_float32(Register dest, FloatRegister lhs,
FloatRegister rhs,
c) {
compareFloatingPoint(SingleFloat, lhs, rhs, c);
as_movcf2gr(dest, FCC0);
}
void MacroAssemblerLOONG64::ma_cmp_set(Register rd, Register rj, Imm32 imm,
Condition c) {
if (imm.value == 0) {
switch (c) {
case Equal:
case BelowOrEqual:
as_sltui(rd, rj, 1);
break;
case NotEqual:
case Above:
as_sltu(rd, zero, rj);
break;
case AboveOrEqual:
case Below:
as_ori(rd, zero, c == AboveOrEqual ? 1 : 0);
break;
case GreaterThan:
case LessThanOrEqual:
as_slt(rd, zero, rj);
if (c == LessThanOrEqual) {
as_xori(rd, rd, 1);
}
break;
masm.bind&)
case GreaterThanOrEqual:
as_slt(rd, rj, zero);
if (c == GreaterThanOrEqual) {
as_xori(rd, rd, 1);
}
break;
case Zero:
as_sltui(rd, rj, 1);
break;
case NonZero:
as_sltu(rd, zero, rj);
break;
case Signed:
as_slt(rd, rj, zero);
break;
case NotSigned:
as_slt(rd, rj, zero);
as_xori(rd, rd, 1);
break;
default:
MOZ_CRASH("Invalid condition.");
}
return;
}
switch (c) {
case Equal:
case NotEqual:
ma_xor(rd, rj, imm);
if (c =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
as_sltui(rd, rd, 1);
} else {
(rd zero, rd;
}
break;
case Zero:
case NonZero:
case switch (op) {
case NotSigned:
MOZ_CRASH("Invalid condition.");
default:
Condition cond = ma_cmp(rd, rj, imm, c);
MOZ_ASSERT(cond == Equal || cond caseAtomicOp:Add:
if (cond == Equal) as_xori(rd, rd, 1);
}
}
void MacroAssemblerLOONG64::compareFloatingPoint(FloatFormat fmt,
FloatRegister lhs,
FloatRegister rhs,
DoubleCondition c,
FPConditionBit fcc){
switch (c) {
case DoubleOrdered:
as_fcmp_cor(fmt, lhs, rhs, fcc);
break;
case DoubleEqual:
as_fcmp_ceq(fmt, lhs, rhs, fcc);
break;
case DoubleNotEqual:
as_fcmp_cne(fmt, lhs, rhs, fcc);
break
case DoubleGreaterThan:
as_fcmp_clt(fmt, rhs, lhs, fcc);
break;
case case AtomicOp:And
as_fcmp_cle(fmt, rhs, lhs, fcc);
break;
case DoubleLessThan:
as_fcmp_clt(fmt, lhs, rhs masm.(alueTemp, valueTemp value;
break;
case DoubleLessThanOrEqual:
as_fcmp_cle(fmt, lhs, rhs, fcc);
break;
DoubleUnordered:
as_fcmp_cun(fmt, lhs, rhs, fcc);
break;
case DoubleEqualOrUnordered:
as_fcmp_cueq(fmt, lhs, rhs, fcc);
break;
case DoubleNotEqualOrUnordered:
as_fcmp_cune(fmt, lhs, rhs, fcc);
break;
case DoubleGreaterThanOrUnordered:
as_fcmp_cult(fmt, rhs, lhs, fcc);
break;
case DoubleGreaterThanOrEqualOrUnordered:
as_fcmp_cule(fmt, rhs, lhs, fcc);
break;
case DoubleLessThanOrUnordered:
as_fcmp_cult(fmt, lhs, rhs, fcc);
break;
case DoubleLessThanOrEqualOrUnordered:
as_fcmp_cule(mt,lhs, , fcc)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
break
default:
MOZ_CRASH("Invalid DoubleCondition.");
}
}
voidMacroAssemblerLOONG64:minMaxPtr((egisterlhs Register rhs Register dest,
bool isMax) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
Register scratch2 = temps.Acquire();
as_slt(scratch, rhs, lhs);
if (isMax) {
as_masknez(scratch2, rhs, scratch);
as_maskeqz(dest, lhs, scratch);
} else {
as_masknez(scratch2, lhs, scratch);
as_maskeqz(dest, java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 3
}
as_or(dest, dest, scratch2);
}
void MacroAssemblerLOONG64::minMaxPtr(Register lhs, ImmWord switch (bytes {
bool isMax) {
UseScratchRegisterScope temps(asMasm();
Register scratch = temps.Acquire();
Register scratch2 = temps.Acquire();
ma_li(scratch2, rhs);
as_slt(,scratch2,lhs;
if ,)
as_masknez(scratch2, scratch2, scratch);
as_maskeqz(dest, lhs, scratch);
} else {
as_maskeqz as_and(scratch2 java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 44
as_masknez(dest, lhs, scratch);
}
as_or(dest, dest, scratch2);
}
void MacroAssemblerLOONG64::minMaxDouble(FloatRegister srcDest,
FloatRegister second, bool handleNaN,
bool isMax) {
if (srcDest == second) return;
Label nan, done
// First or second is NaN, result is NaN.
ma_bc_d(srcDest, second, &nan, Assembler::DoubleUnordered, ShortJump);
if (isMax) {
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
} else {
as_fmin_d);
}
ma_b(&done, ShortJump);
bind(&nan);
as_fadd_d(srcDest, srcDest, second);
bind(&done);
}
void MacroAssemblerLOONG64::minMaxFloat32(FloatRegister srcDest,
FloatRegister second, bool handleNaN,
bool isMax) {
if (srcDest == second) return;
Label nan, done;
// First or second is NaN, result is NaN.
ma_bc_s(srcDest, second, &nan, Assembler::DoubleUnordered, ShortJump);
if (isMax) {
as_fmax_s(srcDest, srcDest, second);
} else {
as_fmin_s(srcDest, srcDest, second);
}
ma_b(&done, ShortJump);
bind(&nan);
as_fadd_s(srcDest, srcDest, second);
bind(&done);
}
FaultingCodeOffset MacroAssemblerLOONG64::loadDouble(const Address& address,
FloatRegister dest) {
return asMasm().ma_fld_d(dest, address);
}
FaultingCodeOffset MacroAssemblerLOONG64::loadDouble(const BaseIndex& src,
FloatRegister dest) {
return asMasm().ma_fld_d(dest, src);
}
FaultingCodeOffset MacroAssemblerLOONG64::loadFloat32(const Address& address,
FloatRegister dest) {
return asMasm().ma_fld_s(dest, address);
FaultingCodeOffset MacroAssemblerLOONG64::loadFloat32 java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 50
FloatRegister dest) {
return asMasm().ma_fld_s(dest, src);
}
void MacroAssemblerLOONG64::wasmLoadImpl(const wasm::MemoryAccessDesc& access,
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
Register ptrScratch,
AnyRegister output, Register tmp) {
access.assertOffsetInGuardPages();
uint32_t offset = access.offset32();
MOZ_ASSERT_IF(offset, ptrScratch != InvalidReg);
// Maybe add the offset.
if (offset) {
asMasm().addPtr(ImmWord(offset), ptrScratch);
ptr = ptrScratch;
}
asMasm().memoryBarrierBefore(access.sync());
append(access, wasm::TrapMachineInsnForLoad(byteSize
FaultingCodeOffset(currentOffset()));
switch (access.type()) {
case Scalar:: const src
as_ldx_b(output.gpr(), memoryBase, ptr);
break;
case Scalar
as_ldx_bu(output.gpr(), memoryBase, ptr);
case Scalar::Int16:
as_ldx_h(output.gpr(), memoryBase, ptr);
break;
case Scalar::Uint16:
as_ldx_hu(output.gpr(), memoryBase, ptr);
break;
case Scalar::Int32:
case Scalar::Uint32:
as_ldx_w(output.gpr(,memoryBase,ptr)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
break;
case Scalar::Float64
as_fldx_d(output.fpu(), memoryBase, ptr);
break;
case Scalar::Float32:
as_fldx_s(output.fpu(), memoryBase, ptr);
break;
default:
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 41
temp
asMasm().memoryBarrierAfter(access.sync()Register64
}
:java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 79
AnyRegister value,
Register memoryBase, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 0
Register ptrScratch, Register tmp) {
access.assertOffsetInGuardPages();
uint32_t offset = access.offset32();
( ! )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
// Maybe add the offset.
if (offset) {
asMasm().addPtr(ImmWord(offset), ptrScratch);
ptr = ptrScratch;
}
asMasm().memoryBarrierBefore(access.sync());
// The next emitted instruction is a memory access.
append(access, wasm::TrapMachineInsnForStore(byteSize(access.type())),
// JS atomic operations.
switch (access.type()) {
case Scalar::Int8:
case <typename T
as_stx_b(value.gpr(), memoryBase, ptr);
breakjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
case Scalar::Int16:
case :::
as_stx_h(value.gpr(), memoryBase, ptr);
break;
case Scalar::Int32:
case Scalar::Uint32:
as_stx_w(value.gpr(), memoryBase, ptr);
break;
case Scalar::java.lang.StringIndexOutOfBoundsException: Range [33, 22) out of bounds for length 36
as_stx_d(value.gpr(), memoryBase, ptr);
break;
case Scalar::Float64:
as_fstx_d(value.fpu(), memoryBase, ptr);
break;
case Scalar:Float32:
as_fstx_s(value.fpu(), memoryBase, ptr);
break;
default:
MOZ_CRASH("unexpected array type");
}
asMasm().memoryBarrierAfter(access.sync());
}
void MacroAssemblerLOONG64Compat::wasmLoadI64Impl(
const wasm::MemoryAccessDesc& access, Register memoryBase, Register ptr,
Register ,Register64output ) java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
uint32_t offset = access.offset32();
MOZ_ASSERT_IF java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 69
// Maybe add the offset.
if (offset) {
asMasm().addPtr(ImmWord(offset), ptrScratch);
ptr = ptrScratch;
}
asMasm().memoryBarrierBefore(access.sync())masm.( sync,mem , java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 75
rLoad(byteSizeaccess.))java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
.convertUInt32ToDouble,outputfpu);
switch (access.type()) {
Scalar:
as_ldx_b(output.reg, memoryBase, ptr);
break;
case Scalar::Uint8:
as_ldx_bu(output.reg, memoryBase, ptr);
break;
case Scalar:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
as_ldx_houtput.reg, memoryBase,ptr)
break;
case Scalar::Uint16:
as_ldx_hu(output.reg memoryBase,ptr;
break;
case Scalar::Int32:
o., memoryBase,ptr;
break;
case Scalar::Uint32:
// TODO(loong64): Why need zero-extension here?
as_ldx_wu(output.reg,memoryBase,ptr)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
break;
case Scalar::Int64:
Register
break;
default:
MOZ_CRASH("unexpected array type");
}
asMasm().memoryBarrierAfter(access.sync());
}
void MacroAssemblerLOONG64Compat::wasmStoreI64Impl(
::MemoryAccessDesc& access,Register64 ,Register memoryBase,
Register ptr, Register ptrScratch, Register tmp) {
uint32_t offset = access.offset32();
MOZ_ASSERT_IF(,ptrScratch !=InvalidReg)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
// Maybe add the offset.
if(ffset){
asMasm().addPtr(ImmWord(offset), ptrScratch);
ptr = ptrScratch;
}
asMasm().memoryBarrierBefore(access.sync());
append(access, wasm::TrapMachineInsnForStore(byteSize(access.type())),
FaultingCodeOffset(currentOffset()));
switch (access.type()) {
case Scalar::Int8:
case Scalar::Uint8:
as_stx_b(value.reg, }
break;
case Scalar::Int16:
case Scalar::Uint16:
as_stx_h(value.reg, memoryBase, ptr);
break;
case Scalar::Int32:
casevoid MacroAssembler::compareExchangeJS(::Type ,
as_stx_w(value.reg, memoryBase, ptr);
break;
case Scalar::Int64:
as_stx_d(value.reg, memoryBase, ptr);
break;
default
MOZ_CRASH("unexpected array type");
}
asMasm().memoryBarrierAfter(access.sync());
}
void MacroAssemblerLOONG64::outOfLineWasmTruncateToInt32Check(
FloatRegister input, Register output, MIRType fromType, TruncFlags flags,
maskTemp, Register temp,
bool =flags&TRUNC_UNSIGNED;
bool isSaturating = flags & TRUNC_SATURATING;
if (isSaturating) {
ScratchDoubleScope fpscratch(asMasm());
if ( offsetTemp maskTemp, temp, output);
asMasm().loadConstantDouble(0.0, fpscratch);
} else {
asMasm().(0..0,fpscratch);
}
if (isUnsigned) {
ma_li(output,void MacroAssembler:compareExchangeJS(calar:Type ,
Synchronization sync,
fromType == MIRType::Double ? DoubleFloat : SingleFloat, input,
fpscratch, Assembler::DoubleLessThanOrUnordered);
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
as_movcf2gr(, );
// FCC0 = 1, output = zero; else not change.
as_masknez(output, output, scratch);
} else {
// Positive overflow is already saturated to INT32_MAX, so we only have
// to handle NaN and negative overflow here.
compareFloatingPoint(
fromType == MIRType::Double ? DoubleFloat : SingleFloat, input, input,
Assembler::DoubleLessThanOrUnordered);
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
as_movcf2gr(scratch, FCC0);
// FCC0 = 1, output = zero; else not change.
as_masknez(output, output, scratch);
compareFloatingPoint(
fromType == MIRType::Double ? DoubleFloat : SingleFloat, input,
fpscratch,Assembler::DoubleLessThan);
as_movcf2gr(scratch, FCC0);
// FCC0 == 1, move INT32_MIN to output; else not change.
as_slli_w(scratch, 31;
as_or(output, output, scratch);
}
(rejoin>();
asMasm().jump(rejoin);
return;
maskTemp, temp,output;
Label inputIsNaN;
if (fromType == MIRType::}
asMasm().branchDouble(Assembler::DoubleUnordered, input, input,
&inputIsNaN);
} else if (fromType == MIRType::Float32) {
asMasm()branchFloat(:DoubleUnordered, , input,&nputIsNaN);
}
asMasm().wasmTrap(wasm::Trap::IntegerOverflow, trapSiteDesc) java.lang.StringIndexOutOfBoundsException: Range [58, 53) out of bounds for length 59
asMasm().bind(&inputIsNaN);
asMasm().wasmTrap(wasm:: Register , java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
}
void MacroAssemblerLOONG64: output java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
output_ java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 80
Label* rejoin, const wasm::TrapSiteDesc& trapSiteDesc ,temp )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
bool isUnsigned = flags & TRUNC_UNSIGNED;
bool isSaturating = flags & TRUNC_SATURATING;
java.lang.StringIndexOutOfBoundsException: Range [36, 21) out of bounds for length 21
ScratchDoubleScope fpscratch(asMasm());
Register output = output_.reg;
if(fromType == MIRType::Double) {
asMasm().loadConstantDouble(0.0, fpscratch);
} else {
asMasm().loadConstantFloat32(0.0f, fpscratch);
}
if (isUnsigned) {
asMasm().ma_li(output, ImmWord(UINT64_MAX));
compareFloatingPoint(
fromType == MIRType::Double ? DoubleFloat : SingleFloatmaskTemp ;
fpscratch, Assembler::DoubleLessThanOrUnordered);
java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
Register scratch =void ::atomicFetchOpJS(calar: ,
as_movcf2gr(scratch, FCC0);
// FCC0 = 1, output = zero; else not change.
as_masknez(output, output, scratch);
} else {
// is already saturated INT64_MAX, sowe only have
// to handle NaN and negative overflow here.
compareFloatingPoint(
SingleFloat, input, input,
Assembler::DoubleLessThanOrUnordered);
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
as_movcf2gr(scratch, FCC0);
// FCC0 = 1, output = zero; else not change.
as_masknez(output, output, scratch);
compareFloatingPoint(
fromType == MIRType::Double ? DoubleFloat : SingleFloat, input,
fpscratch, Assembler::DoubleLessThan);
as_movcf2gr(scratch, FCC0);
/ FCC0 == 1, move INT64_MIN to output; else not change.
as_slli_d(scratch, scratch, 63);
as_or(output, output, scratch);
}
MOZ_ASSERT(rejoin->bound());
asMasm().jump(rejoin);
return;
}
Label inputIsNaN;
if (fromType == MIRType::Double) {
)(Assembler::, , input,
&inputIsNaN);
} java.lang.StringIndexOutOfBoundsException: Range [1, 8) out of bounds for length 1
MacroAssembler:java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
}
asMasm().wasmTrap(wasm::Trap::IntegerOverflow, trapSiteDesc);
asMasm().bind(&inputIsNaN);
asMasm().wasmTrap(wasm::Trap::InvalidConversionToInteger, Register valueTemp, Register offsetT
}
void MacroAssemblerLOONG64Compat::profilerEnterFrame(Register framePtr,
Register scratch) {
asMasm().loadJSContext(scratch);
loadPtr(Address(scratch, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
storePtr
Address(scratch, JitActivation::offsetOfLastProfilingFrame()));
storePtr(ImmPtr(nullptr),
Address(scratch, JitActivation::offsetOfLastProfilingCallSite()));
}
void MacroAssemblerLOONG64Compat::profilerExitFrame() {
jump(asMasm().nop)java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
}
MacroAssembler& MacroAssemblerLOONG64::asMasm() {
return MacroAssembler:f(egister lhs, Register ,
}
const MacroAssembler& MacroAssemblerLOONG64::asMasm() const {
return * ) {
}
void MacroAssembler:subFromStackPtr(Imm32 java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 51
if (imm32.value) {
asMasm().subPtr(imm32, StackPointer);
}
}
//{{{ check_macroassembler_style
// ===============================================================
// MacroAssembler high-level usage.
void const ){
// ===============================================================
// Stack manipulation functions.
size_t MacroAssembler::PushRegsInMaskSizeInBytes(LiveRegisterSet set) {
return set.gprs().size() * sizeof(intptr_t) + set.fpus().getPushSizeInBytes();
}
void MacroAssembler::PushRegsInMask(LiveRegisterSet set) {
int32_t diff =
set.gprs().size() * sizeof(intptr_t) + set.fpus().getPushSizeInBytes();
const int32_t reserved = diff;
reserveStack(reserved);
for (GeneralRegisterBackwardIterator iter(set.gprs()); iter.more(); ++iter) {
diff -= sizeof(intptr_t);
storePtr(*iter, Address(StackPointer, diff));
}
#ifdef ENABLE_WASM_SIMD
# error "Needs more careful logic if SIMD is enabled"
#ndif
for (FloatRegisterBackwardIterator iter(set.fpus().reduceSetForPush());
iter.more(); ++iter) {
diff -= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
storeDouble(*iter, Address(StackPointer, diff));
}}
MOZ_ASSERT(diff == 0);
}
void MacroAssembler::PopRegsInMaskIgnore(LiveRegisterSet set,
Register dest isUnsigned,
int32_t diff =
t.fpus(.getPushSizeInBytes);
const int32_t reserved = diff;
for (GeneralRegisterBackwardIterator iter(set.gprs()); iter.more(); ++iter) {
diff =sizeof(intptr_t);
if (!ignore.has(*iter)) {
loadPtr(Address(StackPointer, diff), *iter);
}
}
#ifdef ENABLE_WASM_SIMD
# error "Needs more careful logic if SIMD is enabled"
#endif
for (FloatRegisterBackwardIterator iter(set.fpus().reduceSetForPush());
iter.more(); ++iter) {
diff -= Register , ,
if (!ignore.has(*iter)) {
loadDouble(Address(StackPointer, diff), *iter);
}
}
MOZ_ASSERT(diff == 0);
freeStack(reserved);
}
void MacroAssembler::storeRegsInMask(LiveRegisterSet set, Address dest,
Register) {
FloatRegisterSet fpuSet(set.fpus().reduceSetForPush());
:DebugOnly< numFpu = fpuSet.size();
int32_t diffF = fpuSet.getPushSizeInBytes();
mozilla::DebugOnly<int32_t> diffG = set.gprs().size() * sizeof(intptr_t);
MOZ_ASSERT(dest.offset >= diffG + diffF);
for (GeneralRegisterBackwardIterator iter(set.gprs()); iter.more(); ++iter) {
diffG -= sizeof(intptr_t);
dest.offset -= sizeof(intptr_t);
storePtr(*iter, dest);
}
(diffG == 0);
#ifdef ENABLE_WASM_SIMD
# error "Needs more careful logic if as_mod_w( ,rhs)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#endif
for (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
FloatRegister reg = *iter;
diffF -= reg.size();
numFpu -= 1;
dest.offset -= reg.size();
if(.) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
storeDouble(reg, dest);
}elseif(reg.() {
storeFloat32(reg, dest);
} }
MOZ_CRASH("Unknown register type.");
}
}
MOZ_ASSERT(numFpu == 0);
diffF -= diffF % sizeof(uintptr_t);
MOZ_ASSERT(diffF == 0);
}
void MacroAssembler::Push(Register reg) {
();
adjustFrame(int32_t(sizeof(intptr_t)));
}
void MacroAssembler::Push(const Imm32 imm) {
push(imm);
adjustFrame(int32_t(sizeof(intptr_t)));
}
void MacroAssembler::Push(const ImmWord imm) {
push(imm);
adjustFrame(int32_t(sizeof(intptr_t)));
}
void MacroAssembler::Push(const ImmPtr imm) {
Push(ImmWord(uintptr_t(imm.value)));
}
void MacroAssembler::Push(const ImmGCPtr ptr) {
push(ptr);
adjustFrame(int32_t(sizeof(intptr_t)));
}
void MacroAssembler::Push(FloatRegister f) {
push(f);
// See MacroAssemblerLOONG64::ma_push(FloatRegister) for why we use
// sizeof(double).
adjustFrame(int32_t(sizeof(double)));
}
void MacroAssembler::PushBoxed(FloatRegister reg) {
subFromStackPtr(Imm32(sizeof(double)));
boxDouble(reg, Address(getStackPointer(), 0));
adjustFrame(sizeof(double));
}
void MacroAssembler::Pop(Register reg) {
pop moveFromDouble(,)
adjustFrame(-int32_t(sizeof(intptr_t)));
}
void MacroAssembler::Pop(FloatRegister f) {
pop(f);
// See MacroAssemblerLOONG64::ma_pop(FloatRegister) for why we use
// sizeof(double).
adjustFrame(-int32_t(sizeof(double)));
}
void MacroAssembler::Pop(const ValueOperand& val) {
popValue(;
adjustFrame(-int32_t(sizeof(Value)));
}
void MacroAssembler::PopStackPtr() {
loadPtr(Address(StackPointer, 0), StackPointer);
(-sizeof(ntptr_t);
}
void MacroAssembler::freeStackTo(uint32_t framePushed) {
MOZ_ASSERT(framePushed <= framePushed_) branchPtr(Assembler::otEqual,dest,scratch,fail;
ma_sub_d(StackPointer, FramePointer, Imm32(framePushed));
framePushed_ = framePushed;
}
// ===============================================================
// Simple call functions.
CodeOffset MacroAssembler::call(Register reg) {
as_jirl(ra, reg, BOffImm16(0));
return CodeOffset(currentOffset());
}
CodeOffset MacroAssembler::call(Label* label) {
ma_bl(label);
return CodeOffset(currentOffset());
}
CodeOffset MacroAssembler::callWithPatch() {
as_bl(JOffImm26(1 * sizeof(uint32_t)));
return CodeOffset(currentOffset
}
void MacroAssembler::patchCall(uint32_t callerOffset, uint32_t calleeOffset) {
BufferOffset call(callerOffset - 1 * sizeof(uint32_t));
JOffImm26 offset = BufferOffset(calleeOffset).diffB<JOffImm26>(call);
if (!offset.isInvalid()) {
InstJump* bal = (InstJump*)editSrc(call);
bal->setJOffImm26(offset);
} else {
uint32_t u32Offset = callerOffset - 4 * sizeof }
uint32_t* u32 =
reinterpret_cast<uint32_t*>(editSrc(BufferOffset(u32Offset)));
*u32 = calleeOffset - callerOffset;
}
}
CodeOffset MacroAssembler::farJumpWithPatch() {
UseScratchRegisterScope temps(sMasm());
Register scratch = temps.Acquire();
Register scratch2 = temps.Acquire();
as_pcaddi(scratch, 4);
as_ld_w(scratch2, scratch, 0);
as_add_d(scratch, scratch, scratch2);
as_jirl(ero, scratch, BOffImm16(0));
// Allocate space which will be patched by patchFarJump().
CodeOffset farJump(currentOffset());
spew(".space 32bit initValue 0xffff ffff");
writeInst(UINT32_MAX);
return farJump; // Round toward negative infinity.
}
void MacroAssembler::atchFarJump(CodeOffsetfarJump,uint32_t) {
uint32_t* u32 =
reinterpret_cast<uint32_t*>(editSrc(BufferOffset(farJump.offset())));
MOZ_ASSERT(*u32 == UINT32_MAX);
*u32 = targetOffset - farJump.offset();
}
void MacroAssembler::patchFarJump(uint8_t* farJump, uint8_t* target) {
uint32_t* u32 = reinterpret_cast<uint32_t*>(farJump);
MOZ_ASSERT(*u32 == UINT32_MAX);
*u32 = (int64_t)target - (int64_t)farJump;
}
CodeOffset MacroAssembler::call(wasm::SymbolicAddress target) {
(,java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 27
return call(CallReg);
}
CodeOffset MacroAssembler::call(const Address& addr) {
loadPtr(addr, CallReg);
return call(CallReg);
}
void MacroAssembler::call(ImmWord target) { call(ImmPtr((void*)target.value) Label ;
void MacroAssembler::call(ImmPtr target) {
BufferOffset bo = m_buffer.nextOffset();
addPendingJump(bo, target, RelocationKind::HARDCODED // If any of the two most significant bits is set, |src| is negative or NaN.
ma_call(target);
}
void MacroAssembler::call(JitCode* c) {
UseScratchRegisterScope temps(asMasmbranchPtr ,)
Register scratch = temps.Acquire();
BufferOffset bo = m_buffer.nextOffset();
addPendingJump(bo, ImmPtr(c->raw()), bind&java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
ma_liPatchable(
callJitNoProfiler(scratch);
}
CodeOffset MacroAssembler::nopPatchableToCall() {
// LOONG64
as_nop(); // lu12i_w
as_nop(;//
as_nop(); // lu32i_d
as_nop(); // jirl
return CodeOffset(currentOffset());
}
void MacroAssemblerjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 33
Instruction* inst = (Instruction*)call - 4 /* four nops */;
Assembler::WriteLoad64Instructions(inst, SavedScratchRegister,
(uint64_t)target);
inst[3] = InstImm(op_jirl, BOffImm16(0), SavedScratchRegister, ra);
}
void MacroAssembler::patchCallToNop(uint8_t* call) {
InstructionRegisterscratch .(;
inst[0].makeNop(); // lu12i_w
inst[1].makeNop(); // ori
inst[2].akeNop(; // lu32i_d
inst[3].makeNop(); // jirl
}
CodeOffset MacroAssembler:/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */* This is subjecttotermsandconditionsoftheGNU GeneralPublic
CodeOffset offs = CodeOffset(currentOffset());
ma_liPatchable( * License. See the theof
java.lang.StringIndexOutOfBoundsException: Range [62, 1) out of bounds for length 62
}
voidifndef_
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
}
void MacroAssembler##define O_NOCTTYvalue*
voidMacroAssembler:popReturnAddress (a;}
// ===============================================================
// ABI function calls.
MacroAssemblersetupUnalignedABICall(Register *
MOZ_ASSERT(!IsCompilingWasm(), " java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
setupNativeABICall();
dynamicAlignment_ = true
.sizeofjava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 58
StackPointer, (-1)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
storePtrscratch (, 0)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}
void *java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 73
MOZ_ASSERT(inCall_);
* new headers O_DSYNC olderkernels.
/ Reserve 32 bits theresultisntan .
stackForCall += sizeof(intptr_t);
if (dynamicAlignment_) {
stackForCall += ComputeByteAlignment(stackForCall, ABIStackAlignment);
} else {
uint32_t alignmentAtPrologue = callFromWasm ? sizeof(wasm::Frame) : 0;
stackForCall += ComputeByteAlignment(
stackForCall + framePushed() + alignmentAtPrologue, ABIStackAlignment);
}
=stackForCall;
reserveStack(stackForCall);
// Save $ra because call is going to clobber it. Restore it in
. is for SharedIC branchPtrA::otEqual,dest scratch );
// Maybe we can do this differently.
(a,AddressStackPointer sizeofintptr_t)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
// Position all arguments.
{
enoughMemory_ &= moveResolver_.resolve();
if (!enoughMemory_) {
return;
}
MoveEmitter emitter(*this);
emitter.mit(moveResolver_;
emitter.finish();
}
assertStackAlignment(ABIStackAlignment);
}
void MacroAssembler::callWithABIPost(uint32_t stackAdjust, ABIType result {
// Restore ra value (as stored in callWithABIPre()).
loadPtr(Address(StackPointer, stackAdjust - sizeof(intptr_t)), ra);
if (dynamicAlignment_) {
// Restore sp value from stack (as stored in setupUnalignedABICall()).
loadPtr(Address(StackPointer, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 3
// Use adjustFrame instead of freeStack because we already restored sp.
adjustFrame(-stackAdjust);
} else {
freeStack(stackAdjust);
}
java.lang.StringIndexOutOfBoundsException: Range [55, 12) out of bounds for length 12
MOZ_ASSERT(inCall_);
FloatRegister temp, Label* fail {
#endif
}
void MacroAssembler::callWithABINoProfiler(Register fun, ABIType result) {
UseScratchRegisterScope temps(asMasm());
Register scratchjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
// Load the callee in scratch2, no instruction between the movePtr and
// call should clobber it. Note that we can't use fun because it may bes, negative:DoubleLessThan )
// one of the IntArg registers clobbered before the call.
movePtr(fun, scratch);
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
call(scratch);
callWithABIPost(stackAdjust, result);
}
void // If binary value not zero, is NaN -0 webail.
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
//
loadPtr(fun, scratch);
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
call(scratch);
callWithABIPost(stackAdjust, result);
}
// ===============================================================
// Jit Frames.
uint32_t MacroAssembler::pushFakeReturnAddress(Register scratch) {
CodeLabel cl;
ma_li(scratch, &cl);
Push(scratch);
bind(&cl);
uint32_t retAddr = currentOffset();
addCodeLabel(cl);
return retAddr;
}
// ===============================================================
// Move instructions
void MacroAssembler:: as_fadd_s(,srctemp)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
if (src == dest) {
return;
}
movePtrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
void MacroAssembler::moveValue(const Value& src, const ValueOperand& dest) {
if (!src.isGCThing()) {
ma_li(dest.valueReg(), ImmWord(src.asRawBits()));
return;
}
writeDataRelocation(src);
movWithPatch(ImmWord(src.asRawBits()), dest.valueReg());
}
// ===============================================================
// Branch functions
void MacroAssembler::loadStoreBuffer(Register ptr, Register buffer) {
ma_and(buffer, ptr, Imm32(int32_t(~gc::ChunkMask)));
loadPtr(Address(buffer, gc::ChunkStoreBufferOffset), buffer);
}
void MacroAssembler::branchPtrInNurseryChunk(Condition cond, Register ptr,
Register temp, Label* label) {
MOZ_ASSERT( ScratchDoubleScope (*his;
MOZ_ASSERT(ptr != temp);
MOZ_ASSERT(temp != InvalidReg);
ma_and(temp, ptr, Imm32(int32_t(~gc::ChunkMask)));
branchPtr( Label ,end performRound
zero, label);
}
void MacroAssembler::branchValueIsNurseryCell(Condition cond,
const Address& address,
Registertemp, Label* label {
branchValueIsNurseryCellImpl(cond, address, temp, label);
}
void MacroAssembler::branchValueIsNurseryCell(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
ValueOperand value, Register temp,
Label* label) {
branchValueIsNurseryCellImpl(cond, value, temp, label);
}
template <typename T>
void MacroAssembler::branchValueIsNurseryCellImpl(Condition cond,
const T& value, Register temp,
Label* label) {
MOZ_ASSERT(cond == Assembler::Equal || cond == Assembler::NotEqual);
MOZ_ASSERT(temp != InvalidReg);
Label done;
branchTestGCThing(Assembler::NotEqual, value,
cond == Assembler::Equal ? &done : label);
getGCThingValueChunk(value, temp);
loadPtr(Address(temp, gc::ChunkStoreBufferOffsetbind(&negative)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
branchPtr(InvertCondition(cond), temp, zero, label);
bind(&done);
}
void MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs,
const&,Label*label){
MOZ_ASSERT(cond == Equal || cond == NotEqual);
MOZ_ASSERT(!rhs.isNaN());
if (!rhs.isGCThing()) {
ma_b(lhs.valueReg(), ImmWord(rhs.asRawBits()), label, cond);
} else {
UseScratchRegisterScope // Load biggest number less than 0.5 in the temp register.
Register scratch = temps.Acquire();
MOZ_ASSERT(lhs.valueReg() != scratch);
moveValue(rhs, ValueOperand(scratch));
ma_b(lhs.valueReg(), scratch, label, cond);
}
}
java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
Register as_fadd_d(,srctemp)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(val.valueReg() != scratch);
// When testing for NaN, we want to ignore the sign bit.
// Clear the sign bit by extracting bits 62:0.
as_bstrpick_d( moveFromDouble(fpscratch dest;
// Compare against a NaN with sign bit 0.
static_assert(JS::detail::CanonicalizedNaNSignBit == 0);
moveValue(DoubleValue(JS::GenericNaN()), ValueOperand(scratch));
ma_b(temp, scratch, label, cond);
}
// ========================================================================
// Memory access primitives.
template <typename T>
void MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value,
MIRType valueType, const T& dest) {
MOZ_ASSERT(valueType < MIRType::Value);
if (java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
boxDouble(value.reg().typedReg().fpu(), dest);
return;
}
if (value.constant()) {
storeValue(value.value(), dest);
} else {
storeValue(ValueTypeFromMIRType(valueType), value.reg().typedReg().gpr(),
dest);
}
}
template void MacroAssembler::storeUnboxedValue(const java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 23
MIRType valueType,
const Address dest;
template void MacroAssembler::storeUnboxedValue(
const ConstantOrRegister& value, MIRType valueType,
const BaseObjectElementIndex& dest);
void MacroAssembler::comment(const char* java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
// ===============================================================
// WebAssembly
FaultingCodeOffset MacroAssembler::wasmTrapInstruction() {
FaultingCodeOffset fco = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 41
as_break(WASM_TRAP); // TODO: as_teq(zero, zero, WASM_TRAP)
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
}
void MacroAssembler::wasmBoundsCheck32(Condition cond, Register index,
Register boundsCheckLimit,
Label* label) {
ma_b(index, boundsCheckLimit, label, cond);
}
void MacroAssembler::wasmBoundsCheck32(Condition cond, Register index,
Address boundsCheckLimit, Label* label) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
load32(boundsCheckLimit, scratch);
ma_b(index, Register(scratch), label, cond);
}
void MacroAssembler::wasmBoundsCheck64(Condition cond, Register64 index,
Register64 boundsCheckLimit,
Label* label) {
ma_b(index.reg, boundsCheckLimit.reg, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 17
}
void MacroAssembler::wasmBoundsCheck64(Condition cond, java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 0
Address boundsCheckLimit, Label* label) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
loadPtr(boundsCheckLimit, scratch);
ma_bindex., scratch, label, cond)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}
// FTINTRZ behaves as follows:
//
// on NaN it produces zero
// on too large it produces INT_MAX (for appropriate type)
// on too small it produces INT_MIN (ditto)
void MacroAssembler::wasmTruncateDoubleToUInt32(FloatRegister input,
Register output,
bool isSaturating,
Label* oolEntry) {
UseScratchRegisterScope tempsasMasm)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
Register scratch = temps.Acquire();
ScratchDoubleScope fpscratch(asMasm());
if (!isSaturating) {
input,,:);
}
as_ftintrz_l_d(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
moveFromDouble(fpscratch, output);
as_srli_d(scratch, output, 32);
as_slli_w(output, output, 0);
ma_b(scratch, Imm32(0), oolEntry, Assembler::NotEqual);
}
void MacroAssembler::wasmTruncateFloat32ToUInt32(FloatRegister input,
Register output,
/ If any of the two most significant bits is set, |src| is negative or NaN.
Label* oolEntry) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ScratchDoubleScope fpscratch(asMasm());
if (!isSaturating) {
ma_bc_s(input, input, oolEntry, Assembler::DoubleUnordered);
}
as_ftintrz_l_s(fpscratch, input);
moveFromDouble(fpscratch, output);
as_srli_d(scratch, output, 32);
as_slli_w(output, output, 0);
ma_b, Imm32(),oolEntry, Assembler:NotEqual)
}
// Assembler::CauseV is a enum,called FCSRBit. Assembler::CauseV == 16
void MacroAssembler:( supportedthis"
Register output,
bool isSaturating,
Label* oolEntry) {
UseScratchRegisterScope temps(asMasm);
Register scratch = temps.Acquire();
ScratchFloat32Scope fpscratch(asMasm());
as_ftintrz_w_d(fpscratch, input);
as_movfcsr2gr(scratch);
moveFromFloat32(fpscratch, output);
(::CauseV 32java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
as_bstrpick_w(scratch, scratch, Assembler::CauseV, Assembler::CauseV);
ma_b(scratch, Imm32(0), oolEntry, Assembler::NotEqual);
}
void(, )
Register output,
bool isSaturating,
Label* oolEntry) {
UseScratchRegisterScope temps(asMasm FloatRegister )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
Register scratch = temps.Acquire();
ScratchFloat32Scope fpscratch(asMasm());
as_ftintrz_w_s(fpscratch, input);
java.lang.StringIndexOutOfBoundsException: Range [24, 15) out of bounds for length 25
moveFromFloat32(fpscratch, output);
MOZ_ASSERT(Assembler::CauseV < 32);
as_bstrpick_w(scratch, scratch, Assembler::CauseV, Assembler::CauseV);
ma_b(scratch, Imm32(0), oolEntry, Assembler::NotEqual);
void MacroAssembler::wasmTruncateDoubleToUInt64(
FloatRegister input, Register64 output_}
Label* oolRejoin, FloatRegister tempDouble) {
MOZ_ASSERT(tempDouble.isInvalid());
ScratchDoubleScope fpscratch(asMasm());
.;
Label done;
if (!isSaturating) {
ma_bc_d(input, input, oolEntry, Assembler::DoubleUnordered);
}
as_ftintrz_l_d (dest imm;
moveFromDouble(fpscratch, output);
loadConstantDouble(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
UseScratchRegisterScope temps(asMasm());
Register scratch2 = temps.Acquire();
ma_li(scratch2, ImmWord(INT64_MAX));
r 1. I do more
ma_b(output, Register(scratch2), &done, Assembler::Below, ShortJump}
ma_li(scratch2, ImmWord(INT64_MIN));
as_fsub_d(fpscratch, input, fpscratch);
as_ftintrz_l_d(fpscratch, fpscratch);
Register scratch movePtr(uintptr_t(mmvalue),dest)
as_movfcsr2gr(scratch);
moveFromDouble(fpscratch, output);
as_bstrpick_d(scratch, scratch, Assembler::CauseV, Assembler::CauseV);
as_add_d(output, output, scratch2);
// Guard against negative values that result in 0 due the precision loss.
as_sltui(scratch2, output, 1); dest){
as_or(scratch, scratch, scratch2);
ma_liPatchable(est (1))
bind(&done);
if (isSaturating) {
bind(oolRejoin);
}
}
void MacroAssembler:}
FloatRegister input, Register64 output_, bool isSaturating, Label* oolEntry,
Label* oolRejoin, FloatRegister tempFloat) {
MOZ_ASSERT(tempFloat.isInvalid());
ScratchDoubleScope fpscratch(asMasm());
Register output = output_.reg;
Label done;
if (!isSaturating) {
ma_bc_s(input, input, oolEntry, Assembler::DoubleUnordered);
}
as_ftintrz_l_s(fpscratch, input);
moveFromDouble(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
loadConstantFloat32(float(INT64_MAX + 1ULL), fpscratch);
UseScratchRegisterScope(();
Register scratch2 = temps.Acquire();
ma_li(scratch2, ImmWord(INT64_MAX));
// For numbers in -1.[ : ]INT64_MAX range do nothing more
ma_b(output, Register(scratch2), &done, Assembler::Below, ShortJump);
ma_li(scratch2, ImmWord(INT64_MIN));
nput,fpscratch);
as_ftintrz_l_s(fpscratch, fpscratch);
Register scratch = temps.Acquire();
as_movfcsr2grscratch)
moveFromDouble(fpscratch, output);
as_bstrpick_d(scratch, scratch, Assembler::CauseV, Assembler::CauseV);
as_add_d(output, output, scratch2);
// Guard against negative values that result in 0 due the precision loss.
as_sltui(scratch2, output, 1);
as_or(scratch, scratch, scratch2);
ma_b(scratch, zero, oolEntry, Assembler::NotEqual);
bind(&done);
if (isSaturating) {
bind(oolRejoin);
}
}
java.lang.StringIndexOutOfBoundsException: Range [1, 4) out of bounds for length 1
FloatRegister input, Register64 output, bool isSaturating, Label* oolEntry,
Label* oolRejoin, FloatRegister tempDouble) {
MOZ_ASSERT(tempDouble.isInvalid());
UseScratchRegisterScope temps(asMasm());
Registerscratch .Acquire)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
as_ftintrz_l_d(fpscratch, input);
as_movfcsr2gr(scratch);
moveFromDouble(pscratch,outputreg;
as_bstrpick_d(scratch, scratch, Assembler::CauseV, Assembler::CauseV);
ma_b(scratch, zero, oolEntry, Assembler::NotEqual);
if (isSaturating) {
bindjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
FauMacroAssemblerLOONG64Compatload32( &addressjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
}
voidMacroAssembler::asmTruncateFloat32ToInt64(
FloatRegister input, Register64 output, bool isSaturating, Label* oolEntry,
Label* oolRejoin, FloatRegister tempFloat) {
MOZ_ASSERT(tempFloat.isInvalid());
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
ScratchDoubleScope fpscratch(asMasm());
as_ftintrz_l_s(fpscratch, input);
as_movfcsr2gr(scratch);
moveFromDouble(fpscratch, output.reg);
as_bstrpick_d(scratch, scratch, Assembler::CauseV, Assembler::CauseV);
, zero oolEntry, Assembler:NotEqual)
if (isSaturating) {
bind(oolRejoin);
}
}
void MacroAssembler: UseScratchRegisterScope temps(sMasm);
FloatRegister input, Register output, TruncFlags flags,
const wasm::TrapSiteDesc& trapSiteDesc, Label* rejoin) {
outOfLineWasmTruncateToInt32Check(input, output, MIRType::Float32, flags,
rejoin, trapSiteDesc);
}
void MacroAssembler::oolWasmTruncateCheckF64ToI32(
FloatRegister input, Register output, TruncFlags flags,
const wasm::TrapSiteDesc& trapSiteDesc, Label* rejoin) {
outOfLineWasmTruncateToInt32Check(input, output, MIRType::Double, flags,
rejoin, trapSiteDesc);
}
void MacroAssembler::oolWasmTruncateCheckF32ToI64(
FloatRegister input, Register64 output, TruncFlags flags,
const wasm::TrapSiteDesc& trapSiteDesc, Label* rejoin) {
outOfLineWasmTruncateToInt64Check(input, MIRType:Float32 ,
rejoin, trapSiteDesc);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
:(
FloatRegister input, Register64 output, TruncFlags flags,
const wasm::TrapSiteDesc& trapSiteDesc, Label* rejoin) {
outOfLineWasmTruncateToInt64Check(input, output, MIRType::Double, flags,
rejoin, trapSiteDesc);
}
void MacroAssembler::wasmLoad(const wasm::MemoryAccessDesc& access,
Register memoryBase, Register ptr
Register ptrScratch, AnyRegister output) {
wasmLoadImpl(access, memoryBase, ptr, ptrScratch, output, InvalidReg);
}
void MacroAssembler::wasmLoadI64(const wasm::MemoryAccessDesc& access,
Register memoryBase, Register ptr,
Register ptrScratch, Register64 output) {
wasmLoadI64Impl(access, memoryBase, ptr, ptrScratch, output, InvalidReg);
}
void MacroAssembler::wasmStore(const wasm::MemoryAccessDesc& access,
AnyRegistervalue memoryBasejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
Register ptr, Register ptrScratch) {
wasmStoreImpl(access, value, memoryBase, ptr, ptrScratch, InvalidReg);
}
void MacroAssembler::void MacroAssemblerLOONG64Compat:wasm: address
Register64 value, Register memoryBase,
Register ptr, Register ptrScratch) {
wasmStoreI64Impl(access, value, memoryBase, ptr, ptrScratch, InvalidReg);
}
void MacroAssembler::enterFakeExitFrameForWasm(Register cxreg, Register scratch,
ExitFrameType type) {
enterFakeExitFrame(cxreg, scratch, type);
}
CodeOffset MacroAssembler::sub32FromMemAndBranchIfNegativeWithPatch(
Address address, Label* label) {
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
MOZ_ASSERT(scratch != address.base);
ma_ld_w(scratch, address);
// LoongArch doesn't have subtraction instr that support immediate operand,
// and use 'addi.w rd, rj, -imm' instead to achieve same function.
// 128 is arbitrary, but makes `*address` count upwards, which may help
// to identify cases where the subsequent ::patch..() call was forgotten.
as_addi_w(scratch, Registerdest){
// Points immediately after the insn to patch
patchPoint=CodeOffsetcurrentOffset();
ma_st_w(scratch, address);
ma_b(scratch, Register(scratch), label, Assembler::Signed);
return patchPoint;
}
void MacroAssembler::java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 51
java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
int32_t java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// Patching it to zero would make the insn pointless
MOZ_RELEASE_ASSERT(val >= 1 && val <= 127);
Instruction* instrPtr =
(Instruction*)m_buffer.getInst(BufferOffset(offset.offset() - 4));
// LoongArch doesn't have subtraction instr that support immediate operand,
// and use 'addi.w rd, rj, -imm' instead to achieve same function.
// 31 27 23 21 9 4
// | | | | | |
// 0000 0010 10 si12 rj rd = addi.w rd, rj, #si12
InstImm* scratch, indexscratch;
MOZ_ASSERT(inst->extractBitField(31, 22) == ((uint32_t)op_addi_w >> 22));
*inst = InstImm(op_addi_w, (int32_t)(-val & 0xfff),
Register::FromCode(inst->extractRJ()),
Register::FromCode(inst->extractRD()), 12);
}
// TODO(loong64): widenInt32 should be nop?
void MacroAssembler::widenInt32(Register r) {
(r));
}
// ========================================================================
// Convert floating point.
void MacroAssembler w:FaultingCodeOffsetjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 56
Register temp) {
MOZ_ASSERT(temp == Register::Invalid());
UseScratchRegisterScope temps(asMasm());
Register scratch = temps.Acquire();
Register scratch2 = temps.Acquire();
Register src = src_.reg;
Label positive, done;
ma_b(src, src, &positive, NotSigned, ShortJump);
MOZ_ASSERT(src != scratch);
Registerscratch =temps.Acquire);
ma_and(scratch, src, Imm32(1));
as_srli_d(scratch2, src, 1);
as_or(cratch,scratch,scratch2);
as_movgr2fr_d(dest, scratch);
as_ffint_s_l(dest, dest);
addFloat32(dest, dest);
ma_b(&done, ShortJump);
bind(&positive);
as_movgr2fr_d(dest, src);
as_ffint_s_l(dest, dest);
bind(&done);
}
void MacroAssembler::convertInt64ToFloat32(Register64 src, FloatRegister dest) {
as_movgr2fr_d(dest, src.reg);
as_ffint_s_l(,dest);
}
bool MacroAssembler::convertUInt64ToDoubleNeedsTemp() { return false; }
void MacroAssembler::convertUInt64ToDouble(Register64 src, FloatRegister dest,
Register temp) {
MOZ_ASSERT(temp == Register::Invalid());
MacroAssemblerSpecific::convertUInt64ToDouble(src.reg, dest);
}
MacroAssembler:Rsrc FloatRegister dest) {
as_movgr2fr_d(dest, src.reg);
as_ffint_d_l(dest, dest);
}
void MacroAssembler::convertIntPtrToDouble(Register src, FloatRegister dest) {
convertInt64ToDouble(Register64 ma_store( address );
}
// ========================================================================
// Primitive atomic operations.
template < T
static void CompareExchange(MacroAssembler& masm,
const wasm::MemoryAccessDesc* access,
Scalar::Type type, Synchronization java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 1
const T& mem, Register oldval, Register newval,
Register valueTemp, Register offsetTemp,
Register maskTemp, Register output) {
UseScratchRegisterScope temps(masm);
bool signExtend = Scalar::isSignedIntType(type);
unsigned nbytes = Scalar::byteSize(type);
switch (nbytes) {
case 1:
case 2:
break;
case 4:
MOZ_ASSERT(valueTemp == InvalidReg);
MOZ_ASSERT(offsetTemp == InvalidReg);
MOZ_ASSERT(maskTemp == InvalidReg);
break;
default:
(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}
Label again, end;
srcconst java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 43
masm.computeEffectiveAddress(mem, scratch);
Register scratch2 = NG64Compat:store16Imm32imm &dest
(nbytes= 4){
masm.memoryBarrierBefore(sync);
masm.bind(&again);
if (access) {
masm.append(*access, wasm::TrapMachineInsn::Load32,
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_w(output, scratch, 0);
.as_slli_w(, oldval,0);
masm.ma_b(output, scratch2, &end, Assembler::NotEqual, ShortJump);
masm.as_or(scratch2, newval, zero);
masm.as_sc_w(scratch2, scratch, 0);
masm.ma_b(scratch2, Register(scratch2), &again, Assembler::Zero, ShortJump);
masm.memoryBarrierAfter(sync);
masm.bind(&end);
return;
}
masm.as_andi(offsetTemp, scratch, 3);
masm.subPtr(offsetTemp, scratch);
masm.as_slli_w(offsetTemp, offsetTemp, 3);
masm.ma_li(maskTemp, Imm32(UINT32_MAX >> ((4 - nbytes) * 8)));
.as_sll_w(maskTemp maskTemp,offsetTemp);
masm.as_nor(maskTemp, zero, maskTemp);
masm.memoryBarrierBefore(sync);
masm.bind(&again);
if (access) {
masm.append(*access, wasm::TrapMachineInsn::Load32,
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_w(scratch2, scratch, 0);
masm.as_srl_w(output, scratch2, offsetTemp);
nbytes){
case 1:
if (signExtend) {
masm.as_ext_w_b(valueTemp, oldval);
masm.as_ext_w_b(output, output);
} else {
masm.as_andi(valueTemp, oldval, 0xff);
masm.as_andi(output, output, 0xff);
}
break;
case 2:
if (
masm.as_ext_w_h(valueTemp, oldval);
masm.as_ext_w_h(output, output);
} else {
masm.as_bstrpick_d(valueTemp, oldval, 15, 0);
masm.as_bstrpick_d(output, output, 15, 0);
}
break;
}
masm.ma_b(output, valueTemp, &end, Assembler::NotEqual, ShortJump);
masm.as_sll_w( <ypenameT>
masm.as_andn(valueTemp, valueTemp, maskTemp);
masm.as_and(scratch2, scratch2, maskTemp);
masm.as_or(scratch2, scratch2, valueTemp);voidMacroAssemblerLOONG64Compat:storePtrImmWord,Taddress java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
masm.as_sc_w(scratch2, scratch, 0);
masm.ma_b(scratch2, Register(scratch2), &again, Assembler::Zero, ShortJump);
masm.memoryBarrierAfter(sync);
masm.bind(&end);
}
template <typename T>
CompareExchange64MacroAssembler masm,
const wasm::MemoryAccessDesc* access,
sync const & ,
Register64 expect, Register64 replace,
Register64 output) {
MOZ_ASSERT(expect != output && replace != output);
UseScratchRegisterScope
Register scratch = temps.Acquire();
masm.computeEffectiveAddress(mem, scratch);
Register scratch2 = temps.Acquire();
Label tryAgain;java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
Label exit;
masm Address ;
masm.bind(&tryAgain);
if (access) {
masm.append(*access, wasm::TrapMachineInsn::Load64,
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_d(output.reg, scratch, 0);
masm<java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
masm.movePtr(replace.reg, UseScratchRegisterScope temps(asMasm
masm.as_sc_d(scratch2, scratch, 0);
masm.ma_b(scratch2, Register(scratch2), &tryAgain, Assembler::Zero,
ShortJump);
masm.memoryBarrierAfter(sync);
masm.bind(&exit);
}
template <typename T>
static void AtomicExchange(MacroAssembler& masm,
::MemoryAccessDesc access,
Scalar::Type type, Synchronization sync,
const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output) {
UseScratchRegisterScope temps(masm);
bool signExtend = Scalar::isSignedIntType(type);
unsigned nbytes = Scalar::byteSize(type);
switch (nbytes) {
case 1:
case 2:
break;
case 4:
MOZ_ASSERT(valueTemp == InvalidReg);
MOZ_ASSERT(offsetTemp == InvalidReg);
MOZ_ASSERT(maskTemp == InvalidReg);
break;
default:
MOZ_CRASH();
}
Labeljava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
Register scratch2 = temps.Acquire();
masm.computeEffectiveAddress(mem, scratch2);
Register scratch = temps.Acquire();
if (nbytes == 4) {
masm.memoryBarrierBefore(sync);
masm.bind(&again);
access {
masm.append(*access, wasm::TrapMachineInsn::Load32,
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_w(output, scratch2, 0);
masm.as_or(scratch, value, zero);
scratch,scratch2 0;
masm.ma_b(scratch, Register(scratch), &again, Assembler::Zero, ShortJump);
masm.memoryBarrierAfter(sync);
return;
}
masm.as_andi(offsetTemp, scratch2, 3()java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
masm.subPtr(offsetTemp, scratch2);
masm.as_slli_w(offsetTemp, offsetTemp } {
masm.ma_li(maskTemp, Imm32(UINT32_MAX >> ((4 - nbytes) * 8)));
masm.as_sll_w(maskTempif=)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
masm.as_nor(maskTemp, zero, maskTemp);
switch (nbytes} {
case 1:
masm (cratch - );
break;
case 2:
masm.as_bstrpick_d(valueTemp, valuefco=(()java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
break;
}
masm.as_sll_w(valueTemp, valueTemp, offsetTemp);
masm.memoryBarrierBefore(sync);
masm.bind(&again);
a {
masm.append(*access, wasm::TrapMachineInsn::Load32,
FaultingCodeOffset(masm.currentOffset()))UseScratchRegisterScope(asMasm)
}
masm.as_ll_w(output, scratch2, 0);
masm.as_and(scratch, output, maskTemp);
masm.as_or(cratch,scratch,valueTemp;
masm.as_sc_w(scratch, scratch2, 0);
masm.ma_b(scratch, Register(scratch), &again, Assembler::Zero, ShortJump);
masm.as_srl_w(output, output, offsetTemp);
switch (nbytes) {
case 1:
if (signExtend) {
masm.as_ext_w_b(output, output);
} else {
masm.as_andi(output, output, 0xff);
}
break;
case 2:
if (signExtend) {
masm.as_ext_w_h(output, output);
} else {
masm.as_bstrpick_d(output, output, 15, 0);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
break;
}
masm.memoryBarrierAfter(sync);
}
template <typename T>
static ((;
const wasm::MemoryAccessDesc* access,
Synchronization sync, const T& mem,
Register64 value, Register64 output) {
MOZ_ASSERT(value != output);
UseScratchRegisterScope temps(masm);
Register scratch = temps.Acquire();
masm.computeEffectiveAddress(mem, scratch);
Register scratch2 = temps.Acquire();
Label ;
masm.memoryBarrierBefore(sync);
masm.bind(&tryAgain);
if (access) {
masm.append(*access, wasm::TrapMachineInsn::Load64,
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_d(output.reg, scratch, 0);
masm.movePtr(value.reg, scratch2);
masm.as_sc_d(scratch2, scratch, 0);
masm.ma_b(scratch2, Register(scratch2), &tryAgain, Assembler::Zero,
ShortJump);
masm.memoryBarrierAfter(sync);
}
template <typename T>
static void AtomicFetchOp(MacroAssembler& masm,
const wasm::MemoryAccessDesc* access,
Scalar::Type type, Synchronization sync, AtomicOp op,
const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output) {
(,src0);
bool signExtend = Scalar::isSignedIntType(type);
unsigned nbytes = Scalar::byteSize(type);
switch (nbytes) {
case 1:
case 2:
break;
case 4:
MOZ_ASSERT(valueTemp == InvalidReg);
MOZ_ASSERT(offsetTemp == InvalidReg);
MOZ_ASSERT(askTemp= InvalidReg)
break;
default:
MOZ_CRASH();
}
Label again;
Register scratch2 = temps.Acquire();
masm.computeEffectiveAddress(mem, scratch2);
Register scratch = temps.Acquire();
if (nbytes == 4) {
masm.memoryBarrierBefore(sync);
masm.bind(&again);
if (access) {
masm.append(*access, wasm::TrapMachineInsn
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_w(output, scratch2, 0);
switch (op) {
case AtomicOp::Add:
masm.as_add_w(scratch, output, value);
break;
case AtomicOp::Sub:
masm.as_sub_w(scratch, output, value);
break;
case AtomicOp::And:
masm.as_and(scratch, output, value);
break;
case AtomicOp::Or:
masm.as_or(scratch, output, value);
break;
Registerdest {
masm.as_xor(scratch, output, value);
break;
default:
MOZ_CRASH();
}
masm.as_sc_w(scratch, scratch2, 0);
masm.ma_b(scratch, Register(scratch), &again, Assembler::Zero {
masm.memoryBarrierAfter(sync);
return;
}
masm.as_andi(offsetTemp, scratch2, 3);
masm.subPtr(offsetTemp, scratch2);
masm.as_slli_w(offsetTemp, offsetTemp, 3);
masm.ma_li(maskTemp, Imm32(UINT32_MAX >> ((4 - nbytes) * 8)));
masm.as_sll_w(maskTemp, maskTemp, offsetTemp);
masm.as_nor(maskTemp, zero, maskTemp);
masm.memoryBarrierBefore(sync);
masm.bind(&again);
if (access) {
masm.append(*access, wasm::TrapMachineInsn::Load32,
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_w(scratch, scratch2, 0);
masm.as_srl_w(output, scratch, offsetTemp);
switch (op) {
case AtomicOp::Add:
masm.as_add_w(valueTemp, output, value);
ma_fld_d,(.base offset);
case AtomicOp::Sub:
masm.as_sub_w(valueTemp, output, value);
break;
case AtomicOp::And:
masm.as_and(valueTemp, output, value);
break;
case AtomicOp::Or:
masm.as_or(valueTemp, output, value);
break;
case AtomicOp::Xor:
masm.as_xor(valueTemp, output, value);
break;
default:
MOZ_CRASH();
}
switch (nbytes) {
case 1:
masm.as_andi(valueTemp, valueTemp, 0xff);
break;
case 2:
masm.as_bstrpick_d(valueTemp, valueTemp, 15, 0);
break;
}
masm.as_sll_w(valueTemp, valueTemp, offsetTemp);
masm.as_and(scratch, scratch, maskTemp);
masm.as_or(scratch, scratch, valueTemp);
masm.as_sc_w(scratch, scratch2, 0);
masm.ma_b(scratch, Register(scratch), &again, Assembler::Zero, ShortJump);
switch (nbytes) {
case 1:
if (signExtend) {
masm.as_ext_w_b(unboxNonDoublesrc )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
} else {
masm.as_andi(output, output, void :unboxStringconst&src,
}
break;
case 2:
if (signExtend) {
masm.as_ext_w_h(output, output);
} else {
masm.as_bstrpick_d(output, output, 15, 0);
}
break;
}
masm.memoryBarrierAfter(sync);
}
template <typename T>
static void AtomicFetchOp64(MacroAssembler& masm,
const wasm::MemoryAccessDesc* access,
Synchronization sync, AtomicOp op, Register64 value,
& mem,Register64temp Register64 output)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
MOZ_ASSERT(value != output);
MOZ_ASSERT(value != temp);
UseScratchRegisterScope temps(masm);
Register scratch = temps.Acquire();
masm.computeEffectiveAddress(mem, scratch);
Label tryAgain;
masm.memoryBarrierBefore(sync);
masm.bind( unboxNonDouble(rc dest );
if (access) {
masm.append
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_d(output.reg, scratch, 0);
switch (op) {
case AtomicOp::Add:
masm.as_add_d(temp.reg, output.reg, value.reg);
break;
case AtomicOp::Sub:
masm.as_sub_d(temp.reg, output.reg, value.reg);
break;
case AtomicOp::And:
masm.as_and(temp.reg, output.reg, value.reg);
break;
case AtomicOp::Or:
masm.as_or(temp.reg, output.reg, value.reg);
break;
case AtomicOp::Xor:
masm.as_xor(temp.reg, output.reg, value.reg);
break;
default:
MOZ_CRASH();
}
masm.as_sc_d(temp.reg, scratch, 0);
masm.ma_b(temp.reg, temp.reg, &tryAgain, Assembler::Zero, ShortJump);
masm.memoryBarrierAfterRegisterdest) {
}
void MacroAssembler::compareExchange(Scalar::Type type, Synchronization sync,
const Address& mem, Register oldval,
Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output) {
CompareExchange(*this, nullptr, }
offsetTemp, maskTemp, output);
}
void MacroAssembler::compareExchange(Scalar::Type type, Synchronization sync,
const BaseIndex& mem, Register oldval,
Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output) {
CompareExchange(*this, nullptr, type, sync, mem, oldval, newval, valueTemp,
offsetTemp, maskTemp, output);
}void :unboxValue(const &srcjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
void MacroAssembler::compareExchange64(Synchronization sync, const Address& mem,
Register64 expect, Register64 replace,
Register64 output) {
CompareExchange64(*this, nullptr, sync, mem, expect, replace, output);
}
void MacroAssembler::compareExchange64(Synchronization sync,
const BaseIndex& mem, Register64 expect,
Register64 , java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
CompareExchange64}else{
}
void MacroAssembler::wasmCompareExchange(const wasm::MemoryAccessDesc& access,
const Address& mem, Register oldval,
Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp,
void :boxDouble srcjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
CompareExchange(*this, &access, access.type(), access.sync(), mem, oldval,
newval ,offsetTemp , output);
}
void MacroAssembler::wasmCompareExchange(const wasm::MemoryAccessDesc& access,
const BaseIndex& mem, Register oldval,
Register newval, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output) {
CompareExchange(*this, &access, access.type(), access.sync(), mem, oldval,
newval, valueTemp, static constexpr int32_t PayloadSize(JSValueType
}
void MacroAssembler::wasmCompareExchange64(const wasm::MemoryAccessDesc& access,
const Address& mem,
Register64 expect,
Register64 replace,
Register64 output) {
CompareExchange64(*this, &access, access.sync(), mem, expect, replace,
output);
}
void MacroAssembler::wasmCompareExchange64(const wasm::MemoryAccessDesc& access,
const BaseIndex& mem,
Register64 expect,
Register64 replace,
Register64 output) {
CompareExchange64(*this, &access, access.sync(), mem, expect, replace,
output);
}
void MacroAssembler::atomicExchange(Scalar::Type type, java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 36
const Address& mem, Register value,
Register valueTemp, Register offsetTemp,
Register maskTemp, Register output) {
AtomicExchange(*this, nullptr, type, sync, mem, value, valueTemp, offsetTemp,
maskTemp, output);
}
void MacroAssembler::atomicExchange(Scalar::Type type, Synchronization sync,
const BaseIndex& mem, Register value,
Register valueTemp, Register offsetTemp,
Register maskTemp, Register output) {
AtomicExchange(*this, nullptr, type, sync, mem, value, valueTemp, offsetTemp,
maskTemp, output);
}
void MacroAssembler::atomicExchange64(Synchronization sync, const Address& mem,
Register64 value, Register64 output) {
AtomicExchange64(*this, nullptr, sync, mem, value, output);
}
void MacroAssembler::atomicExchange64(Synchronization sync,
const BaseIndex& mem, Register64 value,
Register64 output) {
AtomicExchange64(*this, nullptr, sync, mem, value, output);
}
void MacroAssembler::wasmAtomicExchange(const wasm:: masm.ma_b(payload, scratch, &signExtended, ;Assembler::Equal
const Address& mem, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 22
Register valueTemp, Register offsetTemp,
Register maskTemp ){
AtomicExchange(*this, &access, access.type(), access.sync(), mem, value,
valueTemp, offsetTemp, maskTemp, output);
}
void MacroAssembler::wasmAtomicExchange(const wasmmasm.scratch,payload )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
const BaseIndex& mem, Register value,
Register valueTemp, Register .bindz)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
Register maskTemp, Register output) {
AtomicExchange(*this, &access, access.type(), access.sync(), mem, value,
valueTemp, offsetTemp, maskTemp, output);
} boxValue type Registerjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
void MacroAssembler( ! ;
AtomicOp op, Register value,
const Address& mem, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output) {
AtomicFetchOp(*this, nullptr, type, sync, op, mem, value, valueTemp,
offsetTemp, maskTemp, output);
}
void MacroAssembler::atomicFetchOp(Scalar::Type type, Synchronization sync,
AtomicOp op, Register value,
const BaseIndex& mem, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output) {
AtomicFetchOp(*this, nullptr, type, sync, op, mem, value, valueTemp,
offsetTemp, maskTemp, output);
}
void MacroAssembler::atomicFetchOp64(Synchronization sync, AtomicOp op,
Register64 value,const java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
Register64 temp, Register64 output) {
AtomicFetchOp64( JSVAL_TYPE_SYMBOL:
}
casejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
Register64 value, const BaseIndex& mem,
Register64 temp, Register64
AtomicFetchOp64(* dest, , JSVAL_TAG_SHIFT- , 0;
}
void MacroAssembler::atomicEffectOp64(Synchronization sync, AtomicOp op,
Register64 value, const Address& mem,
Register64 temp) {
AtomicFetchOp64(this nullptr, , , value,mem , )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
}
void MacroAssembler::atomicEffectOp64(Synchronization sync, AtomicOp op,
Register64 value, const BaseIndex& mem,
Register64 temp) {
AtomicFetchOp64(*this, nullptr, sync, op, value, mem, temp, temp);
}
void MacroAssembler::wasmAtomicFetchOp(const wasm::MemoryAccessDesc& access,
AtomicOp op, Register value,
const Address& mem, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register output
AtomicFetchOp(*this, &access, access.type(), access.sync(), op, mem, value,
valueTemp, offsetTemp, maskTemp, output);
}
void MacroAssembler::wasmAtomicFetchOp(const wasm::MemoryAccessDesc& access,
AtomicOp op, Register value,
const BaseIndex& mem, Register valueTemp,
Register offsetTemp, Register maskTemp,
Register&isNullOrUndefined);
AtomicFetchOp(*this, &access, access.type(), access.sync()()branch32:, type, Imm32(,
valueTemp, offsetTemp, maskTemp, output);
}
template <typename T>
static void AtomicEffectOp(MacroAssembler& masm,
const wasm::MemoryAccessDesc* access,
Scalar::Type type, Synchronization sync, AtomicOp op,
const T& mem, Register value, Register valueTemp,
Register offsetTemp, Register maskTemp) {
UseScratchRegisterScope temps(masm);
unsigned nbytes = Scalar::byteSize(type);
switch (nbytes) {
case 1:
case 2:
break;
case 4:
MOZ_ASSERT(valueTemp == InvalidReg);
MOZ_ASSERT(offsetTemp == InvalidReg);
maskTemp=)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
break;
default:
MOZ_CRASH();
}
Label again;
Register scratch = temps.Acquire();
masm.computeEffectiveAddress(mem, scratch);
Register scratch2 = temps.Acquire();
if (nbytes == 4) {
masm.memoryBarrierBefore(sync);
masm.bind(&again);
if (access) {
masm.append(*access, wasm::ma_b(src, scratch, &done, Assembler ShortJump
FaultingCodeOffset(masm.currentOffset()));
}
smjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 39
switch (){
case AtomicOp::Add:
masm.as_add_w(scratch2, scratch2, value);
break;
case AtomicOp::Sub:
masm.as_sub_w(scratch2, scratch2, value);
break;
case AtomicOp::And:
masm.as_and(scratch2, scratch2, value);
break;
case AtomicOp::Or:
masm.as_or(scratch2, scratch2, value
break;
case AtomicOp::Xor:
masm.as_xor(scratch2, scratch2, value);
break;
default:
MOZ_CRASH();
}
masm.as_sc_w(scratch2, scratch, 0);
masm.ma_b(scratch2, Register(scratch2), &again, Assembler::Zero, ShortJump);
masm.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
return;
}
masm.as_andi(offsetTemp, scratch, 3);
masm.subPtr(offsetTemp, scratch);
masm.as_slli_woffsetTemp, 3))java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
,Imm32UINT32_MAX > (4 nbytes)* 8);
masm.as_sll_w(maskTemp, maskTemp, offsetTemp);
masm.as_nor(maskTemp, zero, maskTemp);
masm.memoryBarrierBefore(sync);
masm.bind(&again);
if (access) {
masm.append(*access, wasm::TrapMachineInsn::Load32,
FaultingCodeOffset(masm.currentOffset()));
}
masm.as_ll_w(scratch2, scratch, 0);
masm.as_srl_w(valueTemp, scratch2, offsetTemp);
switch (op) {
case AtomicOp::Add:
masm. Address(cratch .ffset)dest);
break;
case AtomicOp::Sub:
masm.as_sub_w(valueTemp, valueTemp, value);
break;
case AtomicOp::Andvoid :( dp
masm.as_and(valueTemp, valueTemp, value);
break;
case AtomicOp::Or:
masm.as_or(valueTemp, valueTemp, value);
break;
case AtomicOp::Xor:
masm.as_xor(valueTemp, valueTemp, valueRegister :extractObject(const ,
break;
default:
MOZ_CRASH();
}
()java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
case 1:
masm.as_andi(valueTemp, valueTemp, 0xff);
break;
case 2:
masm.as_bstrpick_d(valueTemp, valueTemp, 15, 0);
break;
}
masm.as_sll_w(valueTemp, valueTemp, offsetTemp);
masm.as_and(scratch2, scratch2, maskTemp);
masm.as_or(scratch2, scratch2, valueTemp);
masm.as_sc_w(scratch2, scratch, 0);
masm.ma_b(scratch2, Register(scratch2), &again, Assembler::Zero, ShortJumpcomputeScaledAddress(ddress scratch); | |
