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

author	David Anderson <dvander@alliedmods.net>
	Sat Aug 04 23:26:49 2012 -0700 (2012-08-04)
changeset 152	153d0cafc1fd
parent 147	9c544823d090
child 154	a85a0303bcb8
permissions	-rw-r--r--