wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 950703 - SpiderMonkey: Rename MoveOp::Kind to MoveOp::Type. r=jandem

Browse Source
This commit is contained in:
Dan Gohman 2013-12-17 08:46:37 -08:00
parent b146091d37
commit d7eafde96c
14 changed files with 97 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1194,7 +1194,7 @@ CodeGenerator::visitMoveGroup(LMoveGroup *group)
JS_ASSERT(*from != *to);
JS_ASSERT(!from->isConstant());
MoveOp::Kind kind;
MoveOp::Type moveType;
switch (type) {
case LDefinition::OBJECT:
case LDefinition::SLOTS:
@ -1204,13 +1204,13 @@ CodeGenerator::visitMoveGroup(LMoveGroup *group)
#else
case LDefinition::BOX:
#endif
case LDefinition::GENERAL: kind = MoveOp::GENERAL; break;
case LDefinition::FLOAT32: kind = MoveOp::FLOAT32; break;
case LDefinition::DOUBLE: kind = MoveOp::DOUBLE; break;
case LDefinition::GENERAL: moveType = MoveOp::GENERAL; break;
case LDefinition::FLOAT32: moveType = MoveOp::FLOAT32; break;
case LDefinition::DOUBLE: moveType = MoveOp::DOUBLE; break;
default: MOZ_ASSUME_UNREACHABLE("Unexpected move type");
}
if (!resolver.addMove(toMoveOperand(from), toMoveOperand(to), kind))
if (!resolver.addMove(toMoveOperand(from), toMoveOperand(to), moveType))
return false;
}

4
js/src/jit/IonMacroAssembler.h
View File

