sourcepawn2: src/Interpreter.cpp@9efe9a1456fd (annotated)

dvander@39	1	/* vim: set ts=4 sw=4 tw=99 et:
dvander@39	2	*
dvander@0	3	* Copyright (C) 2012 David Anderson
dvander@0	4	*
dvander@0	5	* This file is part of JITCraft.
dvander@0	6	*
dvander@0	7	* JITCraft is free software: you can redistribute it and/or modify it under
dvander@0	8	* the terms of the GNU General Public License as published by the Free
dvander@0	9	* Software Foundation, either version 3 of the License, or (at your option)
dvander@0	10	* any later version.
dvander@0	11	*
dvander@0	12	* Foobar is distributed in the hope that it will be useful, but WITHOUT ANY
dvander@0	13	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
dvander@0	14	* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
dvander@0	15	*
dvander@0	16	* You should have received a copy of the GNU General Public License along with
dvander@0	17	* JITCraft. If not, see http://www.gnu.org/licenses/.
dvander@0	18	*/
danderson@91	19	#include <string.h>
dvander@0	20	#include "Interpreter.h"
dvander@0	21	#include "Modules.h"
dvander@0	22	#include "Zone.h"
dvander@0	23	#include "Types.h"
dvander@12	24	#include "Array.h"
dvander@14	25	#include "Reference.h"
dvander@69	26	#include "Strings.h"
dvander@85	27	#include "Environments.h"
dvander@147	28	#include "Structures.h"
dvander@28	29	#include "Heap-inl.h"
dvander@0	30
dvander@59	31	using namespace ke;
dvander@0	32
dvander@0	33	#define PUSH_I32(top, value) \
dvander@0	34	do { \
dvander@0	35	top.sp->i32 = value; \
dvander@0	36	top.sp++; \
dvander@0	37	} while (0)
dvander@0	38
dvander@4	39	#define PUSH_F(top, value) \
dvander@4	40	do { \
dvander@4	41	top.sp->f = value; \
dvander@4	42	top.sp++; \
dvander@4	43	} while (0)
dvander@4	44
dvander@0	45	static inline int
dvander@0	46	POP_I32(Top &top)
dvander@0	47	{
dvander@0	48	int value = top.sp[-1].i32;
dvander@0	49	top.sp--;
dvander@0	50	return value;
dvander@0	51	}
dvander@0	52
dvander@4	53	static inline float
dvander@4	54	POP_F(Top &top)
dvander@4	55	{
dvander@4	56	float value = top.sp[-1].f;
dvander@4	57	top.sp--;
dvander@4	58	return value;
dvander@4	59	}
dvander@4	60
dvander@77	61	// Pawn's original semantics specify some kind of floor operation, so
dvander@77	62	// (8 / -3 == -3) and (-8 / 3 == -1). The SourcePawn 1 compiler (spcomp) uses
dvander@77	63	// the upstream algorithm when constant folding. However the SourcePawn 1 JIT
dvander@77	64	// does not. My guess is that Borja freaked out seeing the 13-instruction x86
dvander@77	65	// sequence necessary to get this functionality (I vaguely recall a thread
dvander@77	66	// where we discussed this with Mark Peter? But the ITB forums are gone...),
dvander@77	67	// and we just decided to break the damn thing. So SP1 was inconsistent, but
dvander@77	68	// we are not. And for completeness, we assert that the C compiler does the
dvander@77	69	// right thing, since C89 leaves it unspecified.
dvander@77	70	STATIC_ASSERT(8 / -3 == -2);
dvander@77	71	STATIC_ASSERT(-8 / 3 == -2);
dvander@77	72
dvander@0	73	static inline bool
dvander@14	74	PushNewRef(Zone zone, Top &top, void location, Heap::Tenure tenure)
dvander@14	75	{
dvander@14	76	Reference *ref = Reference::NewStack(zone, location, tenure);
dvander@14	77	if (!ref)
dvander@14	78	return false;
dvander@14	79	top.sp->ref = ref;
dvander@14	80	top.sp++;
dvander@14	81	return true;
dvander@14	82	}
dvander@14	83
dvander@178	84	static bool CopyStruct(Zone *zone, Handle<Struct> left, Handle<Struct> right);
dvander@155	85
dvander@152	86	// Even though this function can fail, we immediately bail out, so it doesn't
dvander@152	87	// matter if we've leaving things unrooted.
dvander@21	88	static bool
dvander@178	89	CopyArray(Zone *zone, Handle<Array> source, Handle<Array> dest)
dvander@21	90	{
dvander@178	91	if (source->length() != dest->length()) {
dvander@178	92	// if (!ChangeArrayLength(zone, source, dest))
dvander@178	93	// return false;
dvander@178	94	}
dvander@178	95
dvander@155	96	if (source->type()->contained()->isArray()) {
dvander@155	97	assert(dest->type()->contained()->isArray());
dvander@155	98	assert(source->length() == dest->length());
dvander@155	99
dvander@178	100	Local<Array> left(zone);
dvander@178	101	Local<Array> right(zone);
dvander@155	102	for (unsigned i = 0; i < source->length(); i++) {
dvander@178	103	left = Array::cast(source->readObject(i));
dvander@178	104	right = Array::cast(dest->readObject(i));
dvander@155	105	if (!CopyArray(zone, left, right))
dvander@155	106	return false;
dvander@155	107	}
dvander@155	108	} else if (source->type()->contained()->isStruct()) {
dvander@155	109	assert(dest->type()->contained() == source->type()->contained());
dvander@155	110	assert(source->length() == dest->length());
dvander@21	111
dvander@178	112	Local<Struct> left(zone);
dvander@178	113	Local<Struct> right(zone);
dvander@155	114	for (unsigned i = 0; i < source->length(); i++) {
dvander@178	115	left = Struct::cast(source->readObject(i));
dvander@178	116	right = Struct::cast(dest->readObject(i));
dvander@155	117	if (!CopyStruct(zone, left, right))
dvander@155	118	return false;
dvander@155	119	}
dvander@155	120	} else {
dvander@156	121	assert(source->type()->contained()->pod() == dest->type()->contained()->pod());
dvander@156	122	assert(source->type()->contained()->pod() == PrimitiveType_Char
dvander@155	123	? source->length() >= dest->length()
dvander@155	124	: source->length() == dest->length());
dvander@155	125
dvander@155	126	memcpy(source->vec(), dest->vec(), dest->length() * dest->elementSize());
dvander@155	127	}
dvander@21	128	return true;
dvander@21	129	}
dvander@21	130
dvander@152	131	static void
dvander@157	132	GetElement(Array array, int index, LocalSlot vp)
dvander@157	133	{
dvander@157	134	if (array->type()->contained()->isTraceable()) {
dvander@157	135	vp->obj = array->readObject(index);
dvander@157	136	return;
dvander@157	137	}
dvander@157	138
dvander@157	139	switch (array->type()->contained()->pod()) {
dvander@157	140	case PrimitiveType_Float:
dvander@157	141	vp->f = array->readFloat(index);
dvander@157	142	break;
dvander@157	143
dvander@157	144	case PrimitiveType_Char:
dvander@157	145	vp->i32 = array->readChar(index);
dvander@157	146	break;
dvander@157	147
dvander@157	148	default:
dvander@157	149	assert(array->type()->contained()->pod() == PrimitiveType_Int32);
dvander@157	150	vp->i32 = array->readInt32(index);
dvander@157	151	break;
dvander@157	152	}
dvander@157	153	}
dvander@157	154
dvander@157	155	static void
dvander@157	156	SetElement(Zone zone, Array array, int index, const LocalSlot &v)
dvander@157	157	{
dvander@157	158	if (array->type()->contained()->isTraceable()) {
dvander@157	159	array->writeObject(zone, index, v.obj);
dvander@157	160	return;
dvander@157	161	}
dvander@157	162
dvander@157	163	switch (array->type()->contained()->pod()) {
dvander@157	164	case PrimitiveType_Float:
dvander@157	165	array->writeFloat(index, v.f);
dvander@157	166	break;
dvander@157	167
dvander@157	168	case PrimitiveType_Char:
dvander@157	169	array->writeChar(index, v.i32);
dvander@157	170	break;
dvander@157	171
dvander@157	172	default:
dvander@157	173	assert(array->type()->contained()->pod() == PrimitiveType_Int32);
dvander@157	174	array->writeInt32(index, v.i32);
dvander@157	175	break;
dvander@157	176	}
dvander@157	177	}
dvander@157	178
dvander@157	179	static void
dvander@152	180	GetField(Struct obj, Descriptor desc, LocalSlot *vp)
dvander@152	181	{
dvander@152	182	// :TODO: assert no GC.
dvander@152	183	if (desc->type()->isTraceable()) {
dvander@152	184	vp->obj = obj->get<Object *>(desc);
dvander@157	185	return;
dvander@157	186	}
dvander@152	187
dvander@157	188	switch (desc->type()->pod()) {
dvander@157	189	case PrimitiveType_Float:
dvander@157	190	vp->f = obj->get<float>(desc);
dvander@157	191	break;
dvander@157	192
dvander@157	193	default:
dvander@157	194	assert(desc->type()->pod() == PrimitiveType_Int32);
dvander@157	195	vp->i32 = obj->get<int>(desc);
dvander@157	196	break;
dvander@152	197	}
dvander@152	198	}
dvander@152	199
dvander@152	200	static void
dvander@152	201	GetField(Struct obj, unsigned index, LocalSlot vp)
dvander@152	202	{
dvander@152	203	Descriptor *desc = Descriptor::cast(obj->map()->type()->fields()->at(index));
dvander@152	204	GetField(obj, desc, vp);
dvander@152	205	}
dvander@152	206
dvander@152	207	static void
dvander@152	208	SetField(Zone zone, Struct obj, Descriptor *desc, const LocalSlot &v)
dvander@152	209	{
dvander@152	210	// :TODO: assert no GC.
dvander@152	211	if (desc->type()->isTraceable()) {
dvander@152	212	obj->set(zone, desc, v.obj);
dvander@157	213	return;
dvander@157	214	}
dvander@152	215
dvander@157	216	switch (desc->type()->pod()) {
dvander@157	217	case PrimitiveType_Float:
dvander@157	218	obj->set<float>(desc, v.f);
dvander@157	219	break;
dvander@157	220
dvander@157	221	default:
dvander@157	222	assert(desc->type()->pod() == PrimitiveType_Int32);
dvander@157	223	obj->set<int>(desc, v.i32);
dvander@157	224	break;
dvander@152	225	}
dvander@152	226	}
dvander@152	227
dvander@152	228	static void
dvander@152	229	SetField(Zone zone, Struct obj, unsigned index, const LocalSlot &v)
dvander@152	230	{
dvander@152	231	Descriptor *desc = Descriptor::cast(obj->map()->type()->fields()->at(index));
dvander@152	232	SetField(zone, obj, desc, v);
dvander@152	233	}
dvander@152	234
dvander@152	235	// Even though this function can fail, we immediately bail out, so it doesn't
dvander@152	236	// matter if we've leaving things unrooted.
dvander@152	237	static bool
dvander@178	238	CopyStruct(Zone *zone, Handle<Struct> left, Handle<Struct> right)
dvander@152	239	{
dvander@152	240	assert(left->map()->type() == right->map()->type());
dvander@152	241
dvander@178	242	Local<Type> type(zone, left->map()->type());
dvander@178	243	Local<Struct> leftStruct(zone);
dvander@178	244	Local<Struct> rightStruct(zone);
dvander@178	245	Local<Array> leftArray(zone);
dvander@178	246	Local<Array> rightArray(zone);
dvander@152	247	for (unsigned i = 0; i < type->fields()->length(); i++) {
dvander@152	248	Descriptor *desc = Descriptor::cast(type->fields()->at(i));
dvander@152	249
dvander@152	250	LocalSlot rval;
dvander@152	251	GetField(right, desc, &rval);
dvander@152	252
dvander@152	253	// If the field is a struct, we need to deep-copy.
dvander@152	254	if (desc->type()->isStruct()) {
dvander@152	255	LocalSlot lval;
dvander@152	256
dvander@152	257	GetField(left, desc, &lval);
dvander@178	258	leftStruct = Struct::cast(lval.obj);
dvander@178	259	rightStruct = Struct::cast(rval.obj);
dvander@178	260	if (!CopyStruct(zone, leftStruct, rightStruct))
dvander@152	261	return false;
dvander@152	262	} else if (desc->type()->isArray()) {
dvander@152	263	LocalSlot lval;
dvander@152	264
dvander@152	265	GetField(left, desc, &lval);
dvander@178	266	leftArray = Array::cast(lval.obj);
dvander@178	267	rightArray = Array::cast(rval.obj);
dvander@178	268	if (!CopyArray(zone, leftArray, rightArray))
dvander@152	269	return false;
dvander@152	270	} else {
dvander@152	271	SetField(zone, left, desc, rval);
dvander@152	272	}
dvander@152	273	}
dvander@152	274
dvander@152	275	return true;
dvander@152	276	}
dvander@152	277
dvander@68	278	static bool
dvander@68	279	InvokeNative(Zone zone, Handle<Native> native, void identity, LocalSlot *args, unsigned argc,
dvander@68	280	int *result)
dvander@68	281	{
dvander@68	282	NativeArgs guard;
dvander@68	283
dvander@68	284	if (!zone->stack().pushNativeFrame(native, guard, argc + 1))
dvander@68	285	return false;
dvander@68	286
dvander@68	287	intptr_t *cells = guard.args();
dvander@68	288
dvander@68	289	// params[0] == argc, in ISPE
dvander@68	290	cells[0] = argc;
dvander@68	291
dvander@68	292	// Pass the formal arguments.
dvander@68	293	Local<Type> type(zone, native->type());
dvander@68	294	Local<Type> param(zone);
dvander@68	295	for (unsigned i = 0; i < type->parameters()->length(); i++) {
dvander@68	296	param = type->parameterAt(i);
dvander@68	297
dvander@68	298	// For floats, we rely on the aliasing of \|i32\| and \|f\|.
dvander@68	299	LocalSlot &arg = args[-int(i) - 1];
dvander@68	300	if (param->isInt32() \|\| param->isFloat()) {
dvander@68	301	cells[i + 1] = arg.i32;
dvander@68	302	} else if (param->isReference()) {
dvander@68	303	cells[i + 1] = reinterpret_cast<intptr_t>(arg.ref->location());
dvander@68	304	} else {
dvander@68	305	assert(param->isArray());
dvander@68	306	cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->vec());
dvander@68	307	}
dvander@68	308	}
dvander@68	309
dvander@68	310	// For variadic arguments, the compiler left either arrays or references.
dvander@68	311	for (unsigned i = type->parameters()->length(); i < argc; i++) {
dvander@68	312	LocalSlot &arg = args[-int(i) - 1];
dvander@68	313
dvander@68	314	if (arg.obj->is(MapKind_Reference)) {
dvander@68	315	cells[i + 1] = reinterpret_cast<intptr_t>(arg.ref->location());
dvander@68	316	} else {
dvander@68	317	assert(arg.obj->is(MapKind_Array));
dvander@68	318	cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->vec());
dvander@68	319	}
dvander@68	320	}
dvander@68	321
dvander@68	322	typedef intptr_t (INVOKE)(void , intptr_t *);
dvander@68	323	INVOKE invoke = (INVOKE)native->function();
dvander@68	324	*result = invoke(identity, cells);
dvander@68	325
dvander@69	326	return !zone->hasPendingException();
dvander@68	327	}
dvander@68	328
dvander@0	329	bool
dvander@59	330	ke::Interpret(Zone zone, Frame entryFrame, LocalSlot *result)
dvander@0	331	{
dvander@42	332	Top &top = *zone->stack().top();
dvander@69	333	if (!entryFrame)
dvander@69	334	entryFrame = top.fp;
dvander@69	335
dvander@47	336	LocalSlot *locals = entryFrame->locals();
dvander@0	337
dvander@0	338	for (;;) {
dvander@0	339	Opcode op = Opcode(*top.pc);
dvander@174	340
dvander@174	341	if (OpcodeInfo[op].nuses > 0)
dvander@174	342	assert(top.sp - OpcodeInfo[op].nuses >= top.fp->stackBase());
dvander@174	343
dvander@0	344	switch (op) {
dvander@0	345
dvander@0	346	case OP_NOP:
dvander@0	347	break;
dvander@0	348
dvander@0	349	case OP_INT:
dvander@0	350	PUSH_I32(top, READ_INT32(top.pc));
dvander@0	351	break;
dvander@0	352
dvander@4	353	case OP_FLOAT:
dvander@4	354	PUSH_F(top, READ_FLOAT(top.pc));
dvander@4	355	break;
dvander@4	356
dvander@0	357	case OP_RETURN:
dvander@72	358	case OP_RETURNVOID:
dvander@72	359	case OP_STOP:
dvander@0	360	{
dvander@72	361	if (op == OP_RETURN)
dvander@72	362	result = --top.sp;
dvander@72	363
dvander@69	364	if (top.fp == entryFrame)
dvander@69	365	goto done;
dvander@0	366
dvander@72	367	// This must not GC.
dvander@65	368	zone->stack().popInlineFrame();
dvander@47	369	locals = top.fp->locals();
dvander@72	370
dvander@72	371	if (op == OP_RETURN)
dvander@72	372	top.sp++ = result;
dvander@72	373
dvander@0	374	top.pc += OpcodeInfo[*top.pc].length;
dvander@0	375	continue;
dvander@0	376	}
dvander@0	377
dvander@80	378	case OP_POP:
dvander@80	379	{
dvander@80	380	top.sp--;
dvander@80	381	break;
dvander@80	382	}
dvander@80	383
dvander@0	384	#define RELATIONAL_JUMP(op) \
dvander@0	385	{ \
dvander@0	386	int right = POP_I32(top); \
dvander@0	387	int left = POP_I32(top); \
dvander@0	388	if (left op right) { \
dvander@0	389	top.pc += READ_INT32(top.pc); \
dvander@0	390	continue; \
dvander@0	391	} \
dvander@0	392	}
dvander@0	393
dvander@0	394	case OP_JL:
dvander@0	395	RELATIONAL_JUMP(<);
dvander@0	396	break;
dvander@0	397
dvander@0	398	case OP_JLE:
dvander@0	399	RELATIONAL_JUMP(<=);
dvander@0	400	break;
dvander@0	401
dvander@0	402	case OP_JG:
dvander@0	403	RELATIONAL_JUMP(>);
dvander@0	404	break;
dvander@0	405
dvander@0	406	case OP_JGE:
dvander@0	407	RELATIONAL_JUMP(>=);
dvander@0	408	break;
dvander@0	409
dvander@0	410	case OP_JEQ:
dvander@0	411	RELATIONAL_JUMP(==);
dvander@0	412	break;
dvander@0	413
dvander@0	414	case OP_JNE:
dvander@0	415	RELATIONAL_JUMP(!=);
dvander@0	416	break;
dvander@0	417
dvander@74	418	#undef RELATIONAL_JUMP
dvander@74	419
dvander@0	420	case OP_JT:
dvander@0	421	{
dvander@0	422	int value = POP_I32(top);
dvander@0	423	if (value) {
dvander@0	424	top.pc += READ_INT32(top.pc);
dvander@0	425	continue;
dvander@0	426	}
dvander@0	427	break;
dvander@0	428	}
dvander@0	429
dvander@0	430	case OP_JF:
dvander@0	431	{
dvander@0	432	int value = POP_I32(top);
dvander@0	433	if (!value) {
dvander@0	434	top.pc += READ_INT32(top.pc);
dvander@0	435	continue;
dvander@0	436	}
dvander@0	437	break;
dvander@0	438	}
dvander@0	439
dvander@74	440	#define RELATIONAL_JUMP_F(op) \
dvander@74	441	{ \
dvander@74	442	float right = POP_F(top); \
dvander@74	443	float left = POP_F(top); \
dvander@74	444	if (left op right) { \
dvander@74	445	top.pc += READ_INT32(top.pc); \
dvander@74	446	continue; \
dvander@74	447	} \
dvander@74	448	}
dvander@74	449
dvander@74	450	case OP_JL_F:
dvander@74	451	RELATIONAL_JUMP_F(<);
dvander@74	452	break;
dvander@74	453
dvander@74	454	case OP_JLE_F:
dvander@74	455	RELATIONAL_JUMP_F(<=);
dvander@74	456	break;
dvander@74	457
dvander@74	458	case OP_JG_F:
dvander@74	459	RELATIONAL_JUMP_F(>);
dvander@74	460	break;
dvander@74	461
dvander@74	462	case OP_JGE_F:
dvander@74	463	RELATIONAL_JUMP_F(>=);
dvander@74	464	break;
dvander@74	465
dvander@74	466	case OP_JEQ_F:
dvander@74	467	RELATIONAL_JUMP_F(==);
dvander@74	468	break;
dvander@74	469
dvander@74	470	case OP_JNE_F:
dvander@74	471	RELATIONAL_JUMP_F(!=);
dvander@74	472	break;
dvander@74	473
dvander@74	474	case OP_JT_F:
dvander@74	475	{
dvander@74	476	float value = POP_F(top);
dvander@74	477	if (value) {
dvander@74	478	top.pc += READ_INT32(top.pc);
dvander@74	479	continue;
dvander@74	480	}
dvander@74	481	break;
dvander@74	482	}
dvander@74	483
dvander@74	484	case OP_JF_F:
dvander@74	485	{
dvander@74	486	float value = POP_F(top);
dvander@74	487	if (!value) {
dvander@74	488	top.pc += READ_INT32(top.pc);
dvander@74	489	continue;
dvander@74	490	}
dvander@74	491	break;
dvander@74	492	}
dvander@74	493
dvander@0	494	case OP_JUMP:
dvander@0	495	top.pc += READ_INT32(top.pc);
dvander@0	496	continue;
dvander@0	497
dvander@0	498	case OP_GETLOCAL:
dvander@0	499	{
dvander@0	500	int slot = READ_INT32(top.pc);
dvander@0	501	*top.sp++ = locals[slot];
dvander@0	502	break;
dvander@0	503	}
dvander@0	504
dvander@0	505	case OP_SETLOCAL:
dvander@0	506	{
dvander@0	507	int slot = READ_INT32(top.pc);
dvander@0	508	locals[slot] = top.sp[-1];
dvander@0	509	break;
dvander@0	510	}
dvander@0	511
dvander@0	512	case OP_ADD:
dvander@0	513	{
dvander@77	514	top.sp[-2].i32 = top.sp[-2].i32 + top.sp[-1].i32;
dvander@77	515	top.sp--;
dvander@0	516	break;
dvander@0	517	}
dvander@0	518
dvander@0	519	case OP_SUB:
dvander@0	520	{
dvander@77	521	top.sp[-2].i32 = top.sp[-2].i32 - top.sp[-1].i32;
dvander@77	522	top.sp--;
dvander@0	523	break;
dvander@0	524	}
dvander@0	525
dvander@0	526	case OP_MUL:
dvander@0	527	{
dvander@77	528	top.sp[-2].i32 = top.sp[-2].i32 * top.sp[-1].i32;
dvander@77	529	top.sp--;
dvander@0	530	break;
dvander@0	531	}
dvander@0	532
dvander@0	533	case OP_DIV:
dvander@0	534	{
dvander@77	535	if (top.sp[-1].i32 == 0) {
dvander@69	536	zone->reportError(Message_IntegerDivideByZero);
dvander@69	537	goto error;
dvander@69	538	}
dvander@77	539	top.sp[-2].i32 = top.sp[-2].i32 / top.sp[-1].i32;
dvander@77	540	top.sp--;
dvander@0	541	break;
dvander@0	542	}
dvander@0	543
dvander@82	544	case OP_MOD:
dvander@82	545	{
dvander@82	546	if (top.sp[-1].i32 == 0) {
dvander@82	547	zone->reportError(Message_IntegerDivideByZero);
dvander@82	548	goto error;
dvander@82	549	}
dvander@82	550	top.sp[-2].i32 = top.sp[-2].i32 % top.sp[-1].i32;
dvander@82	551	top.sp--;
dvander@82	552	break;
dvander@82	553	}
dvander@82	554
dvander@74	555	case OP_LT:
dvander@74	556	{
dvander@74	557	top.sp[-2].i32 = top.sp[-2].i32 < top.sp[-1].i32;
dvander@74	558	top.sp--;
dvander@74	559	break;
dvander@74	560	}
dvander@74	561
dvander@74	562	case OP_LE:
dvander@74	563	{
dvander@74	564	top.sp[-2].i32 = top.sp[-2].i32 <= top.sp[-1].i32;
dvander@74	565	top.sp--;
dvander@74	566	break;
dvander@74	567	}
dvander@74	568
dvander@74	569	case OP_GT:
dvander@74	570	{
dvander@74	571	top.sp[-2].i32 = top.sp[-2].i32 > top.sp[-1].i32;
dvander@74	572	top.sp--;
dvander@74	573	break;
dvander@74	574	}
dvander@74	575
dvander@74	576	case OP_GE:
dvander@74	577	{
dvander@74	578	top.sp[-2].i32 = top.sp[-2].i32 >= top.sp[-1].i32;
dvander@74	579	top.sp--;
dvander@74	580	break;
dvander@74	581	}
dvander@74	582
dvander@74	583	case OP_EQ:
dvander@74	584	{
dvander@74	585	top.sp[-2].i32 = (top.sp[-2].i32 == top.sp[-1].i32);
dvander@74	586	top.sp--;
dvander@74	587	break;
dvander@74	588	}
dvander@74	589
dvander@74	590	case OP_NE:
dvander@74	591	{
dvander@74	592	top.sp[-2].i32 = (top.sp[-2].i32 != top.sp[-1].i32);
dvander@74	593	top.sp--;
dvander@74	594	break;
dvander@74	595	}
dvander@74	596
dvander@4	597	case OP_ADD_F:
dvander@4	598	{
dvander@77	599	top.sp[-2].f = top.sp[-2].f + top.sp[-1].f;
dvander@77	600	top.sp--;
dvander@4	601	break;
dvander@4	602	}
dvander@4	603
dvander@4	604	case OP_SUB_F:
dvander@4	605	{
dvander@77	606	top.sp[-2].f = top.sp[-2].f - top.sp[-1].f;
dvander@77	607	top.sp--;
dvander@4	608	break;
dvander@4	609	}
dvander@4	610
dvander@4	611	case OP_MUL_F:
dvander@4	612	{
dvander@77	613	top.sp[-2].f = top.sp[-2].f * top.sp[-1].f;
dvander@77	614	top.sp--;
dvander@4	615	break;
dvander@4	616	}
dvander@4	617
dvander@4	618	case OP_DIV_F:
dvander@4	619	{
dvander@77	620	top.sp[-2].f = top.sp[-2].f / top.sp[-1].f;
dvander@77	621	top.sp--;
dvander@4	622	break;
dvander@4	623	}
dvander@4	624
dvander@74	625	case OP_LT_F:
dvander@74	626	{
dvander@74	627	top.sp[-2].f = top.sp[-2].f < top.sp[-1].f;
dvander@74	628	top.sp--;
dvander@74	629	break;
dvander@74	630	}
dvander@74	631
dvander@74	632	case OP_LE_F:
dvander@74	633	{
dvander@74	634	top.sp[-2].f = top.sp[-2].f <= top.sp[-1].f;
dvander@74	635	top.sp--;
dvander@74	636	break;
dvander@74	637	}
dvander@74	638
dvander@74	639	case OP_GT_F:
dvander@74	640	{
dvander@74	641	top.sp[-2].f = top.sp[-2].f > top.sp[-1].f;
dvander@74	642	top.sp--;
dvander@74	643	break;
dvander@74	644	}
dvander@74	645
dvander@74	646	case OP_GE_F:
dvander@74	647	{
dvander@74	648	top.sp[-2].f = top.sp[-2].f >= top.sp[-1].f;
dvander@74	649	top.sp--;
dvander@74	650	break;
dvander@74	651	}
dvander@74	652
dvander@74	653	case OP_EQ_F:
dvander@74	654	{
dvander@74	655	top.sp[-2].i32 = (top.sp[-2].f == top.sp[-1].f);
dvander@74	656	top.sp--;
dvander@74	657	break;
dvander@74	658	}
dvander@74	659
dvander@74	660	case OP_NE_F:
dvander@74	661	{
dvander@74	662	top.sp[-2].i32 = (top.sp[-2].f != top.sp[-1].f);
dvander@74	663	top.sp--;
dvander@74	664	break;
dvander@74	665	}
dvander@74	666
dvander@8	667	case OP_SHL:
dvander@8	668	{
dvander@77	669	top.sp[-2].i32 = top.sp[-2].i32 << top.sp[-1].i32;
dvander@77	670	top.sp--;
dvander@8	671	break;
dvander@8	672	}
dvander@8	673
dvander@8	674	case OP_SHR:
dvander@8	675	{
dvander@77	676	top.sp[-2].i32 = top.sp[-2].i32 >> top.sp[-1].i32;
dvander@77	677	top.sp--;
dvander@8	678	break;
dvander@8	679	}
dvander@8	680
dvander@8	681	case OP_USHR:
dvander@8	682	{
dvander@77	683	top.sp[-2].i32 = unsigned(top.sp[-2].i32) << unsigned(top.sp[-1].i32);
dvander@77	684	top.sp--;
dvander@8	685	break;
dvander@8	686	}
dvander@8	687
dvander@8	688	case OP_BITAND:
dvander@8	689	{
dvander@77	690	top.sp[-2].i32 = top.sp[-2].i32 & top.sp[-1].i32;
dvander@77	691	top.sp--;
dvander@8	692	break;
dvander@8	693	}
dvander@8	694
dvander@8	695	case OP_BITOR:
dvander@8	696	{
dvander@77	697	top.sp[-2].i32 = top.sp[-2].i32 \| top.sp[-1].i32;
dvander@77	698	top.sp--;
dvander@8	699	break;
dvander@8	700	}
dvander@8	701
dvander@8	702	case OP_BITXOR:
dvander@8	703	{
dvander@77	704	top.sp[-2].i32 = top.sp[-2].i32 ^ top.sp[-1].i32;
dvander@77	705	top.sp--;
dvander@8	706	break;
dvander@8	707	}
dvander@8	708
dvander@78	709	case OP_BITNOT:
dvander@78	710	{
dvander@78	711	top.sp[-1].i32 = ~top.sp[-1].i32;
dvander@78	712	break;
dvander@78	713	}
dvander@78	714
dvander@79	715	case OP_NOT:
dvander@79	716	{
dvander@79	717	top.sp[-1].i32 = top.sp[-1].i32 ? 0 : 1;
dvander@79	718	break;
dvander@79	719	}
dvander@79	720
dvander@79	721	case OP_NOT_F:
dvander@79	722	{
dvander@79	723	top.sp[-1].i32 = top.sp[-1].f ? 0 : 1;
dvander@79	724	break;
dvander@79	725	}
dvander@79	726
dvander@80	727	case OP_NEG:
dvander@79	728	{
dvander@80	729	top.sp[-1].i32 = -top.sp[-1].i32;
dvander@80	730	break;
dvander@80	731	}
dvander@80	732
dvander@80	733	case OP_NEG_F:
dvander@80	734	{
dvander@80	735	top.sp[-1].f = -top.sp[-1].f;
dvander@0	736	break;
dvander@79	737	}
dvander@0	738
dvander@73	739	case OP_CALL:
dvander@0	740	{
dvander@73	741	Local<Function> newFun(zone, top.sp[-1].fun);
dvander@73	742	top.sp--;
dvander@73	743
dvander@69	744	if (!zone->stack().pushInlineFrame(newFun))
dvander@69	745	goto error;
dvander@0	746
dvander@47	747	locals = top.fp->locals();
dvander@0	748	continue;
dvander@0	749	}
dvander@0	750
dvander@0	751	case OP_GETARG:
dvander@0	752	{
dvander@0	753	unsigned slot = READ_UINT32(top.pc);
dvander@47	754	*top.sp++ = top.fp->arg(slot);
dvander@0	755	break;
dvander@0	756	}
dvander@0	757
dvander@0	758	case OP_SETARG:
dvander@0	759	{
dvander@0	760	unsigned slot = READ_UINT32(top.pc);
dvander@174	761	top.fp->arg(slot) = top.sp[-1];
dvander@0	762	break;
dvander@0	763	}
dvander@0	764
dvander@158	765	case OP_GETELEM:
dvander@0	766	{
dvander@158	767	Array *array = Array::cast(top.sp[-2].obj);
dvander@0	768	int index = top.sp[-1].i32;
dvander@158	769
dvander@155	770	if (index < 0 \|\| unsigned(index) >= array->length()) {
dvander@155	771	zone->reportError(Message_ArrayIndexOutOfBounds, index, array->length());
dvander@69	772	goto error;
dvander@69	773	}
dvander@0	774
dvander@157	775	GetElement(array, index, &top.sp[-2]);
dvander@21	776	top.sp--;
dvander@21	777	break;
dvander@21	778	}
dvander@21	779
dvander@157	780	case OP_SETELEM:
dvander@0	781	{
dvander@157	782	Array *array = Array::cast(top.sp[-3].obj);
dvander@0	783	int index = top.sp[-2].i32;
dvander@158	784
dvander@158	785	if (index < 0 \|\| unsigned(index) >= array->length()) {
dvander@158	786	zone->reportError(Message_ArrayIndexOutOfBounds, index, array->length());
dvander@158	787	goto error;
dvander@158	788	}
dvander@158	789
dvander@157	790	SetElement(zone, array, index, top.sp[-1]);
dvander@7	791	top.sp[-3] = top.sp[-1];
dvander@7	792	top.sp -= 2;
dvander@7	793	break;
dvander@7	794	}
dvander@7	795
dvander@4	796	case OP_CVT_I2F:
dvander@4	797	{
dvander@4	798	int ival = POP_I32(top);
dvander@4	799	float fval = (float)ival;
dvander@4	800	PUSH_F(top, fval);
dvander@4	801	break;
dvander@4	802	}
dvander@4	803
dvander@85	804	case OP_NEWARRAY:
dvander@12	805	{
dvander@85	806	Heap::Tenure tenure = (Heap::Tenure)top.pc[1];
dvander@85	807	Local<ArrayMap> map(zone, ArrayMap::cast(top.fp->code()->map(READ_UINT32(top.pc + 1))));
dvander@154	808	Array *array = Array::New(zone, map, map->type()->elements(), tenure);
dvander@69	809	if (!array)
dvander@69	810	goto error;
dvander@12	811	top.sp->obj = array;
dvander@12	812	top.sp++;
dvander@12	813	break;
dvander@12	814	}
dvander@12	815
dvander@147	816	case OP_NEWSTRUCT:
dvander@147	817	{
dvander@147	818	Heap::Tenure tenure = (Heap::Tenure)top.pc[1];
dvander@147	819	Local<StructMap> map(zone, StructMap::cast(top.fp->code()->map(READ_UINT32(top.pc + 1))));
dvander@147	820	top.sp->obj = Struct::New(zone, map, tenure);
dvander@147	821	if (!top.sp->obj)
dvander@147	822	goto error;
dvander@147	823	top.sp++;
dvander@147	824	break;
dvander@147	825	}
dvander@147	826
dvander@12	827	case OP_SAVELIFO:
dvander@10	828	{
dvander@10	829	unsigned slot = READ_UINT32(top.pc);
dvander@42	830	locals[slot].address = zone->heap().lifoPosition();
dvander@12	831	break;
dvander@12	832	}
dvander@12	833
dvander@12	834	case OP_UNWINDLIFO:
dvander@12	835	{
dvander@12	836	unsigned slot = READ_UINT32(top.pc);
dvander@42	837	zone->heap().unwindLifo(locals[slot].address);
dvander@10	838	break;
dvander@10	839	}
dvander@10	840
dvander@14	841	case OP_VARREF_LIFO:
dvander@14	842	{
dvander@14	843	unsigned slot = READ_UINT32(top.pc);
dvander@69	844	if (!PushNewRef(zone, top, &locals[slot], Heap::Tenure_Stack))
dvander@69	845	goto error;
dvander@14	846	break;
dvander@14	847	}
dvander@14	848
dvander@14	849	case OP_ARGREF_LIFO:
dvander@14	850	{
dvander@14	851	unsigned slot = READ_UINT32(top.pc);
dvander@69	852	if (!PushNewRef(zone, top, &top.fp->arg(slot), Heap::Tenure_Stack))
dvander@69	853	goto error;
dvander@14	854	break;
dvander@14	855	}
dvander@14	856
dvander@17	857	case OP_ARRAYREF_LIFO:
dvander@17	858	{
dvander@164	859	Local<Array> array(zone, Array::cast(top.sp[-2].obj));
dvander@42	860	Local<Reference> ref(zone, Reference::NewArray(zone, array, top.sp[-1].i32, Heap::Tenure_Stack));
dvander@69	861	if (!ref)
dvander@69	862	goto error;
dvander@17	863	top.sp[-2].ref = ref;
dvander@17	864	top.sp--;
dvander@17	865	break;
dvander@17	866	}
dvander@17	867
dvander@16	868	case OP_SLOTREF_LIFO:
dvander@16	869	{
dvander@42	870	Reference *ref = Reference::NewStack(zone, top.sp[-1], Heap::Tenure_Stack);
dvander@69	871	if (!ref)
dvander@69	872	goto error;
dvander@16	873	top.sp[-1].ref = ref;
dvander@16	874	break;
dvander@16	875	}
dvander@16	876
dvander@164	877	case OP_FIELDREF_LIFO:
dvander@164	878	{
dvander@164	879	Local<Struct> obj(zone, Struct::cast(top.sp[-1].obj));
dvander@164	880	top.sp[-1].obj = Reference::NewField(zone, obj, READ_UINT32(top.pc), Heap::Tenure_Stack);
dvander@164	881	if (!top.sp[-1].obj)
dvander@164	882	goto error;
dvander@164	883	break;
dvander@164	884	}
dvander@164	885
dvander@14	886	case OP_GETREF_I:
dvander@14	887	{
dvander@14	888	top.sp[-1].i32 = top.sp[-1].ref->getInt();
dvander@14	889	break;
dvander@14	890	}
dvander@14	891
dvander@14	892	case OP_SETREF_I:
dvander@14	893	{
dvander@14	894	top.sp[-2].ref->setInt(top.sp[-1].i32);
dvander@14	895	top.sp[-2].i32 = top.sp[-1].i32;
dvander@23	896	top.sp--;
dvander@14	897	break;
dvander@14	898	}
dvander@14	899
dvander@14	900	case OP_GETREF_F:
dvander@14	901	{
dvander@14	902	top.sp[-1].f = top.sp[-1].ref->getFloat();
dvander@14	903	break;
dvander@14	904	}
dvander@14	905
dvander@14	906	case OP_SETREF_F:
dvander@14	907	{
dvander@14	908	top.sp[-2].ref->setFloat(top.sp[-1].f);
dvander@14	909	top.sp[-2].f = top.sp[-1].f;
dvander@14	910	break;
dvander@14	911	}
dvander@14	912
dvander@21	913	case OP_OBJECT:
dvander@21	914	{
dvander@47	915	top.sp->obj = top.fp->code()->object(READ_UINT32(top.pc));
dvander@21	916	top.sp++;
dvander@21	917	break;
dvander@21	918	}
dvander@21	919
dvander@152	920	case OP_COPYARRAY:
dvander@21	921	{
dvander@21	922	// Note for this assignment opcode, we return the left-hand side, not the
dvander@21	923	// right, since in this case the result of the expression could be different.
dvander@178	924	Local<Array> left(zone, Array::cast(top.sp[-2].array));
dvander@178	925	Local<Array> right(zone, Array::cast(top.sp[-1].array));
dvander@178	926	if (!CopyArray(zone, left, right))
dvander@69	927	goto error;
dvander@21	928	top.sp--;
dvander@21	929	break;
dvander@21	930	}
dvander@21	931
dvander@22	932	case OP_DUP:
dvander@22	933	{
dvander@23	934	top.sp++;
dvander@23	935	top.sp[-1] = top.sp[-2];
dvander@22	936	break;
dvander@22	937	}
dvander@22	938
dvander@22	939	case OP_DUP2:
dvander@22	940	{
dvander@23	941	top.sp += 2;
dvander@23	942	top.sp[-2] = top.sp[-4];
dvander@23	943	top.sp[-1] = top.sp[-3];
dvander@23	944	break;
dvander@23	945	}
dvander@23	946
dvander@23	947	case OP_SWAP:
dvander@23	948	{
dvander@23	949	LocalSlot slot = top.sp[-2];
dvander@23	950	top.sp[-2] = top.sp[-1];
dvander@23	951	top.sp[-1] = slot;
dvander@23	952	break;
dvander@23	953	}
dvander@23	954
dvander@23	955	case OP_ROLL3:
dvander@23	956	{
dvander@23	957	LocalSlot slot = top.sp[-3];
dvander@23	958	top.sp[-3] = top.sp[-2];
dvander@23	959	top.sp[-2] = top.sp[-1];
dvander@23	960	top.sp[-1] = slot;
dvander@23	961	break;
dvander@23	962	}
dvander@23	963
dvander@23	964	case OP_PICK2:
dvander@23	965	{
dvander@23	966	top.sp++;
dvander@23	967	top.sp[-1] = top.sp[-3];
dvander@23	968	break;
dvander@23	969	}
dvander@23	970
dvander@23	971	case OP_PICK3:
dvander@23	972	{
dvander@23	973	top.sp++;
dvander@23	974	top.sp[-1] = top.sp[-4];
dvander@22	975	break;
dvander@22	976	}
dvander@22	977
dvander@68	978	case OP_CALLNATIVE:
dvander@68	979	{
dvander@68	980	unsigned index = READ_UINT32(top.pc);
dvander@68	981	unsigned argc = READ_UINT32(top.pc + 4);
dvander@68	982
dvander@68	983	Local<Native> native(zone, Native::cast(top.fp->code()->module()->natives()->at(index)));
dvander@68	984	if (!native->function()) {
dvander@69	985	zone->reportError(Message_NativeNotBound, native->name()->chars());
dvander@69	986	goto error;
dvander@68	987	}
dvander@68	988
dvander@68	989	int result;
dvander@68	990	void *nativeIdentity = top.fp->code()->module()->nativeIdentity();
dvander@69	991	if (!InvokeNative(zone, native, nativeIdentity, top.sp, argc, &result))
dvander@69	992	goto error;
dvander@68	993
dvander@68	994	top.sp -= argc;
dvander@68	995	PUSH_I32(top, result);
dvander@68	996	break;
dvander@68	997	}
dvander@68	998
dvander@73	999	case OP_MODULE:
dvander@73	1000	{
dvander@73	1001	top.sp++;
dvander@73	1002	top.sp[-1].module = top.fp->code()->module();
dvander@73	1003	break;
dvander@73	1004	}
dvander@73	1005
dvander@73	1006	case OP_GETMODULE_FN:
dvander@73	1007	{
dvander@73	1008	top.sp[-1].fun = top.sp[-1].module->getFunction(READ_UINT32(top.pc));
dvander@73	1009	break;
dvander@73	1010	}
dvander@73	1011
dvander@85	1012	case OP_GETGLOBAL_I:
dvander@85	1013	{
dvander@85	1014	unsigned slot = READ_UINT32(top.pc);
dvander@85	1015	top.sp++;
dvander@85	1016	top.sp[-1].i32 = top.fp->code()->module()->environment()->getInt32(slot);
dvander@85	1017	break;
dvander@85	1018	}
dvander@85	1019
dvander@85	1020	case OP_GETGLOBAL_F:
dvander@85	1021	{
dvander@85	1022	unsigned slot = READ_UINT32(top.pc);
dvander@85	1023	top.sp++;
dvander@85	1024	top.sp[-1].f = top.fp->code()->module()->environment()->getFloat(slot);
dvander@85	1025	break;
dvander@85	1026	}
dvander@85	1027
dvander@85	1028	case OP_GETGLOBAL_O:
dvander@85	1029	{
dvander@85	1030	unsigned slot = READ_UINT32(top.pc);
dvander@85	1031	top.sp++;
dvander@85	1032	top.sp[-1].obj = top.fp->code()->module()->environment()->getObject(slot);
dvander@85	1033	break;
dvander@85	1034	}
dvander@85	1035
dvander@85	1036	case OP_SETGLOBAL_I:
dvander@85	1037	{
dvander@85	1038	unsigned slot = READ_UINT32(top.pc);
dvander@85	1039	top.fp->code()->module()->environment()->setInt32(slot, top.sp[-1].i32);
dvander@85	1040	break;
dvander@85	1041	}
dvander@85	1042
dvander@85	1043	case OP_SETGLOBAL_F:
dvander@85	1044	{
dvander@85	1045	unsigned slot = READ_UINT32(top.pc);
dvander@85	1046	top.fp->code()->module()->environment()->setFloat(slot, top.sp[-1].f);
dvander@85	1047	break;
dvander@85	1048	}
dvander@85	1049
dvander@85	1050	case OP_SETGLOBAL_O:
dvander@85	1051	{
dvander@85	1052	unsigned slot = READ_UINT32(top.pc);
dvander@85	1053	top.fp->code()->module()->environment()->setObject(slot, top.sp[-1].obj);
dvander@85	1054	break;
dvander@85	1055	}
dvander@85	1056
dvander@142	1057	case OP_BITS_I2F:
dvander@142	1058	case OP_BITS_F2I:
dvander@142	1059	{
dvander@142	1060	// Because the stack is a union, these are actually no-ops in the
dvander@142	1061	// interpreter.
dvander@142	1062	break;
dvander@142	1063	}
dvander@142	1064
dvander@143	1065	case OP_TRUE:
dvander@143	1066	{
dvander@143	1067	top.sp++;
dvander@143	1068	top.sp[-1].i32 = 1;
dvander@143	1069	break;
dvander@143	1070	}
dvander@143	1071
dvander@143	1072	case OP_FALSE:
dvander@143	1073	{
dvander@143	1074	top.sp++;
dvander@143	1075	top.sp[-1].i32 = 0;
dvander@143	1076	break;
dvander@143	1077	}
dvander@143	1078
dvander@152	1079	case OP_GETFIELD:
dvander@152	1080	{
dvander@152	1081	Struct *obj = Struct::cast(top.sp[-1].obj);
dvander@152	1082	GetField(obj, READ_UINT32(top.pc), &top.sp[-1]);
dvander@152	1083	break;
dvander@152	1084	}
dvander@152	1085
dvander@152	1086	case OP_SETFIELD:
dvander@152	1087	{
dvander@152	1088	Struct *obj = Struct::cast(top.sp[-2].obj);
dvander@152	1089	SetField(zone, obj, READ_UINT32(top.pc), top.sp[-1]);
dvander@152	1090	top.sp[-2] = top.sp[-1];
dvander@152	1091	top.sp--;
dvander@152	1092	break;
dvander@152	1093	}
dvander@152	1094
dvander@152	1095	case OP_COPYSTRUCT:
dvander@152	1096	{
dvander@178	1097	Local<Struct> left(zone, Struct::cast(top.sp[-2].obj));
dvander@178	1098	Local<Struct> right(zone, Struct::cast(top.sp[-1].obj));
dvander@178	1099	if (!CopyStruct(zone, left, right))
dvander@152	1100	goto error;
dvander@152	1101	top.sp[-2].obj = top.sp[-1].obj;
dvander@152	1102	top.sp--;
dvander@152	1103	break;
dvander@152	1104	}
dvander@152	1105
dvander@172	1106	case OP_TABLESWITCH:
dvander@172	1107	{
dvander@172	1108	int value = top.sp[-1].i32;
dvander@172	1109	int low = READ_TABLESWITCH_LOW(top.pc);
dvander@172	1110	int high = READ_TABLESWITCH_HIGH(top.pc);
dvander@172	1111
dvander@172	1112	top.sp--;
dvander@172	1113
dvander@172	1114	unsigned index = unsigned(value - low);
dvander@172	1115	unsigned tablesize = TableSwitchEntries(low, high);
dvander@172	1116	if (index < tablesize) {
dvander@172	1117	top.pc += OP_TABLESWITCH_LENGTH + OP_JUMP_LENGTH;
dvander@172	1118	top.pc += index * OP_JUMP_LENGTH;
dvander@172	1119	continue;
dvander@172	1120	}
dvander@172	1121	break;
dvander@172	1122	}
dvander@172	1123
dvander@0	1124	default:
dvander@0	1125	assert(false);
dvander@0	1126	return false;
dvander@0	1127
dvander@0	1128	}
dvander@0	1129
dvander@0	1130	top.pc += OpcodeInfo[op].length;
dvander@174	1131	assert(top.sp >= top.fp->stackBase());
dvander@0	1132	}
dvander@0	1133
dvander@69	1134	done:
dvander@0	1135	return true;
dvander@69	1136
dvander@69	1137	error:
dvander@69	1138	// Unwind frames until we can continue.
dvander@69	1139	while (top.fp != entryFrame)
dvander@69	1140	zone->stack().popInlineFrame();
dvander@69	1141	return false;
dvander@0	1142	}

author	David Anderson <dvander@alliedmods.net>
	Thu Sep 13 23:52:25 2012 -0700 (2012-09-13)
changeset 178	9efe9a1456fd
parent 174	e718b56aba78
child 179	5f3c91fa6058
permissions	-rw-r--r--