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

Bug 1290337 - Part 11: Replace ConstantOrRegister parameter to const ConstantOrRegister&. r=nbp

Browse Source
This commit is contained in:
Tooru Fujisawa 2016-09-11 18:15:23 +09:00
parent 5b44531d1d
commit 22d9bd985f
14 changed files with 110 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
js/src/jit/CodeGenerator.cpp
View File

@ -8620,7 +8620,7 @@ static const VMFunction ArrayPushDenseInfo =
void
CodeGenerator::emitArrayPush(LInstruction* lir, const MArrayPush* mir, Register obj,
ConstantOrRegister value, Register elementsTemp, Register length)
const ConstantOrRegister& value, Register elementsTemp, Register length)
{
OutOfLineCode* ool = oolCallVM(ArrayPushDenseInfo, lir, ArgList(obj, value), StoreRegisterTo(length));
@ -9912,7 +9912,7 @@ CodeGenerator::visitNameIC(OutOfLineUpdateCache* ool, DataPtr<NameIC>& ic)
void
CodeGenerator::addGetPropertyCache(LInstruction* ins, LiveRegisterSet liveRegs, Register objReg,
ConstantOrRegister id, TypedOrValueRegister output,
const ConstantOrRegister& id, TypedOrValueRegister output,
bool monitoredResult, bool allowDoubleResult,
jsbytecode* profilerLeavePc)
{
@ -9924,7 +9924,8 @@ CodeGenerator::addGetPropertyCache(LInstruction* ins, LiveRegisterSet liveRegs,
void
CodeGenerator::addSetPropertyCache(LInstruction* ins, LiveRegisterSet liveRegs, Register objReg,
Register temp, Register tempUnbox, FloatRegister tempDouble,
FloatRegister tempF32, ConstantOrRegister id, ConstantOrRegister value,
FloatRegister tempF32, const ConstantOrRegister& id,
const ConstantOrRegister& value,
bool strict, bool needsTypeBarrier, bool guardHoles,
jsbytecode* profilerLeavePc)
{

7
js/src/jit/CodeGenerator.h
View File

@ -311,7 +311,7 @@ class CodeGenerator final : public CodeGeneratorSpecific
void visitArrayPopShiftV(LArrayPopShiftV* lir);
void visitArrayPopShiftT(LArrayPopShiftT* lir);
void emitArrayPush(LInstruction* lir, const MArrayPush* mir, Register obj,
ConstantOrRegister value, Register elementsTemp, Register length);
const ConstantOrRegister& value, Register elementsTemp, Register length);
void visitArrayPushV(LArrayPushV* lir);
void visitArrayPushT(LArrayPushT* lir);
void visitArraySlice(LArraySlice* lir);
@ -439,12 +439,13 @@ class CodeGenerator final : public CodeGeneratorSpecific
private:
void addGetPropertyCache(LInstruction* ins, LiveRegisterSet liveRegs, Register objReg,
ConstantOrRegister id, TypedOrValueRegister output,
const ConstantOrRegister& id, TypedOrValueRegister output,
bool monitoredResult, bool allowDoubleResult,
jsbytecode* profilerLeavePc);
void addSetPropertyCache(LInstruction* ins, LiveRegisterSet liveRegs, Register objReg,
Register temp, Register tempUnbox, FloatRegister tempDouble,
FloatRegister tempF32, ConstantOrRegister id, ConstantOrRegister value,
FloatRegister tempF32, const ConstantOrRegister& id,
const ConstantOrRegister& value,
bool strict, bool needsTypeBarrier, bool guardHoles,
jsbytecode* profilerLeavePc);

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

@ -2351,7 +2351,7 @@ IonCache::reset(ReprotectCode reprotect)
// Jump to failure if a value being written is not a property for obj/id.
static void
CheckTypeSetForWrite(MacroAssembler& masm, JSObject* obj, jsid id,
Register scratch, ConstantOrRegister value, Label* failure)
Register scratch, const ConstantOrRegister& value, Label* failure)
{
TypedOrValueRegister valReg = value.reg();
ObjectGroup* group = obj->group();
@ -2369,7 +2369,7 @@ CheckTypeSetForWrite(MacroAssembler& masm, JSObject* obj, jsid id,
static void
GenerateSetSlot(JSContext* cx, MacroAssembler& masm, IonCache::StubAttacher& attacher,
JSObject* obj, Shape* shape, Register object, Register tempReg,
ConstantOrRegister value, bool needsTypeBarrier, bool checkTypeset,
const ConstantOrRegister& value, bool needsTypeBarrier, bool checkTypeset,
Label* failures)
{
TestMatchingReceiver(masm, attacher, object, obj, failures, needsTypeBarrier);
@ -2542,7 +2542,7 @@ ProxySetProperty(JSContext* cx, HandleObject proxy, HandleId id, HandleValue v,
static bool
EmitCallProxySet(JSContext* cx, MacroAssembler& masm, IonCache::StubAttacher& attacher,
HandleId propId, LiveRegisterSet liveRegs, Register object,
ConstantOrRegister value, void* returnAddr, bool strict)
const ConstantOrRegister& value, void* returnAddr, bool strict)
{
MacroAssembler::AfterICSaveLive aic = masm.icSaveLive(liveRegs);
@ -2688,7 +2688,7 @@ static bool
GenerateCallSetter(JSContext* cx, IonScript* ion, MacroAssembler& masm,
IonCache::StubAttacher& attacher, HandleObject obj, HandleObject holder,
HandleShape shape, bool strict, Register object, Register tempReg,
ConstantOrRegister value, Label* failure, LiveRegisterSet liveRegs,
const ConstantOrRegister& value, Label* failure, LiveRegisterSet liveRegs,
void* returnAddr)
{
// Generate prototype guards if needed.
@ -3005,7 +3005,7 @@ SetPropertyIC::attachCallSetter(JSContext* cx, HandleScript outerScript, IonScri
static void
GenerateAddSlot(JSContext* cx, MacroAssembler& masm, IonCache::StubAttacher& attacher,
JSObject* obj, Shape* oldShape, ObjectGroup* oldGroup,
Register object, Register tempReg, ConstantOrRegister value,
Register object, Register tempReg, const ConstantOrRegister& value,
bool checkTypeset, Label* failures)
{
// Use a modified version of TestMatchingReceiver that uses the old shape and group.
@ -3178,7 +3178,8 @@ SetPropertyIC::attachAddSlot(JSContext* cx, HandleScript outerScript, IonScript*
}
static bool
CanInlineSetPropTypeCheck(JSObject* obj, jsid id, ConstantOrRegister val, bool* checkTypeset)
CanInlineSetPropTypeCheck(JSObject* obj, jsid id, const ConstantOrRegister& val,
bool* checkTypeset)
{
bool shouldCheck = false;
ObjectGroup* group = obj->group();
@ -3217,7 +3218,7 @@ CanInlineSetPropTypeCheck(JSObject* obj, jsid id, ConstantOrRegister val, bool*
static bool
IsPropertySetInlineable(NativeObject* obj, HandleId id, MutableHandleShape pshape,
ConstantOrRegister val, bool needsTypeBarrier, bool* checkTypeset)
const ConstantOrRegister& val, bool needsTypeBarrier, bool* checkTypeset)
{
// CanInlineSetPropTypeCheck assumes obj has a non-lazy group.
MOZ_ASSERT(!obj->hasLazyGroup());
@ -3272,7 +3273,8 @@ PrototypeChainShadowsPropertyAdd(JSContext* cx, JSObject* obj, jsid id)
}
static bool
IsPropertyAddInlineable(JSContext* cx, NativeObject* obj, HandleId id, ConstantOrRegister val,
IsPropertyAddInlineable(JSContext* cx, NativeObject* obj, HandleId id,
const ConstantOrRegister& val,
HandleShape oldShape, bool needsTypeBarrier, bool* checkTypeset)
{
// If the shape of the object did not change, then this was not an add.
@ -3315,7 +3317,7 @@ IsPropertyAddInlineable(JSContext* cx, NativeObject* obj, HandleId id, ConstantO
}
static SetPropertyIC::NativeSetPropCacheability
CanAttachNativeSetProp(JSContext* cx, HandleObject obj, HandleId id, ConstantOrRegister val,
CanAttachNativeSetProp(JSContext* cx, HandleObject obj, HandleId id, const ConstantOrRegister& val,
bool needsTypeBarrier, MutableHandleObject holder,
MutableHandleShape shape, bool* checkTypeset)
{
@ -3357,8 +3359,8 @@ CanAttachNativeSetProp(JSContext* cx, HandleObject obj, HandleId id, ConstantOrR
static void
GenerateSetUnboxed(JSContext* cx, MacroAssembler& masm, IonCache::StubAttacher& attacher,
JSObject* obj, jsid id, uint32_t unboxedOffset, JSValueType unboxedType,
Register object, Register tempReg, ConstantOrRegister value, bool checkTypeset,
Label* failures)
Register object, Register tempReg, const ConstantOrRegister& value,
bool checkTypeset, Label* failures)
{
// Guard on the type of the object.
masm.branchPtr(Assembler::NotEqual,
@ -3388,7 +3390,7 @@ GenerateSetUnboxed(JSContext* cx, MacroAssembler& masm, IonCache::StubAttacher&
}
static bool
CanAttachSetUnboxed(JSContext* cx, HandleObject obj, HandleId id, ConstantOrRegister val,
CanAttachSetUnboxed(JSContext* cx, HandleObject obj, HandleId id, const ConstantOrRegister& val,
bool needsTypeBarrier, bool* checkTypeset,
uint32_t* unboxedOffset, JSValueType* unboxedType)
{
@ -3409,7 +3411,8 @@ CanAttachSetUnboxed(JSContext* cx, HandleObject obj, HandleId id, ConstantOrRegi
}
static bool
CanAttachSetUnboxedExpando(JSContext* cx, HandleObject obj, HandleId id, ConstantOrRegister val,
CanAttachSetUnboxedExpando(JSContext* cx, HandleObject obj, HandleId id,
const ConstantOrRegister& val,
bool needsTypeBarrier, bool* checkTypeset, Shape** pshape)
{
if (!obj->is<UnboxedPlainObject>())
@ -3433,7 +3436,7 @@ CanAttachSetUnboxedExpando(JSContext* cx, HandleObject obj, HandleId id, Constan
static bool
CanAttachAddUnboxedExpando(JSContext* cx, HandleObject obj, HandleShape oldShape,
HandleId id, ConstantOrRegister val,
HandleId id, const ConstantOrRegister& val,
bool needsTypeBarrier, bool* checkTypeset)
{
if (!obj->is<UnboxedPlainObject>())
@ -4050,7 +4053,7 @@ static void
GenerateGetTypedOrUnboxedArrayElement(JSContext* cx, MacroAssembler& masm,
IonCache::StubAttacher& attacher,
HandleObject array, const Value& idval, Register object,
ConstantOrRegister index, TypedOrValueRegister output,
const ConstantOrRegister& index, TypedOrValueRegister output,
bool allowDoubleResult)
{
MOZ_ASSERT(GetPropertyIC::canAttachTypedOrUnboxedArrayElement(array, idval, output));
@ -4299,7 +4302,7 @@ GetPropertyIC::tryAttachArgumentsElement(JSContext* cx, HandleScript outerScript
}
static bool
IsDenseElementSetInlineable(JSObject* obj, const Value& idval, ConstantOrRegister val,
IsDenseElementSetInlineable(JSObject* obj, const Value& idval, const ConstantOrRegister& val,
bool needsTypeBarrier, bool* checkTypeset)
{
if (!obj->is<ArrayObject>())
@ -4344,7 +4347,7 @@ IsTypedArrayElementSetInlineable(JSObject* obj, const Value& idval, const Value&
}
static void
StoreDenseElement(MacroAssembler& masm, ConstantOrRegister value, Register elements,
StoreDenseElement(MacroAssembler& masm, const ConstantOrRegister& value, Register elements,
BaseObjectElementIndex target)
{
// If the ObjectElements::CONVERT_DOUBLE_ELEMENTS flag is set, int32 values
@ -4400,8 +4403,9 @@ StoreDenseElement(MacroAssembler& masm, ConstantOrRegister value, Register eleme
static bool
GenerateSetDenseElement(JSContext* cx, MacroAssembler& masm, IonCache::StubAttacher& attacher,
JSObject* obj, const Value& idval, bool guardHoles, Register object,
TypedOrValueRegister index, ConstantOrRegister value, Register tempToUnboxIndex,
Register temp, bool needsTypeBarrier, bool checkTypeset)
TypedOrValueRegister index, const ConstantOrRegister& value,
Register tempToUnboxIndex, Register temp,
bool needsTypeBarrier, bool checkTypeset)
{
MOZ_ASSERT(obj->isNative());
MOZ_ASSERT(idval.isInt32());
@ -4537,7 +4541,7 @@ SetPropertyIC::tryAttachDenseElement(JSContext* cx, HandleScript outerScript, Io
static bool
GenerateSetTypedArrayElement(JSContext* cx, MacroAssembler& masm, IonCache::StubAttacher& attacher,
HandleObject tarr, Register object, TypedOrValueRegister index,
ConstantOrRegister value, Register tempUnbox, Register temp,
const ConstantOrRegister& value, Register tempUnbox, Register temp,
FloatRegister tempDouble, FloatRegister tempFloat32)
{
Label failures, done, popObjectAndFail;

7
js/src/jit/IonCaches.h
View File

@ -411,7 +411,7 @@ class GetPropertyIC : public IonCache
public:
GetPropertyIC(LiveRegisterSet liveRegs,
Register object, ConstantOrRegister id,
Register object, const ConstantOrRegister& id,
TypedOrValueRegister output,
bool monitoredResult, bool allowDoubleResult)
: liveRegs_(liveRegs),
@ -602,8 +602,9 @@ class SetPropertyIC : public IonCache
public:
SetPropertyIC(LiveRegisterSet liveRegs, Register object, Register temp, Register tempToUnboxIndex,
FloatRegister tempDouble, FloatRegister tempFloat32, ConstantOrRegister id,
ConstantOrRegister value, bool strict, bool needsTypeBarrier, bool guardHoles)
FloatRegister tempDouble, FloatRegister tempFloat32,
const ConstantOrRegister& id, const ConstantOrRegister& value,
bool strict, bool needsTypeBarrier, bool guardHoles)
: liveRegs_(liveRegs),
object_(object),
temp_(temp),

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

@ -576,7 +576,7 @@ StoreUnboxedFailure(MacroAssembler& masm, Label* failure)
template <typename T>
void
MacroAssembler::storeUnboxedProperty(T address, JSValueType type,
ConstantOrRegister value, Label* failure)
const ConstantOrRegister& value, Label* failure)
{
switch (type) {
case JSVAL_TYPE_BOOLEAN:
@ -695,11 +695,11 @@ MacroAssembler::storeUnboxedProperty(T address, JSValueType type,
template void
MacroAssembler::storeUnboxedProperty(Address address, JSValueType type,
ConstantOrRegister value, Label* failure);
const ConstantOrRegister& value, Label* failure);
template void
MacroAssembler::storeUnboxedProperty(BaseIndex address, JSValueType type,
ConstantOrRegister value, Label* failure);
const ConstantOrRegister& value, Label* failure);
void
MacroAssembler::checkUnboxedArrayCapacity(Register obj, const RegisterOrInt32Constant& index,
@ -1879,7 +1879,8 @@ MacroAssembler::convertValueToFloatingPoint(JSContext* cx, const Value& v, Float
}
bool
MacroAssembler::convertConstantOrRegisterToFloatingPoint(JSContext* cx, ConstantOrRegister src,
MacroAssembler::convertConstantOrRegisterToFloatingPoint(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister output, Label* fail,
MIRType outputType)
{
@ -2148,7 +2149,8 @@ MacroAssembler::convertValueToInt(JSContext* cx, const Value& v, Register output
}
bool
MacroAssembler::convertConstantOrRegisterToInt(JSContext* cx, ConstantOrRegister src,
MacroAssembler::convertConstantOrRegisterToInt(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister temp, Register output,
Label* fail, IntConversionBehavior behavior)
{
@ -2452,7 +2454,7 @@ MacroAssembler::Push(TypedOrValueRegister v)
}
void
MacroAssembler::Push(ConstantOrRegister v)
MacroAssembler::Push(const ConstantOrRegister& v)
{
if (v.constant())
Push(v.value());

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

@ -438,7 +438,7 @@ class MacroAssembler : public MacroAssemblerSpecific
void Push(FloatRegister reg) PER_SHARED_ARCH;
void Push(jsid id, Register scratchReg);
void Push(TypedOrValueRegister v);
void Push(ConstantOrRegister v);
void Push(const ConstantOrRegister& v);
void Push(const ValueOperand& val);
void Push(const Value& val);
void Push(JSValueType type, Register reg);
@ -1294,7 +1294,7 @@ class MacroAssembler : public MacroAssemblerSpecific
inline void storeFloat32x3(FloatRegister src, const BaseIndex& dest) PER_SHARED_ARCH;
template <typename T>
void storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
void storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType, const T& dest,
MIRType slotType) PER_ARCH;
public:
@ -1468,7 +1468,7 @@ class MacroAssembler : public MacroAssemblerSpecific
inline void storeObjectOrNull(Register src, const T& dest);
template <typename T>
void storeConstantOrRegister(ConstantOrRegister src, const T& dest) {
void storeConstantOrRegister(const ConstantOrRegister& src, const T& dest) {
if (src.constant())
storeValue(src.value(), dest);
else
@ -1608,7 +1608,7 @@ class MacroAssembler : public MacroAssemblerSpecific
// in the property.
template <typename T>
void storeUnboxedProperty(T address, JSValueType type,
ConstantOrRegister value, Label* failure);
const ConstantOrRegister& value, Label* failure);
void checkUnboxedArrayCapacity(Register obj, const RegisterOrInt32Constant& index,
Register temp, Label* failure);
@ -1853,7 +1853,7 @@ class MacroAssembler : public MacroAssemblerSpecific
FloatRegister output, Label* fail,
MIRType outputType);
MOZ_MUST_USE bool convertConstantOrRegisterToFloatingPoint(JSContext* cx,
ConstantOrRegister src,
const ConstantOrRegister& src,
FloatRegister output, Label* fail,
MIRType outputType);
void convertTypedOrValueToFloatingPoint(TypedOrValueRegister src, FloatRegister output,
@ -1870,7 +1870,8 @@ class MacroAssembler : public MacroAssemblerSpecific
Label* fail) {
return convertValueToFloatingPoint(cx, v, output, fail, MIRType::Double);
}
MOZ_MUST_USE bool convertConstantOrRegisterToDouble(JSContext* cx, ConstantOrRegister src,
MOZ_MUST_USE bool convertConstantOrRegisterToDouble(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister output, Label* fail)
{
return convertConstantOrRegisterToFloatingPoint(cx, src, output, fail, MIRType::Double);
@ -1886,7 +1887,8 @@ class MacroAssembler : public MacroAssemblerSpecific
Label* fail) {
return convertValueToFloatingPoint(cx, v, output, fail, MIRType::Float32);
}
MOZ_MUST_USE bool convertConstantOrRegisterToFloat(JSContext* cx, ConstantOrRegister src,
MOZ_MUST_USE bool convertConstantOrRegisterToFloat(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister output, Label* fail)
{
return convertConstantOrRegisterToFloatingPoint(cx, src, output, fail, MIRType::Float32);
@ -1932,7 +1934,8 @@ class MacroAssembler : public MacroAssemblerSpecific
}
MOZ_MUST_USE bool convertValueToInt(JSContext* cx, const Value& v, Register output, Label* fail,
IntConversionBehavior behavior);
MOZ_MUST_USE bool convertConstantOrRegisterToInt(JSContext* cx, ConstantOrRegister src,
MOZ_MUST_USE bool convertConstantOrRegisterToInt(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister temp, Register output,
Label* fail, IntConversionBehavior behavior);
void convertTypedOrValueToInt(TypedOrValueRegister src, FloatRegister temp, Register output,
@ -1965,7 +1968,8 @@ class MacroAssembler : public MacroAssemblerSpecific
? IntConversion_NegativeZeroCheck
: IntConversion_Normal);
}
MOZ_MUST_USE bool convertConstantOrRegisterToInt32(JSContext* cx, ConstantOrRegister src,
MOZ_MUST_USE bool convertConstantOrRegisterToInt32(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister temp, Register output,
Label* fail, bool negativeZeroCheck)
{
@ -2005,7 +2009,8 @@ class MacroAssembler : public MacroAssemblerSpecific
Label* fail) {
return convertValueToInt(cx, v, output, fail, IntConversion_Truncate);
}
MOZ_MUST_USE bool truncateConstantOrRegisterToInt32(JSContext* cx, ConstantOrRegister src,
MOZ_MUST_USE bool truncateConstantOrRegisterToInt32(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister temp, Register output,
Label* fail)
{
@ -2038,7 +2043,8 @@ class MacroAssembler : public MacroAssemblerSpecific
Label* fail) {
return convertValueToInt(cx, v, output, fail, IntConversion_ClampToUint8);
}
MOZ_MUST_USE bool clampConstantOrRegisterToUint8(JSContext* cx, ConstantOrRegister src,
MOZ_MUST_USE bool clampConstantOrRegisterToUint8(JSContext* cx,
const ConstantOrRegister& src,
FloatRegister temp, Register output,
Label* fail)
{

24
js/src/jit/RegisterSets.h
View File

@ -230,41 +230,49 @@ class ConstantOrRegister
TypedOrValueRegister reg;
} data;
Value& dataValue() {
const Value& dataValue() const {
MOZ_ASSERT(constant());
return data.constant;
}
TypedOrValueRegister& dataReg() {
void setDataValue(const Value& value) {
MOZ_ASSERT(constant());
data.constant = value;
}
const TypedOrValueRegister& dataReg() const {
MOZ_ASSERT(!constant());
return data.reg;
}
void setDataReg(const TypedOrValueRegister& reg) {
MOZ_ASSERT(!constant());
data.reg = reg;
}
public:
ConstantOrRegister()
{}
MOZ_IMPLICIT ConstantOrRegister(Value value)
MOZ_IMPLICIT ConstantOrRegister(const Value& value)
: constant_(true)
{
dataValue() = value;
setDataValue(value);
}
MOZ_IMPLICIT ConstantOrRegister(TypedOrValueRegister reg)
: constant_(false)
{
dataReg() = reg;
setDataReg(reg);
}
bool constant() {
bool constant() const {
return constant_;
}
Value value() {
const Value& value() const {
return dataValue();
}
TypedOrValueRegister reg() {
const TypedOrValueRegister& reg() const {
return dataReg();
}
};

8
js/src/jit/arm/MacroAssembler-arm.cpp
View File

@ -5208,8 +5208,8 @@ MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs,
// Memory access primitives.
template <typename T>
void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
MIRType slotType)
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const T& dest, MIRType slotType)
{
if (valueType == MIRType::Double) {
storeDouble(value.reg().typedReg().fpu(), dest);
@ -5228,10 +5228,10 @@ MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, c
}
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType,
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const Address& dest, MIRType slotType);
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType,
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const BaseIndex& dest, MIRType slotType);
//}}} check_macroassembler_style

8
js/src/jit/arm64/MacroAssembler-arm64.cpp
View File

@ -789,8 +789,8 @@ MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs,
// Memory access primitives.
template <typename T>
void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
MIRType slotType)
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const T& dest, MIRType slotType)
{
if (valueType == MIRType::Double) {
storeDouble(value.reg().typedReg().fpu(), dest);
@ -820,10 +820,10 @@ MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, c
}
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType,
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const Address& dest, MIRType slotType);
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType,
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const BaseIndex& dest, MIRType slotType);
void

12
js/src/jit/mips32/MacroAssembler-mips32.cpp
View File

@ -2218,8 +2218,8 @@ MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs,
// Memory access primitives.
template <typename T>
void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
MIRType slotType)
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const T& dest, MIRType slotType)
{
if (valueType == MIRType::Double) {
storeDouble(value.reg().typedReg().fpu(), dest);
@ -2238,10 +2238,10 @@ MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, c
}
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const Address& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const Address& dest, MIRType slotType);
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const BaseIndex& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const BaseIndex& dest, MIRType slotType);
//}}} check_macroassembler_style

12
js/src/jit/mips64/MacroAssembler-mips64.cpp
View File

@ -2320,8 +2320,8 @@ MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs,
// Memory access primitives.
template <typename T>
void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
MIRType slotType)
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const T& dest, MIRType slotType)
{
if (valueType == MIRType::Double) {
storeDouble(value.reg().typedReg().fpu(), dest);
@ -2350,10 +2350,10 @@ MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, c
}
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const Address& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const Address& dest, MIRType slotType);
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const BaseIndex& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const BaseIndex& dest, MIRType slotType);
//}}} check_macroassembler_style

2
js/src/jit/none/MacroAssembler-none.h
View File

@ -396,7 +396,7 @@ class MacroAssemblerNone : public Assembler
Condition testStringTruthy(bool, ValueOperand) { MOZ_CRASH(); }
template <typename T> void loadUnboxedValue(T, MIRType, AnyRegister) { MOZ_CRASH(); }
template <typename T> void storeUnboxedValue(ConstantOrRegister, MIRType, T, MIRType) { MOZ_CRASH(); }
template <typename T> void storeUnboxedValue(const ConstantOrRegister&, MIRType, T, MIRType) { MOZ_CRASH(); }
template <typename T> void storeUnboxedPayload(ValueOperand value, T, size_t) { MOZ_CRASH(); }
void convertUInt32ToDouble(Register, FloatRegister) { MOZ_CRASH(); }

12
js/src/jit/x64/MacroAssembler-x64.cpp
View File

@ -621,8 +621,8 @@ MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs,
// Memory access primitives.
template <typename T>
void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
MIRType slotType)
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const T& dest, MIRType slotType)
{
if (valueType == MIRType::Double) {
storeDouble(value.reg().typedReg().fpu(), dest);
@ -651,11 +651,11 @@ MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, c
}
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const Address& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const Address& dest, MIRType slotType);
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const BaseIndex& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const BaseIndex& dest, MIRType slotType);
// ========================================================================
// wasm support

12
js/src/jit/x86/MacroAssembler-x86.cpp
View File

@ -529,8 +529,8 @@ MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs,
// Memory access primitives.
template <typename T>
void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const T& dest,
MIRType slotType)
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const T& dest, MIRType slotType)
{
if (valueType == MIRType::Double) {
storeDouble(value.reg().typedReg().fpu(), dest);
@ -549,11 +549,11 @@ MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, c
}
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const Address& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const Address& dest, MIRType slotType);
template void
MacroAssembler::storeUnboxedValue(ConstantOrRegister value, MIRType valueType, const BaseIndex& dest,
MIRType slotType);
MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, MIRType valueType,
const BaseIndex& dest, MIRType slotType);
// wasm specific methods, used in both the wasm baseline compiler and ion.