@ -865,12 +865,12 @@ class MacroAssembler : public MacroAssemblerSpecific
// been made so that a safepoint can be made at that location.
template <typename T>
void callWithABINoProfiling(const T &fun, MoveOp::Kind result = MoveOp::GENERAL) {
void callWithABINoProfiling(const T &fun, MoveOp::Type result = MoveOp::GENERAL) {
MacroAssemblerSpecific::callWithABI(fun, result);
}
template <typename T>
void callWithABI(const T &fun, MoveOp::Kind result = MoveOp::GENERAL) {
void callWithABI(const T &fun, MoveOp::Type result = MoveOp::GENERAL) {
leaveSPSFrame();
callWithABINoProfiling(fun, result);
reenterSPSFrame();

4
js/src/jit/MoveResolver.cpp
View File

@ -21,14 +21,14 @@ MoveResolver::resetState()
}
bool
MoveResolver::addMove(const MoveOperand &from, const MoveOperand &to, MoveOp::Kind kind)
MoveResolver::addMove(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type)
{
// Assert that we're not doing no-op moves.
JS_ASSERT(!(from == to));
PendingMove *pm = movePool_.allocate();
if (!pm)
return false;
new (pm) PendingMove(from, to, kind);
new (pm) PendingMove(from, to, type);
pending_.pushBack(pm);
return true;
}

18
js/src/jit/MoveResolver.h
View File

@ -113,23 +113,23 @@ class MoveOp
bool cycle_;
public:
enum Kind {
enum Type {
GENERAL,
FLOAT32,
DOUBLE
};
protected:
Kind kind_;
Type type_;
public:
MoveOp()
{ }
MoveOp(const MoveOperand &from, const MoveOperand &to, Kind kind)
MoveOp(const MoveOperand &from, const MoveOperand &to, Type type)
: from_(from),
to_(to),
cycle_(false),
kind_(kind)
type_(type)
{ }
bool inCycle() const {
@ -141,8 +141,8 @@ class MoveOp
const MoveOperand &to() const {
return to_;
}
Kind kind() const {
return kind_;
Type type() const {
return type_;
}
};
@ -156,8 +156,8 @@ class MoveResolver
{
PendingMove()
{ }
PendingMove(const MoveOperand &from, const MoveOperand &to, Kind kind)
: MoveOp(from, to, kind)
PendingMove(const MoveOperand &from, const MoveOperand &to, Type type)
: MoveOp(from, to, type)
{ }
void setInCycle() {
@ -193,7 +193,7 @@ class MoveResolver
//
// After calling addMove() for each parallel move, resolve() performs the
// cycle resolution algorithm. Calling addMove() again resets the resolver.
bool addMove(const MoveOperand &from, const MoveOperand &to, MoveOp::Kind kind);
bool addMove(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type);
bool resolve();
size_t numMoves() const {

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

@ -3508,13 +3508,13 @@ MacroAssemblerARMCompat::setupUnalignedABICall(uint32_t args, const Register &sc
}
#ifdef JS_CPU_ARM_HARDFP
void
MacroAssemblerARMCompat::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
MacroAssemblerARMCompat::passABIArg(const MoveOperand &from, MoveOp::Type type)
{
MoveOperand to;
++passedArgs_;
if (!enoughMemory_)
return;
switch (kind) {
switch (type) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE: {
FloatRegister fr;
@ -3549,21 +3549,21 @@ MacroAssemblerARMCompat::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
break;
}
default:
MOZ_ASSUME_UNREACHABLE("Unexpected argument kind");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
enoughMemory_ = moveResolver_.addMove(from, to, kind);
enoughMemory_ = moveResolver_.addMove(from, to, type);
}
#else
void
MacroAssemblerARMCompat::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
MacroAssemblerARMCompat::passABIArg(const MoveOperand &from, MoveOp::Type type)
{
MoveOperand to;
uint32_t increment = 1;
bool useResolver = true;
++passedArgs_;
switch (kind) {
switch (type) {
case MoveOp::DOUBLE:
// Double arguments need to be rounded up to the nearest doubleword
// boundary, even if it is in a register!
@ -3574,13 +3574,13 @@ MacroAssemblerARMCompat::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
case MoveOp::GENERAL:
break;
default:
MOZ_ASSUME_UNREACHABLE("Unexpected argument kind");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
Register destReg;
MoveOperand dest;
if (GetIntArgReg(usedSlots_, 0, &destReg)) {
if (kind == MoveOp::DOUBLE || kind == MoveOp::FLOAT32) {
if (type == MoveOp::DOUBLE || type == MoveOp::FLOAT32) {
floatArgsInGPR[destReg.code() >> 1] = from;
floatArgsInGPRValid[destReg.code() >> 1] = true;
useResolver = false;
@ -3596,7 +3596,7 @@ MacroAssemblerARMCompat::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
}
if (useResolver)
enoughMemory_ = enoughMemory_ && moveResolver_.addMove(from, dest, kind);
enoughMemory_ = enoughMemory_ && moveResolver_.addMove(from, dest, type);
usedSlots_ += increment;
}
#endif
@ -3608,9 +3608,9 @@ MacroAssemblerARMCompat::passABIArg(const Register &reg)
}
void
MacroAssemblerARMCompat::passABIArg(const FloatRegister &freg, MoveOp::Kind kind)
MacroAssemblerARMCompat::passABIArg(const FloatRegister &freg, MoveOp::Type type)
{
passABIArg(MoveOperand(freg), kind);
passABIArg(MoveOperand(freg), type);
}
void MacroAssemblerARMCompat::checkStackAlignment()
@ -3680,7 +3680,7 @@ MacroAssemblerARMCompat::callWithABIPre(uint32_t *stackAdjust)
}
void
MacroAssemblerARMCompat::callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result)
MacroAssemblerARMCompat::callWithABIPost(uint32_t stackAdjust, MoveOp::Type result)
{
if (secondScratchReg_ != lr)
ma_mov(secondScratchReg_, lr);
@ -3718,7 +3718,7 @@ MacroAssemblerARMCompat::callWithABIPost(uint32_t stackAdjust, MoveOp::Kind resu
}
void
MacroAssemblerARMCompat::callWithABI(void *fun, MoveOp::Kind result)
MacroAssemblerARMCompat::callWithABI(void *fun, MoveOp::Type result)
{
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
@ -3727,7 +3727,7 @@ MacroAssemblerARMCompat::callWithABI(void *fun, MoveOp::Kind result)
}
void
MacroAssemblerARMCompat::callWithABI(AsmJSImmPtr imm, MoveOp::Kind result)
MacroAssemblerARMCompat::callWithABI(AsmJSImmPtr imm, MoveOp::Type result)
{
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
@ -3736,7 +3736,7 @@ MacroAssemblerARMCompat::callWithABI(AsmJSImmPtr imm, MoveOp::Kind result)
}
void
MacroAssemblerARMCompat::callWithABI(const Address &fun, MoveOp::Kind result)
MacroAssemblerARMCompat::callWithABI(const Address &fun, MoveOp::Type result)
{
// Load the callee in r12, no instruction between the ldr and call
// should clobber it. Note that we can't use fun.base because it may

12
js/src/jit/arm/MacroAssembler-arm.h
View File

@ -1403,9 +1403,9 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
// automatically adjusted. It is extremely important that esp-relative
// addresses are computed *after* setupABICall(). Furthermore, no
// operations should be emitted while setting arguments.
void passABIArg(const MoveOperand &from, MoveOp::Kind kind);
void passABIArg(const MoveOperand &from, MoveOp::Type type);
void passABIArg(const Register &reg);
void passABIArg(const FloatRegister &reg, MoveOp::Kind kind);
void passABIArg(const FloatRegister &reg, MoveOp::Type type);
void passABIArg(const ValueOperand &regs);
protected:
@ -1413,13 +1413,13 @@ class MacroAssemblerARMCompat : public MacroAssemblerARM
private:
void callWithABIPre(uint32_t *stackAdjust);
void callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result);
void callWithABIPost(uint32_t stackAdjust, MoveOp::Type result);
public:
// Emits a call to a C/C++ function, resolving all argument moves.
void callWithABI(void *fun, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(AsmJSImmPtr imm, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(const Address &fun, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(void *fun, MoveOp::Type result = MoveOp::GENERAL);
void callWithABI(AsmJSImmPtr imm, MoveOp::Type result = MoveOp::GENERAL);
void callWithABI(const Address &fun, MoveOp::Type result = MoveOp::GENERAL);
CodeOffsetLabel labelForPatch() {
return CodeOffsetLabel(nextOffset().getOffset());

20
js/src/jit/arm/MoveEmitter-arm.cpp
View File

@ -100,7 +100,7 @@ MoveEmitterARM::tempReg()
}
void
MoveEmitterARM::breakCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Kind kind)
MoveEmitterARM::breakCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type)
{
// There is some pattern:
// (A -> B)
@ -108,7 +108,7 @@ MoveEmitterARM::breakCycle(const MoveOperand &from, const MoveOperand &to, MoveO
//
// This case handles (A -> B), which we reach first. We save B, then allow
// the original move to continue.
switch (kind) {
switch (type) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE:
if (to.isMemory()) {
@ -135,12 +135,12 @@ MoveEmitterARM::breakCycle(const MoveOperand &from, const MoveOperand &to, MoveO
}
break;
default:
MOZ_ASSUME_UNREACHABLE("Unexpected move kind");
MOZ_ASSUME_UNREACHABLE("Unexpected move type");
}
}
void
MoveEmitterARM::completeCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Kind kind)
MoveEmitterARM::completeCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type)
{
// There is some pattern:
// (A -> B)
@ -148,7 +148,7 @@ MoveEmitterARM::completeCycle(const MoveOperand &from, const MoveOperand &to, Mo
//
// This case handles (B -> A), which we reach last. We emit a move from the
// saved value of B, to A.
switch (kind) {
switch (type) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE:
if (to.isMemory()) {
@ -173,7 +173,7 @@ MoveEmitterARM::completeCycle(const MoveOperand &from, const MoveOperand &to, Mo
}
break;
default:
MOZ_ASSUME_UNREACHABLE("Unexpected move kind");
MOZ_ASSUME_UNREACHABLE("Unexpected move type");
}
}
@ -251,16 +251,16 @@ MoveEmitterARM::emit(const MoveOp &move)
if (move.inCycle()) {
if (inCycle_) {
completeCycle(from, to, move.kind());
completeCycle(from, to, move.type());
inCycle_ = false;
return;
}
breakCycle(from, to, move.kind());
breakCycle(from, to, move.type());
inCycle_ = true;
}
switch (move.kind()) {
switch (move.type()) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE:
emitDoubleMove(from, to);
@ -269,7 +269,7 @@ MoveEmitterARM::emit(const MoveOp &move)
emitMove(from, to);
break;
default:
MOZ_ASSUME_UNREACHABLE("Unexpected move kind");
MOZ_ASSUME_UNREACHABLE("Unexpected move type");
}
}

4
js/src/jit/arm/MoveEmitter-arm.h
View File

@ -46,8 +46,8 @@ class MoveEmitterARM
void emitMove(const MoveOperand &from, const MoveOperand &to);
void emitDoubleMove(const MoveOperand &from, const MoveOperand &to);
void breakCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Kind kind);
void completeCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Kind kind);
void breakCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type);
void completeCycle(const MoveOperand &from, const MoveOperand &to, MoveOp::Type type);
void emit(const MoveOp &move);
public:

20
js/src/jit/shared/MoveEmitter-x86-shared.cpp
View File

@ -107,7 +107,7 @@ MoveEmitterX86::emit(const MoveResolver &moves)
// If this is the end of a cycle for which we're using the stack,
// handle the end.
if (inCycle_) {
completeCycle(to, move.kind());
completeCycle(to, move.type());
inCycle_ = false;
continue;
}
@ -123,12 +123,12 @@ MoveEmitterX86::emit(const MoveResolver &moves)
}
// Otherwise use the stack.
breakCycle(to, move.kind());
breakCycle(to, move.type());
inCycle_ = true;
}
// A normal move which is not part of a cycle.
switch (move.kind()) {
switch (move.type()) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE:
emitDoubleMove(from, to);
@ -137,7 +137,7 @@ MoveEmitterX86::emit(const MoveResolver &moves)
emitGeneralMove(from, to);
break;
default:
MOZ_ASSUME_UNREACHABLE("Unexpected move kind");
MOZ_ASSUME_UNREACHABLE("Unexpected move type");
}
}
}
@ -211,7 +211,7 @@ MoveEmitterX86::toPopOperand(const MoveOperand &operand) const
}
void
MoveEmitterX86::breakCycle(const MoveOperand &to, MoveOp::Kind kind)
MoveEmitterX86::breakCycle(const MoveOperand &to, MoveOp::Type type)
{
// There is some pattern:
// (A -> B)
@ -219,7 +219,7 @@ MoveEmitterX86::breakCycle(const MoveOperand &to, MoveOp::Kind kind)
//
// This case handles (A -> B), which we reach first. We save B, then allow
// the original move to continue.
switch (kind) {
switch (type) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE:
if (to.isMemory()) {
@ -233,12 +233,12 @@ MoveEmitterX86::breakCycle(const MoveOperand &to, MoveOp::Kind kind)
masm.Push(toOperand(to));
break;
default:
MOZ_ASSUME_UNREACHABLE("Unexpected move kind");
MOZ_ASSUME_UNREACHABLE("Unexpected move type");
}
}
void
MoveEmitterX86::completeCycle(const MoveOperand &to, MoveOp::Kind kind)
MoveEmitterX86::completeCycle(const MoveOperand &to, MoveOp::Type type)
{
// There is some pattern:
// (A -> B)
@ -246,7 +246,7 @@ MoveEmitterX86::completeCycle(const MoveOperand &to, MoveOp::Kind kind)
//
// This case handles (B -> A), which we reach last. We emit a move from the
// saved value of B, to A.
switch (kind) {
switch (type) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE:
if (to.isMemory()) {
@ -264,7 +264,7 @@ MoveEmitterX86::completeCycle(const MoveOperand &to, MoveOp::Kind kind)
}
break;
default:
MOZ_ASSUME_UNREACHABLE("Unexpected move kind");
MOZ_ASSUME_UNREACHABLE("Unexpected move type");
}
}

4
js/src/jit/shared/MoveEmitter-x86-shared.h
View File

@ -45,8 +45,8 @@ class MoveEmitterX86
bool allGeneralRegs, bool allFloatRegs, size_t swapCount);
void emitGeneralMove(const MoveOperand &from, const MoveOperand &to);
void emitDoubleMove(const MoveOperand &from, const MoveOperand &to);
void breakCycle(const MoveOperand &to, MoveOp::Kind kind);
void completeCycle(const MoveOperand &to, MoveOp::Kind kind);
void breakCycle(const MoveOperand &to, MoveOp::Type type);
void completeCycle(const MoveOperand &to, MoveOp::Type type);
public:
MoveEmitterX86(MacroAssemblerSpecific &masm);

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

@ -134,10 +134,10 @@ MacroAssemblerX64::setupUnalignedABICall(uint32_t args, const Register &scratch)
}
void
MacroAssemblerX64::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
MacroAssemblerX64::passABIArg(const MoveOperand &from, MoveOp::Type type)
{
MoveOperand to;
switch (kind) {
switch (type) {
case MoveOp::FLOAT32:
case MoveOp::DOUBLE: {
FloatRegister dest;
@ -149,10 +149,10 @@ MacroAssemblerX64::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
to = MoveOperand(dest);
} else {
to = MoveOperand(StackPointer, stackForCall_);
switch (kind) {
switch (type) {
case MoveOp::FLOAT32: stackForCall_ += sizeof(float); break;
case MoveOp::DOUBLE: stackForCall_ += sizeof(double); break;
default: MOZ_ASSUME_UNREACHABLE("Unexpected float register class argument kind");
default: MOZ_ASSUME_UNREACHABLE("Unexpected float register class argument type");
}
}
break;
@ -172,10 +172,10 @@ MacroAssemblerX64::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
break;
}
default:
MOZ_ASSUME_UNREACHABLE("Unexpected argument kind");
MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
enoughMemory_ = moveResolver_.addMove(from, to, kind);
enoughMemory_ = moveResolver_.addMove(from, to, type);
}
void
@ -185,9 +185,9 @@ MacroAssemblerX64::passABIArg(const Register &reg)
}
void
MacroAssemblerX64::passABIArg(const FloatRegister &reg, MoveOp::Kind kind)
MacroAssemblerX64::passABIArg(const FloatRegister &reg, MoveOp::Type type)
{
passABIArg(MoveOperand(reg), kind);
passABIArg(MoveOperand(reg), type);
}
void
@ -231,7 +231,7 @@ MacroAssemblerX64::callWithABIPre(uint32_t *stackAdjust)
}
void
MacroAssemblerX64::callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result)
MacroAssemblerX64::callWithABIPost(uint32_t stackAdjust, MoveOp::Type result)
{
freeStack(stackAdjust);
if (dynamicAlignment_)
@ -242,7 +242,7 @@ MacroAssemblerX64::callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result)
}
void
MacroAssemblerX64::callWithABI(void *fun, MoveOp::Kind result)
MacroAssemblerX64::callWithABI(void *fun, MoveOp::Type result)
{
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
@ -251,7 +251,7 @@ MacroAssemblerX64::callWithABI(void *fun, MoveOp::Kind result)
}
void
MacroAssemblerX64::callWithABI(AsmJSImmPtr imm, MoveOp::Kind result)
MacroAssemblerX64::callWithABI(AsmJSImmPtr imm, MoveOp::Type result)
{
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
@ -271,7 +271,7 @@ IsIntArgReg(Register reg)
}
void
MacroAssemblerX64::callWithABI(Address fun, MoveOp::Kind result)
MacroAssemblerX64::callWithABI(Address fun, MoveOp::Type result)
{
if (IsIntArgReg(fun.base)) {
// Callee register may be clobbered for an argument. Move the callee to

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

@ -1193,19 +1193,19 @@ class MacroAssemblerX64 : public MacroAssemblerX86Shared
// automatically adjusted. It is extremely important that esp-relative
// addresses are computed *after* setupABICall(). Furthermore, no
// operations should be emitted while setting arguments.
void passABIArg(const MoveOperand &from, MoveOp::Kind kind);
void passABIArg(const MoveOperand &from, MoveOp::Type type);
void passABIArg(const Register &reg);
void passABIArg(const FloatRegister &reg, MoveOp::Kind kind);
void passABIArg(const FloatRegister &reg, MoveOp::Type type);
private:
void callWithABIPre(uint32_t *stackAdjust);
void callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result);
void callWithABIPost(uint32_t stackAdjust, MoveOp::Type result);
public:
// Emits a call to a C/C++ function, resolving all argument moves.
void callWithABI(void *fun, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(AsmJSImmPtr imm, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(Address fun, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(void *fun, MoveOp::Type result = MoveOp::GENERAL);
void callWithABI(AsmJSImmPtr imm, MoveOp::Type result = MoveOp::GENERAL);
void callWithABI(Address fun, MoveOp::Type result = MoveOp::GENERAL);
void handleFailureWithHandler(void *handler);
void handleFailureWithHandlerTail();

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

@ -163,17 +163,17 @@ MacroAssemblerX86::setupUnalignedABICall(uint32_t args, const Register &scratch)
}
void
MacroAssemblerX86::passABIArg(const MoveOperand &from, MoveOp::Kind kind)
MacroAssemblerX86::passABIArg(const MoveOperand &from, MoveOp::Type type)
{
++passedArgs_;
MoveOperand to = MoveOperand(StackPointer, stackForCall_);
switch (kind) {
switch (type) {
case MoveOp::FLOAT32: stackForCall_ += sizeof(float); break;
case MoveOp::DOUBLE: stackForCall_ += sizeof(double); break;
case MoveOp::GENERAL: stackForCall_ += sizeof(int32_t); break;
default: MOZ_ASSUME_UNREACHABLE("Unexpected argument kind");
default: MOZ_ASSUME_UNREACHABLE("Unexpected argument type");
}
enoughMemory_ &= moveResolver_.addMove(from, to, kind);
enoughMemory_ &= moveResolver_.addMove(from, to, type);
}
void
@ -183,9 +183,9 @@ MacroAssemblerX86::passABIArg(const Register &reg)
}
void
MacroAssemblerX86::passABIArg(const FloatRegister &reg, MoveOp::Kind kind)
MacroAssemblerX86::passABIArg(const FloatRegister &reg, MoveOp::Type type)
{
passABIArg(MoveOperand(reg), kind);
passABIArg(MoveOperand(reg), type);
}
void
@ -230,7 +230,7 @@ MacroAssemblerX86::callWithABIPre(uint32_t *stackAdjust)
}
void
MacroAssemblerX86::callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result)
MacroAssemblerX86::callWithABIPost(uint32_t stackAdjust, MoveOp::Type result)
{
freeStack(stackAdjust);
if (result == MoveOp::DOUBLE) {
@ -252,7 +252,7 @@ MacroAssemblerX86::callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result)
}
void
MacroAssemblerX86::callWithABI(void *fun, MoveOp::Kind result)
MacroAssemblerX86::callWithABI(void *fun, MoveOp::Type result)
{
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
@ -261,7 +261,7 @@ MacroAssemblerX86::callWithABI(void *fun, MoveOp::Kind result)
}
void
MacroAssemblerX86::callWithABI(AsmJSImmPtr fun, MoveOp::Kind result)
MacroAssemblerX86::callWithABI(AsmJSImmPtr fun, MoveOp::Type result)
{
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);
@ -270,7 +270,7 @@ MacroAssemblerX86::callWithABI(AsmJSImmPtr fun, MoveOp::Kind result)
}
void
MacroAssemblerX86::callWithABI(const Address &fun, MoveOp::Kind result)
MacroAssemblerX86::callWithABI(const Address &fun, MoveOp::Type result)
{
uint32_t stackAdjust;
callWithABIPre(&stackAdjust);

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

@ -1037,19 +1037,19 @@ class MacroAssemblerX86 : public MacroAssemblerX86Shared
// automatically adjusted. It is extremely important that esp-relative
// addresses are computed *after* setupABICall(). Furthermore, no
// operations should be emitted while setting arguments.
void passABIArg(const MoveOperand &from, MoveOp::Kind kind);
void passABIArg(const MoveOperand &from, MoveOp::Type type);
void passABIArg(const Register &reg);
void passABIArg(const FloatRegister &reg, MoveOp::Kind kind);
void passABIArg(const FloatRegister &reg, MoveOp::Type type);
private:
void callWithABIPre(uint32_t *stackAdjust);
void callWithABIPost(uint32_t stackAdjust, MoveOp::Kind result);
void callWithABIPost(uint32_t stackAdjust, MoveOp::Type result);
public:
// Emits a call to a C/C++ function, resolving all argument moves.
void callWithABI(void *fun, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(AsmJSImmPtr fun, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(const Address &fun, MoveOp::Kind result = MoveOp::GENERAL);
void callWithABI(void *fun, MoveOp::Type result = MoveOp::GENERAL);
void callWithABI(AsmJSImmPtr fun, MoveOp::Type result = MoveOp::GENERAL);
void callWithABI(const Address &fun, MoveOp::Type result = MoveOp::GENERAL);
// Used from within an Exit frame to handle a pending exception.
void handleFailureWithHandler(void *handler);