gecko-dev/js/js2/icode.h
rogerl%netscape.com f13e0741a0 Changed Cast to take a JSValue containing a type instead of type directly.
Added LoadType to help support that. Also added LoadNull.
2001-02-01 00:59:21 +00:00

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