mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-02 07:05:24 +00:00
1330 lines
52 KiB
C++
1330 lines
52 KiB
C++
// THIS FILE IS MACHINE GENERATED! DO NOT EDIT BY HAND!
|
|
|
|
#if !defined(OPCODE_NAMES)
|
|
|
|
enum {
|
|
ADD, /* dest, source1, source2 */
|
|
AND, /* dest, source1, source2 */
|
|
BIND_THIS, /* result, this, target */
|
|
BITNOT, /* dest, source */
|
|
BRANCH, /* target label */
|
|
BRANCH_FALSE, /* target label, condition */
|
|
BRANCH_INITIALIZED, /* target label, condition */
|
|
BRANCH_TRUE, /* target label, condition */
|
|
CALL, /* result, target, args */
|
|
CAST, /* dest, rvalue, toType */
|
|
CLASS, /* dest, obj */
|
|
COMPARE_EQ, /* dest, source1, source2 */
|
|
COMPARE_GE, /* dest, source1, source2 */
|
|
COMPARE_GT, /* dest, source1, source2 */
|
|
COMPARE_IN, /* dest, source1, source2 */
|
|
COMPARE_LE, /* dest, source1, source2 */
|
|
COMPARE_LT, /* dest, source1, source2 */
|
|
COMPARE_NE, /* dest, source1, source2 */
|
|
DEBUGGER, /* drop to the debugger */
|
|
DELETE_PROP, /* dest, object, prop name */
|
|
DIRECT_CALL, /* result, target, args */
|
|
DIVIDE, /* dest, source1, source2 */
|
|
ELEM_XCR, /* dest, base, index, value */
|
|
GENERIC_BINARY_OP, /* dest, op, source1, source2 */
|
|
GET_CLOSURE, /* dest, closure depth */
|
|
GET_ELEMENT, /* dest, base, index */
|
|
GET_METHOD, /* result, target base, index */
|
|
GET_PROP, /* dest, object, prop name */
|
|
GET_SLOT, /* dest, object, slot number */
|
|
GET_STATIC, /* dest, class, index */
|
|
INSTANCEOF, /* dest, source1, source2 */
|
|
JSR, /* target */
|
|
LOAD_FALSE, /* dest */
|
|
LOAD_IMMEDIATE, /* dest, immediate value (double) */
|
|
LOAD_NAME, /* dest, name */
|
|
LOAD_NULL, /* dest */
|
|
LOAD_STRING, /* dest, immediate value (string) */
|
|
LOAD_TRUE, /* dest */
|
|
LOAD_TYPE, /* dest, type */
|
|
MOVE, /* dest, source */
|
|
MULTIPLY, /* dest, source1, source2 */
|
|
NAME_XCR, /* dest, name, value */
|
|
NEGATE, /* dest, source */
|
|
NEW_ARRAY, /* dest */
|
|
NEW_CLASS, /* dest, class */
|
|
NEW_CLOSURE, /* dest, ICodeModule */
|
|
NEW_FUNCTION, /* dest, ICodeModule */
|
|
NEW_OBJECT, /* dest, constructor */
|
|
NOP, /* do nothing and like it */
|
|
NOT, /* dest, source */
|
|
OR, /* dest, source1, source2 */
|
|
POSATE, /* dest, source */
|
|
PROP_XCR, /* dest, source, name, value */
|
|
REMAINDER, /* dest, source1, source2 */
|
|
RETURN, /* return value */
|
|
RETURN_VOID, /* Return without a value */
|
|
RTS, /* Return to sender */
|
|
SAVE_NAME, /* name, source */
|
|
SET_ELEMENT, /* base, index, value */
|
|
SET_PROP, /* object, name, source */
|
|
SET_SLOT, /* object, slot number, source */
|
|
SET_STATIC, /* class, index, source */
|
|
SHIFTLEFT, /* dest, source1, source2 */
|
|
SHIFTRIGHT, /* dest, source1, source2 */
|
|
SLOT_XCR, /* dest, source, slot number, value */
|
|
STATIC_XCR, /* dest, class, index, value */
|
|
STRICT_EQ, /* dest, source1, source2 */
|
|
STRICT_NE, /* dest, source1, source2 */
|
|
SUBTRACT, /* dest, source1, source2 */
|
|
SUPER, /* dest */
|
|
TEST, /* dest, source */
|
|
THROW, /* exception value */
|
|
TRYIN, /* catch target, finally target */
|
|
TRYOUT, /* mmm, there is no try, only do */
|
|
USHIFTRIGHT, /* dest, source1, source2 */
|
|
VAR_XCR, /* dest, source, value */
|
|
WITHIN, /* within this object */
|
|
WITHOUT, /* without this object */
|
|
XOR, /* dest, source1, source2 */
|
|
};
|
|
|
|
class Add : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Add (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(ADD, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class And : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
And (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(AND, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class BindThis : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* result, this, target */
|
|
BindThis (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(BIND_THIS, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[BIND_THIS] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Bitnot : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source */
|
|
Bitnot (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(BITNOT, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[BITNOT] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Branch : public GenericBranch {
|
|
public:
|
|
/* target label */
|
|
Branch (Label* aOp1) :
|
|
GenericBranch
|
|
(BRANCH, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[BRANCH] << "\t" << "Offset " << ((mOp1) ? mOp1->mOffset : NotAnOffset);
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class BranchFalse : public GenericBranch {
|
|
public:
|
|
/* target label, condition */
|
|
BranchFalse (Label* aOp1, TypedRegister aOp2) :
|
|
GenericBranch
|
|
(BRANCH_FALSE, aOp1, aOp2) {};
|
|
/* print() and printOperands() inherited from GenericBranch */
|
|
};
|
|
|
|
class BranchInitialized : public GenericBranch {
|
|
public:
|
|
/* target label, condition */
|
|
BranchInitialized (Label* aOp1, TypedRegister aOp2) :
|
|
GenericBranch
|
|
(BRANCH_INITIALIZED, aOp1, aOp2) {};
|
|
/* print() and printOperands() inherited from GenericBranch */
|
|
};
|
|
|
|
class BranchTrue : public GenericBranch {
|
|
public:
|
|
/* target label, condition */
|
|
BranchTrue (Label* aOp1, TypedRegister aOp2) :
|
|
GenericBranch
|
|
(BRANCH_TRUE, aOp1, aOp2) {};
|
|
/* print() and printOperands() inherited from GenericBranch */
|
|
};
|
|
|
|
class Call : public Instruction_3<TypedRegister, TypedRegister, ArgumentList*> {
|
|
public:
|
|
/* result, target, args */
|
|
Call (TypedRegister aOp1, TypedRegister aOp2, ArgumentList* aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, ArgumentList*>
|
|
(CALL, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[CALL] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Cast : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, rvalue, toType */
|
|
Cast (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(CAST, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[CAST] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Class : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, obj */
|
|
Class (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(CLASS, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[CLASS] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class CompareEQ : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
CompareEQ (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(COMPARE_EQ, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[COMPARE_EQ] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class CompareGE : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
CompareGE (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(COMPARE_GE, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[COMPARE_GE] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class CompareGT : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
CompareGT (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(COMPARE_GT, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[COMPARE_GT] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class CompareIN : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
CompareIN (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(COMPARE_IN, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[COMPARE_IN] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class CompareLE : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
CompareLE (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(COMPARE_LE, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[COMPARE_LE] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class CompareLT : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
CompareLT (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(COMPARE_LT, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[COMPARE_LT] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class CompareNE : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
CompareNE (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(COMPARE_NE, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[COMPARE_NE] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Debugger : public Instruction {
|
|
public:
|
|
/* drop to the debugger */
|
|
Debugger () :
|
|
Instruction
|
|
(DEBUGGER) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[DEBUGGER];
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class DeleteProp : public Instruction_3<TypedRegister, TypedRegister, const StringAtom*> {
|
|
public:
|
|
/* dest, object, prop name */
|
|
DeleteProp (TypedRegister aOp1, TypedRegister aOp2, const StringAtom* aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, const StringAtom*>
|
|
(DELETE_PROP, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[DELETE_PROP] << "\t" << mOp1 << ", " << mOp2 << ", " << "'" << *mOp3 << "'";
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class DirectCall : public Instruction_3<TypedRegister, JSFunction*, ArgumentList*> {
|
|
public:
|
|
/* result, target, args */
|
|
DirectCall (TypedRegister aOp1, JSFunction* aOp2, ArgumentList* aOp3) :
|
|
Instruction_3<TypedRegister, JSFunction*, ArgumentList*>
|
|
(DIRECT_CALL, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[DIRECT_CALL] << "\t" << mOp1 << ", " << "JSFunction" << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Divide : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Divide (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(DIVIDE, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class ElemXcr : public Instruction_4<TypedRegister, TypedRegister, TypedRegister, double> {
|
|
public:
|
|
/* dest, base, index, value */
|
|
ElemXcr (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3, double aOp4) :
|
|
Instruction_4<TypedRegister, TypedRegister, TypedRegister, double>
|
|
(ELEM_XCR, aOp1, aOp2, aOp3, aOp4) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[ELEM_XCR] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3 << ", " << mOp4;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class GenericBinaryOP : public Instruction_4<TypedRegister, ExprNode::Kind, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, op, source1, source2 */
|
|
GenericBinaryOP (TypedRegister aOp1, ExprNode::Kind aOp2, TypedRegister aOp3, TypedRegister aOp4) :
|
|
Instruction_4<TypedRegister, ExprNode::Kind, TypedRegister, TypedRegister>
|
|
(GENERIC_BINARY_OP, aOp1, aOp2, aOp3, aOp4) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[GENERIC_BINARY_OP] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3 << ", " << mOp4;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp3.first) << ", " << getRegisterValue(registers, mOp4.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class GetClosure : public Instruction_2<TypedRegister, uint32> {
|
|
public:
|
|
/* dest, closure depth */
|
|
GetClosure (TypedRegister aOp1, uint32 aOp2) :
|
|
Instruction_2<TypedRegister, uint32>
|
|
(GET_CLOSURE, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[GET_CLOSURE] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class GetElement : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, base, index */
|
|
GetElement (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(GET_ELEMENT, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[GET_ELEMENT] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class GetMethod : public Instruction_3<TypedRegister, TypedRegister, uint32> {
|
|
public:
|
|
/* result, target base, index */
|
|
GetMethod (TypedRegister aOp1, TypedRegister aOp2, uint32 aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, uint32>
|
|
(GET_METHOD, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[GET_METHOD] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class GetProp : public Instruction_3<TypedRegister, TypedRegister, const StringAtom*> {
|
|
public:
|
|
/* dest, object, prop name */
|
|
GetProp (TypedRegister aOp1, TypedRegister aOp2, const StringAtom* aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, const StringAtom*>
|
|
(GET_PROP, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[GET_PROP] << "\t" << mOp1 << ", " << mOp2 << ", " << "'" << *mOp3 << "'";
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class GetSlot : public Instruction_3<TypedRegister, TypedRegister, uint32> {
|
|
public:
|
|
/* dest, object, slot number */
|
|
GetSlot (TypedRegister aOp1, TypedRegister aOp2, uint32 aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, uint32>
|
|
(GET_SLOT, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[GET_SLOT] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class GetStatic : public Instruction_3<TypedRegister, JSClass*, uint32> {
|
|
public:
|
|
/* dest, class, index */
|
|
GetStatic (TypedRegister aOp1, JSClass* aOp2, uint32 aOp3) :
|
|
Instruction_3<TypedRegister, JSClass*, uint32>
|
|
(GET_STATIC, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[GET_STATIC] << "\t" << mOp1 << ", " << mOp2->getName() << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Instanceof : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Instanceof (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(INSTANCEOF, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[INSTANCEOF] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Jsr : public GenericBranch {
|
|
public:
|
|
/* target */
|
|
Jsr (Label* aOp1) :
|
|
GenericBranch
|
|
(JSR, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[JSR] << "\t" << "Offset " << ((mOp1) ? mOp1->mOffset : NotAnOffset);
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class LoadFalse : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* dest */
|
|
LoadFalse (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(LOAD_FALSE, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[LOAD_FALSE] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class LoadImmediate : public Instruction_2<TypedRegister, double> {
|
|
public:
|
|
/* dest, immediate value (double) */
|
|
LoadImmediate (TypedRegister aOp1, double aOp2) :
|
|
Instruction_2<TypedRegister, double>
|
|
(LOAD_IMMEDIATE, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[LOAD_IMMEDIATE] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class LoadName : public Instruction_2<TypedRegister, const StringAtom*> {
|
|
public:
|
|
/* dest, name */
|
|
LoadName (TypedRegister aOp1, const StringAtom* aOp2) :
|
|
Instruction_2<TypedRegister, const StringAtom*>
|
|
(LOAD_NAME, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[LOAD_NAME] << "\t" << mOp1 << ", " << "'" << *mOp2 << "'";
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class LoadNull : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* dest */
|
|
LoadNull (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(LOAD_NULL, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[LOAD_NULL] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class LoadString : public Instruction_2<TypedRegister, JSString*> {
|
|
public:
|
|
/* dest, immediate value (string) */
|
|
LoadString (TypedRegister aOp1, JSString* aOp2) :
|
|
Instruction_2<TypedRegister, JSString*>
|
|
(LOAD_STRING, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[LOAD_STRING] << "\t" << mOp1 << ", " << "'" << *mOp2 << "'";
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class LoadTrue : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* dest */
|
|
LoadTrue (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(LOAD_TRUE, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[LOAD_TRUE] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class LoadType : public Instruction_2<TypedRegister, JSType*> {
|
|
public:
|
|
/* dest, type */
|
|
LoadType (TypedRegister aOp1, JSType* aOp2) :
|
|
Instruction_2<TypedRegister, JSType*>
|
|
(LOAD_TYPE, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[LOAD_TYPE] << "\t" << mOp1 << ", " << "'" << mOp2->getName() << "'";
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Move : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source */
|
|
Move (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(MOVE, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[MOVE] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Multiply : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Multiply (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(MULTIPLY, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class NameXcr : public Instruction_3<TypedRegister, const StringAtom*, double> {
|
|
public:
|
|
/* dest, name, value */
|
|
NameXcr (TypedRegister aOp1, const StringAtom* aOp2, double aOp3) :
|
|
Instruction_3<TypedRegister, const StringAtom*, double>
|
|
(NAME_XCR, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NAME_XCR] << "\t" << mOp1 << ", " << "'" << *mOp2 << "'" << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Negate : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source */
|
|
Negate (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(NEGATE, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NEGATE] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class NewArray : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* dest */
|
|
NewArray (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(NEW_ARRAY, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NEW_ARRAY] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class NewClass : public Instruction_2<TypedRegister, JSClass*> {
|
|
public:
|
|
/* dest, class */
|
|
NewClass (TypedRegister aOp1, JSClass* aOp2) :
|
|
Instruction_2<TypedRegister, JSClass*>
|
|
(NEW_CLASS, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NEW_CLASS] << "\t" << mOp1 << ", " << mOp2->getName();
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class NewClosure : public Instruction_2<TypedRegister, ICodeModule*> {
|
|
public:
|
|
/* dest, ICodeModule */
|
|
NewClosure (TypedRegister aOp1, ICodeModule* aOp2) :
|
|
Instruction_2<TypedRegister, ICodeModule*>
|
|
(NEW_CLOSURE, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NEW_CLOSURE] << "\t" << mOp1 << ", " << "ICodeModule";
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class NewFunction : public Instruction_2<TypedRegister, ICodeModule*> {
|
|
public:
|
|
/* dest, ICodeModule */
|
|
NewFunction (TypedRegister aOp1, ICodeModule* aOp2) :
|
|
Instruction_2<TypedRegister, ICodeModule*>
|
|
(NEW_FUNCTION, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NEW_FUNCTION] << "\t" << mOp1 << ", " << "ICodeModule";
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class NewObject : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, constructor */
|
|
NewObject (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(NEW_OBJECT, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NEW_OBJECT] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Nop : public Instruction {
|
|
public:
|
|
/* do nothing and like it */
|
|
Nop () :
|
|
Instruction
|
|
(NOP) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NOP];
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Not : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source */
|
|
Not (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(NOT, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[NOT] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Or : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Or (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(OR, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class Posate : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source */
|
|
Posate (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(POSATE, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[POSATE] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class PropXcr : public Instruction_4<TypedRegister, TypedRegister, const StringAtom*, double> {
|
|
public:
|
|
/* dest, source, name, value */
|
|
PropXcr (TypedRegister aOp1, TypedRegister aOp2, const StringAtom* aOp3, double aOp4) :
|
|
Instruction_4<TypedRegister, TypedRegister, const StringAtom*, double>
|
|
(PROP_XCR, aOp1, aOp2, aOp3, aOp4) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[PROP_XCR] << "\t" << mOp1 << ", " << mOp2 << ", " << "'" << *mOp3 << "'" << ", " << mOp4;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Remainder : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Remainder (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(REMAINDER, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class Return : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* return value */
|
|
Return (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(RETURN, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[RETURN] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class ReturnVoid : public Instruction {
|
|
public:
|
|
/* Return without a value */
|
|
ReturnVoid () :
|
|
Instruction
|
|
(RETURN_VOID) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[RETURN_VOID];
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Rts : public Instruction {
|
|
public:
|
|
/* Return to sender */
|
|
Rts () :
|
|
Instruction
|
|
(RTS) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[RTS];
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class SaveName : public Instruction_2<const StringAtom*, TypedRegister> {
|
|
public:
|
|
/* name, source */
|
|
SaveName (const StringAtom* aOp1, TypedRegister aOp2) :
|
|
Instruction_2<const StringAtom*, TypedRegister>
|
|
(SAVE_NAME, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[SAVE_NAME] << "\t" << "'" << *mOp1 << "'" << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class SetElement : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* base, index, value */
|
|
SetElement (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(SET_ELEMENT, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[SET_ELEMENT] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class SetProp : public Instruction_3<TypedRegister, const StringAtom*, TypedRegister> {
|
|
public:
|
|
/* object, name, source */
|
|
SetProp (TypedRegister aOp1, const StringAtom* aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, const StringAtom*, TypedRegister>
|
|
(SET_PROP, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[SET_PROP] << "\t" << mOp1 << ", " << "'" << *mOp2 << "'" << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class SetSlot : public Instruction_3<TypedRegister, uint32, TypedRegister> {
|
|
public:
|
|
/* object, slot number, source */
|
|
SetSlot (TypedRegister aOp1, uint32 aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, uint32, TypedRegister>
|
|
(SET_SLOT, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[SET_SLOT] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class SetStatic : public Instruction_3<JSClass*, uint32, TypedRegister> {
|
|
public:
|
|
/* class, index, source */
|
|
SetStatic (JSClass* aOp1, uint32 aOp2, TypedRegister aOp3) :
|
|
Instruction_3<JSClass*, uint32, TypedRegister>
|
|
(SET_STATIC, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[SET_STATIC] << "\t" << mOp1->getName() << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Shiftleft : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Shiftleft (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(SHIFTLEFT, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class Shiftright : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Shiftright (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(SHIFTRIGHT, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class SlotXcr : public Instruction_4<TypedRegister, TypedRegister, uint32, double> {
|
|
public:
|
|
/* dest, source, slot number, value */
|
|
SlotXcr (TypedRegister aOp1, TypedRegister aOp2, uint32 aOp3, double aOp4) :
|
|
Instruction_4<TypedRegister, TypedRegister, uint32, double>
|
|
(SLOT_XCR, aOp1, aOp2, aOp3, aOp4) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[SLOT_XCR] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3 << ", " << mOp4;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class StaticXcr : public Instruction_4<TypedRegister, JSClass*, uint32, double> {
|
|
public:
|
|
/* dest, class, index, value */
|
|
StaticXcr (TypedRegister aOp1, JSClass* aOp2, uint32 aOp3, double aOp4) :
|
|
Instruction_4<TypedRegister, JSClass*, uint32, double>
|
|
(STATIC_XCR, aOp1, aOp2, aOp3, aOp4) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[STATIC_XCR] << "\t" << mOp1 << ", " << mOp2->getName() << ", " << mOp3 << ", " << mOp4;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class StrictEQ : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
StrictEQ (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(STRICT_EQ, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[STRICT_EQ] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class StrictNE : public Instruction_3<TypedRegister, TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
StrictNE (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, TypedRegister>
|
|
(STRICT_NE, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[STRICT_NE] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first) << ", " << getRegisterValue(registers, mOp3.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Subtract : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Subtract (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(SUBTRACT, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class Super : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* dest */
|
|
Super (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(SUPER, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[SUPER] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Test : public Instruction_2<TypedRegister, TypedRegister> {
|
|
public:
|
|
/* dest, source */
|
|
Test (TypedRegister aOp1, TypedRegister aOp2) :
|
|
Instruction_2<TypedRegister, TypedRegister>
|
|
(TEST, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[TEST] << "\t" << mOp1 << ", " << mOp2;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Throw : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* exception value */
|
|
Throw (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(THROW, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[THROW] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Tryin : public Instruction_2<Label*, Label*> {
|
|
public:
|
|
/* catch target, finally target */
|
|
Tryin (Label* aOp1, Label* aOp2) :
|
|
Instruction_2<Label*, Label*>
|
|
(TRYIN, aOp1, aOp2) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[TRYIN] << "\t" << "Offset " << ((mOp1) ? mOp1->mOffset : NotAnOffset) << ", " << "Offset " << ((mOp2) ? mOp2->mOffset : NotAnOffset);
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Tryout : public Instruction {
|
|
public:
|
|
/* mmm, there is no try, only do */
|
|
Tryout () :
|
|
Instruction
|
|
(TRYOUT) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[TRYOUT];
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Ushiftright : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Ushiftright (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(USHIFTRIGHT, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
class VarXcr : public Instruction_3<TypedRegister, TypedRegister, double> {
|
|
public:
|
|
/* dest, source, value */
|
|
VarXcr (TypedRegister aOp1, TypedRegister aOp2, double aOp3) :
|
|
Instruction_3<TypedRegister, TypedRegister, double>
|
|
(VAR_XCR, aOp1, aOp2, aOp3) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[VAR_XCR] << "\t" << mOp1 << ", " << mOp2 << ", " << mOp3;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first) << ", " << getRegisterValue(registers, mOp2.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Within : public Instruction_1<TypedRegister> {
|
|
public:
|
|
/* within this object */
|
|
Within (TypedRegister aOp1) :
|
|
Instruction_1<TypedRegister>
|
|
(WITHIN, aOp1) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[WITHIN] << "\t" << mOp1;
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& registers) {
|
|
f << getRegisterValue(registers, mOp1.first);
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Without : public Instruction {
|
|
public:
|
|
/* without this object */
|
|
Without () :
|
|
Instruction
|
|
(WITHOUT) {};
|
|
virtual Formatter& print(Formatter& f) {
|
|
f << opcodeNames[WITHOUT];
|
|
return f;
|
|
}
|
|
virtual Formatter& printOperands(Formatter& f, const JSValues& /*registers*/) {
|
|
return f;
|
|
}
|
|
};
|
|
|
|
class Xor : public Arithmetic {
|
|
public:
|
|
/* dest, source1, source2 */
|
|
Xor (TypedRegister aOp1, TypedRegister aOp2, TypedRegister aOp3) :
|
|
Arithmetic
|
|
(XOR, aOp1, aOp2, aOp3) {};
|
|
/* print() and printOperands() inherited from Arithmetic */
|
|
};
|
|
|
|
#else
|
|
|
|
char *opcodeNames[] = {
|
|
"ADD ",
|
|
"AND ",
|
|
"BIND_THIS ",
|
|
"BITNOT ",
|
|
"BRANCH ",
|
|
"BRANCH_FALSE ",
|
|
"BRANCH_INITIALIZED",
|
|
"BRANCH_TRUE ",
|
|
"CALL ",
|
|
"CAST ",
|
|
"CLASS ",
|
|
"COMPARE_EQ ",
|
|
"COMPARE_GE ",
|
|
"COMPARE_GT ",
|
|
"COMPARE_IN ",
|
|
"COMPARE_LE ",
|
|
"COMPARE_LT ",
|
|
"COMPARE_NE ",
|
|
"DEBUGGER ",
|
|
"DELETE_PROP ",
|
|
"DIRECT_CALL ",
|
|
"DIVIDE ",
|
|
"ELEM_XCR ",
|
|
"GENERIC_BINARY_OP ",
|
|
"GET_CLOSURE ",
|
|
"GET_ELEMENT ",
|
|
"GET_METHOD ",
|
|
"GET_PROP ",
|
|
"GET_SLOT ",
|
|
"GET_STATIC ",
|
|
"INSTANCEOF ",
|
|
"JSR ",
|
|
"LOAD_FALSE ",
|
|
"LOAD_IMMEDIATE ",
|
|
"LOAD_NAME ",
|
|
"LOAD_NULL ",
|
|
"LOAD_STRING ",
|
|
"LOAD_TRUE ",
|
|
"LOAD_TYPE ",
|
|
"MOVE ",
|
|
"MULTIPLY ",
|
|
"NAME_XCR ",
|
|
"NEGATE ",
|
|
"NEW_ARRAY ",
|
|
"NEW_CLASS ",
|
|
"NEW_CLOSURE ",
|
|
"NEW_FUNCTION ",
|
|
"NEW_OBJECT ",
|
|
"NOP ",
|
|
"NOT ",
|
|
"OR ",
|
|
"POSATE ",
|
|
"PROP_XCR ",
|
|
"REMAINDER ",
|
|
"RETURN ",
|
|
"RETURN_VOID ",
|
|
"RTS ",
|
|
"SAVE_NAME ",
|
|
"SET_ELEMENT ",
|
|
"SET_PROP ",
|
|
"SET_SLOT ",
|
|
"SET_STATIC ",
|
|
"SHIFTLEFT ",
|
|
"SHIFTRIGHT ",
|
|
"SLOT_XCR ",
|
|
"STATIC_XCR ",
|
|
"STRICT_EQ ",
|
|
"STRICT_NE ",
|
|
"SUBTRACT ",
|
|
"SUPER ",
|
|
"TEST ",
|
|
"THROW ",
|
|
"TRYIN ",
|
|
"TRYOUT ",
|
|
"USHIFTRIGHT ",
|
|
"VAR_XCR ",
|
|
"WITHIN ",
|
|
"WITHOUT ",
|
|
"XOR ",
|
|
};
|
|
|
|
#endif
|
|
|