sourcepawn2: src/Interpreter.cpp@b7d14a8b918e (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@195	29	#include "NativeTable.h"
dvander@28	30	#include "Heap-inl.h"
dvander@0	31
dvander@59	32	using namespace ke;
dvander@0	33
dvander@0	34	#define PUSH_I32(top, value) \
dvander@0	35	do { \
dvander@0	36	top.sp->i32 = value; \
dvander@0	37	top.sp++; \
dvander@0	38	} while (0)
dvander@0	39
dvander@4	40	#define PUSH_F(top, value) \
dvander@4	41	do { \
dvander@4	42	top.sp->f = value; \
dvander@4	43	top.sp++; \
dvander@4	44	} while (0)
dvander@4	45
dvander@0	46	static inline int
dvander@0	47	POP_I32(Top &top)
dvander@0	48	{
dvander@0	49	int value = top.sp[-1].i32;
dvander@0	50	top.sp--;
dvander@0	51	return value;
dvander@0	52	}
dvander@0	53
dvander@4	54	static inline float
dvander@4	55	POP_F(Top &top)
dvander@4	56	{
dvander@4	57	float value = top.sp[-1].f;
dvander@4	58	top.sp--;
dvander@4	59	return value;
dvander@4	60	}
dvander@4	61
dvander@77	62	// Pawn's original semantics specify some kind of floor operation, so
dvander@77	63	// (8 / -3 == -3) and (-8 / 3 == -1). The SourcePawn 1 compiler (spcomp) uses
dvander@77	64	// the upstream algorithm when constant folding. However the SourcePawn 1 JIT
dvander@77	65	// does not. My guess is that Borja freaked out seeing the 13-instruction x86
dvander@77	66	// sequence necessary to get this functionality (I vaguely recall a thread
dvander@77	67	// where we discussed this with Mark Peter? But the ITB forums are gone...),
dvander@77	68	// and we just decided to break the damn thing. So SP1 was inconsistent, but
dvander@77	69	// we are not. And for completeness, we assert that the C compiler does the
dvander@77	70	// right thing, since C89 leaves it unspecified.
dvander@77	71	STATIC_ASSERT(8 / -3 == -2);
dvander@77	72	STATIC_ASSERT(-8 / 3 == -2);
dvander@77	73
dvander@0	74	static inline bool
dvander@14	75	PushNewRef(Zone zone, Top &top, void location, Heap::Tenure tenure)
dvander@14	76	{
dvander@14	77	Reference *ref = Reference::NewStack(zone, location, tenure);
dvander@14	78	if (!ref)
dvander@14	79	return false;
dvander@14	80	top.sp->ref = ref;
dvander@14	81	top.sp++;
dvander@14	82	return true;
dvander@14	83	}
dvander@14	84
dvander@152	85	static void
dvander@157	86	GetElement(Array array, int index, LocalSlot vp)
dvander@157	87	{
dvander@157	88	if (array->type()->contained()->isTraceable()) {
dvander@157	89	vp->obj = array->readObject(index);
dvander@157	90	return;
dvander@157	91	}
dvander@157	92
dvander@157	93	switch (array->type()->contained()->pod()) {
dvander@157	94	case PrimitiveType_Float:
dvander@157	95	vp->f = array->readFloat(index);
dvander@157	96	break;
dvander@157	97
dvander@157	98	case PrimitiveType_Char:
dvander@157	99	vp->i32 = array->readChar(index);
dvander@157	100	break;
dvander@157	101
dvander@157	102	default:
dvander@157	103	assert(array->type()->contained()->pod() == PrimitiveType_Int32);
dvander@157	104	vp->i32 = array->readInt32(index);
dvander@157	105	break;
dvander@157	106	}
dvander@157	107	}
dvander@157	108
dvander@157	109	static void
dvander@157	110	SetElement(Zone zone, Array array, int index, const LocalSlot &v)
dvander@157	111	{
dvander@157	112	if (array->type()->contained()->isTraceable()) {
dvander@157	113	array->writeObject(zone, index, v.obj);
dvander@157	114	return;
dvander@157	115	}
dvander@157	116
dvander@157	117	switch (array->type()->contained()->pod()) {
dvander@157	118	case PrimitiveType_Float:
dvander@157	119	array->writeFloat(index, v.f);
dvander@157	120	break;
dvander@157	121
dvander@157	122	case PrimitiveType_Char:
dvander@157	123	array->writeChar(index, v.i32);
dvander@157	124	break;
dvander@157	125
dvander@157	126	default:
dvander@157	127	assert(array->type()->contained()->pod() == PrimitiveType_Int32);
dvander@157	128	array->writeInt32(index, v.i32);
dvander@157	129	break;
dvander@157	130	}
dvander@157	131	}
dvander@157	132
dvander@157	133	static void
dvander@196	134	FetchField(Struct obj, Descriptor desc, LocalSlot *vp)
dvander@152	135	{
dvander@152	136	// :TODO: assert no GC.
dvander@152	137	if (desc->type()->isTraceable()) {
dvander@152	138	vp->obj = obj->get<Object *>(desc);
dvander@157	139	return;
dvander@157	140	}
dvander@152	141
dvander@157	142	switch (desc->type()->pod()) {
dvander@157	143	case PrimitiveType_Float:
dvander@157	144	vp->f = obj->get<float>(desc);
dvander@157	145	break;
dvander@157	146
dvander@157	147	default:
dvander@157	148	assert(desc->type()->pod() == PrimitiveType_Int32);
dvander@157	149	vp->i32 = obj->get<int>(desc);
dvander@157	150	break;
dvander@152	151	}
dvander@152	152	}
dvander@152	153
dvander@152	154	static void
dvander@152	155	GetField(Struct obj, unsigned index, LocalSlot vp)
dvander@152	156	{
dvander@195	157	StructType *type = StructType::cast(obj->map()->type());
dvander@195	158	Descriptor *desc = Descriptor::cast(type->fields()->at(index));
dvander@196	159	FetchField(obj, desc, vp);
dvander@195	160	}
dvander@195	161
dvander@195	162	static void
dvander@195	163	GetGlobal(Zone zone, Handle<Struct> obj, Handle<String> name, LocalSlot vp)
dvander@195	164	{
dvander@195	165	Local<StructType> type(zone, StructType::cast(obj->map()->type()));
dvander@195	166	Local<Descriptor> desc(zone, type->lookupField(name, NULL));
dvander@196	167	FetchField(obj, desc, vp);
dvander@152	168	}
dvander@152	169
dvander@152	170	static void
dvander@196	171	StoreField(Zone zone, Struct obj, Descriptor *desc, const LocalSlot &v)
dvander@152	172	{
dvander@152	173	// :TODO: assert no GC.
dvander@152	174	if (desc->type()->isTraceable()) {
dvander@152	175	obj->set(zone, desc, v.obj);
dvander@157	176	return;
dvander@157	177	}
dvander@152	178
dvander@157	179	switch (desc->type()->pod()) {
dvander@157	180	case PrimitiveType_Float:
dvander@157	181	obj->set<float>(desc, v.f);
dvander@157	182	break;
dvander@157	183
dvander@157	184	default:
dvander@157	185	assert(desc->type()->pod() == PrimitiveType_Int32);
dvander@157	186	obj->set<int>(desc, v.i32);
dvander@157	187	break;
dvander@152	188	}
dvander@152	189	}
dvander@152	190
dvander@152	191	static void
dvander@152	192	SetField(Zone zone, Struct obj, unsigned index, const LocalSlot &v)
dvander@152	193	{
dvander@195	194	StructType *type = StructType::cast(obj->map()->type());
dvander@195	195	Descriptor *desc = Descriptor::cast(type->fields()->at(index));
dvander@196	196	StoreField(zone, obj, desc, v);
dvander@195	197	}
dvander@195	198
dvander@195	199	static void
dvander@195	200	SetGlobal(Zone *zone, Handle<Struct> obj, Handle<String> name, LocalSlot &v)
dvander@195	201	{
dvander@195	202	Local<StructType> type(zone, StructType::cast(obj->map()->type()));
dvander@195	203	Local<Descriptor> desc(zone, type->lookupField(name, NULL));
dvander@196	204	StoreField(zone, obj, desc, v);
dvander@152	205	}
dvander@152	206
dvander@68	207	static bool
dvander@68	208	InvokeNative(Zone zone, Handle<Native> native, void identity, LocalSlot *args, unsigned argc,
dvander@68	209	int *result)
dvander@68	210	{
dvander@68	211	NativeArgs guard;
dvander@68	212
dvander@195	213	void *address = zone->nativeTable()->address(native->index());
dvander@195	214	if (!address) {
dvander@195	215	Local<String> name(zone, zone->nativeTable()->name(native->index()));
dvander@195	216	zone->reportError(Message_NativeNotBound, name->chars());
dvander@195	217	return false;
dvander@195	218	}
dvander@195	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@195	229	Local<FunctionType> 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@188	242	cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->bytes());
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@188	254	cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->bytes());
dvander@68	255	}
dvander@68	256	}
dvander@68	257
dvander@68	258	typedef intptr_t (INVOKE)(void , intptr_t *);
dvander@195	259	INVOKE invoke = (INVOKE)address;
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@174	276
dvander@174	277	if (OpcodeInfo[op].nuses > 0)
dvander@174	278	assert(top.sp - OpcodeInfo[op].nuses >= top.fp->stackBase());
dvander@174	279
dvander@0	280	switch (op) {
dvander@0	281
dvander@0	282	case OP_NOP:
dvander@0	283	break;
dvander@0	284
dvander@0	285	case OP_INT:
dvander@0	286	PUSH_I32(top, READ_INT32(top.pc));
dvander@0	287	break;
dvander@0	288
dvander@4	289	case OP_FLOAT:
dvander@4	290	PUSH_F(top, READ_FLOAT(top.pc));
dvander@4	291	break;
dvander@4	292
dvander@0	293	case OP_RETURN:
dvander@72	294	case OP_RETURNVOID:
dvander@72	295	case OP_STOP:
dvander@0	296	{
dvander@72	297	if (op == OP_RETURN)
dvander@72	298	result = --top.sp;
dvander@72	299
dvander@69	300	if (top.fp == entryFrame)
dvander@69	301	goto done;
dvander@0	302
dvander@72	303	// This must not GC.
dvander@65	304	zone->stack().popInlineFrame();
dvander@47	305	locals = top.fp->locals();
dvander@72	306
dvander@72	307	if (op == OP_RETURN)
dvander@72	308	top.sp++ = result;
dvander@72	309
dvander@0	310	top.pc += OpcodeInfo[*top.pc].length;
dvander@0	311	continue;
dvander@0	312	}
dvander@0	313
dvander@80	314	case OP_POP:
dvander@80	315	{
dvander@80	316	top.sp--;
dvander@80	317	break;
dvander@80	318	}
dvander@80	319
dvander@0	320	case OP_JT:
dvander@0	321	{
dvander@0	322	int value = POP_I32(top);
dvander@0	323	if (value) {
dvander@0	324	top.pc += READ_INT32(top.pc);
dvander@0	325	continue;
dvander@0	326	}
dvander@0	327	break;
dvander@0	328	}
dvander@0	329
dvander@0	330	case OP_JF:
dvander@0	331	{
dvander@0	332	int value = POP_I32(top);
dvander@0	333	if (!value) {
dvander@0	334	top.pc += READ_INT32(top.pc);
dvander@0	335	continue;
dvander@0	336	}
dvander@0	337	break;
dvander@0	338	}
dvander@0	339
dvander@0	340	case OP_JUMP:
dvander@230	341	{
dvander@0	342	top.pc += READ_INT32(top.pc);
dvander@0	343	continue;
dvander@230	344	}
dvander@230	345
dvander@230	346	case OP_BREAK:
dvander@230	347	case OP_CONTINUE:
dvander@230	348	{
dvander@230	349	top.fp->leaveLoop(zone);
dvander@230	350	top.pc += READ_INT32(top.pc);
dvander@230	351	continue;
dvander@230	352	}
dvander@0	353
dvander@0	354	case OP_GETLOCAL:
dvander@0	355	{
dvander@195	356	unsigned slot = READ_UINT32(top.pc);
dvander@195	357	assert(slot < top.fp->code()->nlocals());
dvander@0	358	*top.sp++ = locals[slot];
dvander@0	359	break;
dvander@0	360	}
dvander@0	361
dvander@0	362	case OP_SETLOCAL:
dvander@0	363	{
dvander@195	364	unsigned slot = READ_UINT32(top.pc);
dvander@195	365	assert(slot < top.fp->code()->nlocals());
dvander@0	366	locals[slot] = top.sp[-1];
dvander@0	367	break;
dvander@0	368	}
dvander@0	369
dvander@0	370	case OP_ADD:
dvander@0	371	{
dvander@77	372	top.sp[-2].i32 = top.sp[-2].i32 + top.sp[-1].i32;
dvander@77	373	top.sp--;
dvander@0	374	break;
dvander@0	375	}
dvander@0	376
dvander@0	377	case OP_SUB:
dvander@0	378	{
dvander@77	379	top.sp[-2].i32 = top.sp[-2].i32 - top.sp[-1].i32;
dvander@77	380	top.sp--;
dvander@0	381	break;
dvander@0	382	}
dvander@0	383
dvander@0	384	case OP_MUL:
dvander@0	385	{
dvander@77	386	top.sp[-2].i32 = top.sp[-2].i32 * top.sp[-1].i32;
dvander@77	387	top.sp--;
dvander@0	388	break;
dvander@0	389	}
dvander@0	390
dvander@0	391	case OP_DIV:
dvander@0	392	{
dvander@77	393	if (top.sp[-1].i32 == 0) {
dvander@69	394	zone->reportError(Message_IntegerDivideByZero);
dvander@69	395	goto error;
dvander@69	396	}
dvander@77	397	top.sp[-2].i32 = top.sp[-2].i32 / top.sp[-1].i32;
dvander@77	398	top.sp--;
dvander@0	399	break;
dvander@0	400	}
dvander@0	401
dvander@82	402	case OP_MOD:
dvander@82	403	{
dvander@82	404	if (top.sp[-1].i32 == 0) {
dvander@82	405	zone->reportError(Message_IntegerDivideByZero);
dvander@82	406	goto error;
dvander@82	407	}
dvander@82	408	top.sp[-2].i32 = top.sp[-2].i32 % top.sp[-1].i32;
dvander@82	409	top.sp--;
dvander@82	410	break;
dvander@82	411	}
dvander@82	412
dvander@74	413	case OP_LT:
dvander@74	414	{
dvander@74	415	top.sp[-2].i32 = top.sp[-2].i32 < top.sp[-1].i32;
dvander@74	416	top.sp--;
dvander@74	417	break;
dvander@74	418	}
dvander@74	419
dvander@74	420	case OP_LE:
dvander@74	421	{
dvander@74	422	top.sp[-2].i32 = top.sp[-2].i32 <= top.sp[-1].i32;
dvander@74	423	top.sp--;
dvander@74	424	break;
dvander@74	425	}
dvander@74	426
dvander@74	427	case OP_GT:
dvander@74	428	{
dvander@74	429	top.sp[-2].i32 = top.sp[-2].i32 > top.sp[-1].i32;
dvander@74	430	top.sp--;
dvander@74	431	break;
dvander@74	432	}
dvander@74	433
dvander@74	434	case OP_GE:
dvander@74	435	{
dvander@74	436	top.sp[-2].i32 = top.sp[-2].i32 >= top.sp[-1].i32;
dvander@74	437	top.sp--;
dvander@74	438	break;
dvander@74	439	}
dvander@74	440
dvander@74	441	case OP_EQ:
dvander@74	442	{
dvander@74	443	top.sp[-2].i32 = (top.sp[-2].i32 == top.sp[-1].i32);
dvander@74	444	top.sp--;
dvander@74	445	break;
dvander@74	446	}
dvander@74	447
dvander@74	448	case OP_NE:
dvander@74	449	{
dvander@74	450	top.sp[-2].i32 = (top.sp[-2].i32 != top.sp[-1].i32);
dvander@74	451	top.sp--;
dvander@74	452	break;
dvander@74	453	}
dvander@74	454
dvander@4	455	case OP_ADD_F:
dvander@4	456	{
dvander@77	457	top.sp[-2].f = top.sp[-2].f + top.sp[-1].f;
dvander@77	458	top.sp--;
dvander@4	459	break;
dvander@4	460	}
dvander@4	461
dvander@4	462	case OP_SUB_F:
dvander@4	463	{
dvander@77	464	top.sp[-2].f = top.sp[-2].f - top.sp[-1].f;
dvander@77	465	top.sp--;
dvander@4	466	break;
dvander@4	467	}
dvander@4	468
dvander@4	469	case OP_MUL_F:
dvander@4	470	{
dvander@77	471	top.sp[-2].f = top.sp[-2].f * top.sp[-1].f;
dvander@77	472	top.sp--;
dvander@4	473	break;
dvander@4	474	}
dvander@4	475
dvander@4	476	case OP_DIV_F:
dvander@4	477	{
dvander@77	478	top.sp[-2].f = top.sp[-2].f / top.sp[-1].f;
dvander@77	479	top.sp--;
dvander@4	480	break;
dvander@4	481	}
dvander@4	482
dvander@74	483	case OP_LT_F:
dvander@74	484	{
dvander@74	485	top.sp[-2].f = top.sp[-2].f < top.sp[-1].f;
dvander@74	486	top.sp--;
dvander@74	487	break;
dvander@74	488	}
dvander@74	489
dvander@74	490	case OP_LE_F:
dvander@74	491	{
dvander@74	492	top.sp[-2].f = top.sp[-2].f <= top.sp[-1].f;
dvander@74	493	top.sp--;
dvander@74	494	break;
dvander@74	495	}
dvander@74	496
dvander@74	497	case OP_GT_F:
dvander@74	498	{
dvander@74	499	top.sp[-2].f = top.sp[-2].f > top.sp[-1].f;
dvander@74	500	top.sp--;
dvander@74	501	break;
dvander@74	502	}
dvander@74	503
dvander@74	504	case OP_GE_F:
dvander@74	505	{
dvander@74	506	top.sp[-2].f = top.sp[-2].f >= top.sp[-1].f;
dvander@74	507	top.sp--;
dvander@74	508	break;
dvander@74	509	}
dvander@74	510
dvander@74	511	case OP_EQ_F:
dvander@74	512	{
dvander@74	513	top.sp[-2].i32 = (top.sp[-2].f == top.sp[-1].f);
dvander@74	514	top.sp--;
dvander@74	515	break;
dvander@74	516	}
dvander@74	517
dvander@74	518	case OP_NE_F:
dvander@74	519	{
dvander@74	520	top.sp[-2].i32 = (top.sp[-2].f != top.sp[-1].f);
dvander@74	521	top.sp--;
dvander@74	522	break;
dvander@74	523	}
dvander@74	524
dvander@8	525	case OP_SHL:
dvander@8	526	{
dvander@77	527	top.sp[-2].i32 = top.sp[-2].i32 << top.sp[-1].i32;
dvander@77	528	top.sp--;
dvander@8	529	break;
dvander@8	530	}
dvander@8	531
dvander@8	532	case OP_SHR:
dvander@8	533	{
dvander@77	534	top.sp[-2].i32 = top.sp[-2].i32 >> top.sp[-1].i32;
dvander@77	535	top.sp--;
dvander@8	536	break;
dvander@8	537	}
dvander@8	538
dvander@8	539	case OP_USHR:
dvander@8	540	{
dvander@207	541	top.sp[-2].i32 = unsigned(top.sp[-2].i32) >> unsigned(top.sp[-1].i32);
dvander@77	542	top.sp--;
dvander@8	543	break;
dvander@8	544	}
dvander@8	545
dvander@8	546	case OP_BITAND:
dvander@8	547	{
dvander@77	548	top.sp[-2].i32 = top.sp[-2].i32 & top.sp[-1].i32;
dvander@77	549	top.sp--;
dvander@8	550	break;
dvander@8	551	}
dvander@8	552
dvander@8	553	case OP_BITOR:
dvander@8	554	{
dvander@77	555	top.sp[-2].i32 = top.sp[-2].i32 \| top.sp[-1].i32;
dvander@77	556	top.sp--;
dvander@8	557	break;
dvander@8	558	}
dvander@8	559
dvander@8	560	case OP_BITXOR:
dvander@8	561	{
dvander@77	562	top.sp[-2].i32 = top.sp[-2].i32 ^ top.sp[-1].i32;
dvander@77	563	top.sp--;
dvander@8	564	break;
dvander@8	565	}
dvander@8	566
dvander@78	567	case OP_BITNOT:
dvander@78	568	{
dvander@78	569	top.sp[-1].i32 = ~top.sp[-1].i32;
dvander@78	570	break;
dvander@78	571	}
dvander@78	572
dvander@79	573	case OP_NOT:
dvander@79	574	{
dvander@79	575	top.sp[-1].i32 = top.sp[-1].i32 ? 0 : 1;
dvander@79	576	break;
dvander@79	577	}
dvander@79	578
dvander@79	579	case OP_NOT_F:
dvander@79	580	{
dvander@79	581	top.sp[-1].i32 = top.sp[-1].f ? 0 : 1;
dvander@79	582	break;
dvander@79	583	}
dvander@79	584
dvander@80	585	case OP_NEG:
dvander@79	586	{
dvander@80	587	top.sp[-1].i32 = -top.sp[-1].i32;
dvander@80	588	break;
dvander@80	589	}
dvander@80	590
dvander@80	591	case OP_NEG_F:
dvander@80	592	{
dvander@80	593	top.sp[-1].f = -top.sp[-1].f;
dvander@0	594	break;
dvander@79	595	}
dvander@0	596
dvander@73	597	case OP_CALL:
dvander@0	598	{
dvander@195	599	Local<Function> newFun(zone, Function::cast(top.sp[-1].obj));
dvander@73	600	top.sp--;
dvander@73	601
dvander@69	602	if (!zone->stack().pushInlineFrame(newFun))
dvander@69	603	goto error;
dvander@0	604
dvander@47	605	locals = top.fp->locals();
dvander@0	606	continue;
dvander@0	607	}
dvander@0	608
dvander@0	609	case OP_GETARG:
dvander@0	610	{
dvander@0	611	unsigned slot = READ_UINT32(top.pc);
dvander@47	612	*top.sp++ = top.fp->arg(slot);
dvander@0	613	break;
dvander@0	614	}
dvander@0	615
dvander@0	616	case OP_SETARG:
dvander@0	617	{
dvander@0	618	unsigned slot = READ_UINT32(top.pc);
dvander@174	619	top.fp->arg(slot) = top.sp[-1];
dvander@0	620	break;
dvander@0	621	}
dvander@0	622
dvander@158	623	case OP_GETELEM:
dvander@0	624	{
dvander@158	625	Array *array = Array::cast(top.sp[-2].obj);
dvander@0	626	int index = top.sp[-1].i32;
dvander@158	627
dvander@155	628	if (index < 0 \|\| unsigned(index) >= array->length()) {
dvander@155	629	zone->reportError(Message_ArrayIndexOutOfBounds, index, array->length());
dvander@69	630	goto error;
dvander@69	631	}
dvander@0	632
dvander@157	633	GetElement(array, index, &top.sp[-2]);
dvander@21	634	top.sp--;
dvander@21	635	break;
dvander@21	636	}
dvander@21	637
dvander@157	638	case OP_SETELEM:
dvander@0	639	{
dvander@157	640	Array *array = Array::cast(top.sp[-3].obj);
dvander@0	641	int index = top.sp[-2].i32;
dvander@158	642
dvander@158	643	if (index < 0 \|\| unsigned(index) >= array->length()) {
dvander@158	644	zone->reportError(Message_ArrayIndexOutOfBounds, index, array->length());
dvander@158	645	goto error;
dvander@158	646	}
dvander@158	647
dvander@157	648	SetElement(zone, array, index, top.sp[-1]);
dvander@7	649	top.sp[-3] = top.sp[-1];
dvander@7	650	top.sp -= 2;
dvander@7	651	break;
dvander@7	652	}
dvander@7	653
dvander@4	654	case OP_CVT_I2F:
dvander@4	655	{
dvander@4	656	int ival = POP_I32(top);
dvander@4	657	float fval = (float)ival;
dvander@4	658	PUSH_F(top, fval);
dvander@4	659	break;
dvander@4	660	}
dvander@4	661
dvander@208	662	case OP_CVT_I2B:
dvander@208	663	{
dvander@208	664	top.sp[-1].i32 = !!top.sp[-1].i32;
dvander@208	665	break;
dvander@208	666	}
dvander@208	667
dvander@234	668	case OP_DUPARRAY:
dvander@234	669	{
dvander@234	670	Local<Array> src(zone, Array::cast(top.sp[-1].obj));
dvander@234	671	top.sp[-1].obj = Array::DeepCopy(zone, src, Heap::Tenure_Default);
dvander@234	672	if (!top.sp[-1].obj)
dvander@234	673	goto error;
dvander@234	674	break;
dvander@234	675	}
dvander@234	676
dvander@185	677	case OP_NEWFIXED:
dvander@12	678	{
dvander@85	679	Heap::Tenure tenure = (Heap::Tenure)top.pc[1];
dvander@85	680	Local<ArrayMap> map(zone, ArrayMap::cast(top.fp->code()->map(READ_UINT32(top.pc + 1))));
dvander@187	681	Array *array = Array::NewFixed(zone, map, tenure);
dvander@185	682	if (!array)
dvander@185	683	goto error;
dvander@185	684	top.sp->obj = array;
dvander@185	685	top.sp++;
dvander@185	686	break;
dvander@185	687	}
dvander@185	688
dvander@185	689	case OP_NEWEMPTY:
dvander@185	690	{
dvander@185	691	Heap::Tenure tenure = (Heap::Tenure)top.pc[1];
dvander@185	692	Local<ArrayMap> map(zone, ArrayMap::cast(top.fp->code()->map(READ_UINT32(top.pc + 1))));
dvander@187	693	Array *array = Array::NewEmpty(zone, map, tenure);
dvander@187	694	if (!array)
dvander@187	695	goto error;
dvander@187	696	top.sp->obj = array;
dvander@187	697	top.sp++;
dvander@187	698	break;
dvander@187	699	}
dvander@187	700
dvander@187	701	case OP_NEWSIZED:
dvander@187	702	{
dvander@187	703	Heap::Tenure tenure = (Heap::Tenure)top.pc[1];
dvander@187	704	Local<ArrayMap> map(zone, ArrayMap::cast(top.fp->code()->map(READ_UINT32(top.pc + 1))));
dvander@187	705	assert(map->type()->levels() < MAX_ARRAY_DEPTH);
dvander@187	706
dvander@187	707	int dims[MAX_ARRAY_DEPTH];
dvander@187	708	for (unsigned i = map->type()->levels() - 1; i < map->type()->levels(); i--)
dvander@187	709	dims[i] = POP_I32(top);
dvander@187	710
dvander@187	711	Array *array = Array::NewSized(zone, map, dims, tenure);
dvander@69	712	if (!array)
dvander@69	713	goto error;
dvander@12	714	top.sp->obj = array;
dvander@12	715	top.sp++;
dvander@12	716	break;
dvander@12	717	}
dvander@12	718
dvander@147	719	case OP_NEWSTRUCT:
dvander@147	720	{
dvander@147	721	Heap::Tenure tenure = (Heap::Tenure)top.pc[1];
dvander@147	722	Local<StructMap> map(zone, StructMap::cast(top.fp->code()->map(READ_UINT32(top.pc + 1))));
dvander@147	723	top.sp->obj = Struct::New(zone, map, tenure);
dvander@147	724	if (!top.sp->obj)
dvander@147	725	goto error;
dvander@147	726	top.sp++;
dvander@147	727	break;
dvander@147	728	}
dvander@147	729
dvander@12	730	case OP_SAVELIFO:
dvander@10	731	{
dvander@10	732	unsigned slot = READ_UINT32(top.pc);
dvander@42	733	locals[slot].address = zone->heap().lifoPosition();
dvander@12	734	break;
dvander@12	735	}
dvander@12	736
dvander@12	737	case OP_UNWINDLIFO:
dvander@12	738	{
dvander@12	739	unsigned slot = READ_UINT32(top.pc);
dvander@42	740	zone->heap().unwindLifo(locals[slot].address);
dvander@10	741	break;
dvander@10	742	}
dvander@10	743
dvander@14	744	case OP_VARREF_LIFO:
dvander@14	745	{
dvander@14	746	unsigned slot = READ_UINT32(top.pc);
dvander@69	747	if (!PushNewRef(zone, top, &locals[slot], Heap::Tenure_Stack))
dvander@69	748	goto error;
dvander@14	749	break;
dvander@14	750	}
dvander@14	751
dvander@14	752	case OP_ARGREF_LIFO:
dvander@14	753	{
dvander@14	754	unsigned slot = READ_UINT32(top.pc);
dvander@69	755	if (!PushNewRef(zone, top, &top.fp->arg(slot), Heap::Tenure_Stack))
dvander@69	756	goto error;
dvander@14	757	break;
dvander@14	758	}
dvander@14	759
dvander@16	760	case OP_SLOTREF_LIFO:
dvander@16	761	{
dvander@42	762	Reference *ref = Reference::NewStack(zone, top.sp[-1], Heap::Tenure_Stack);
dvander@69	763	if (!ref)
dvander@69	764	goto error;
dvander@16	765	top.sp[-1].ref = ref;
dvander@16	766	break;
dvander@16	767	}
dvander@16	768
dvander@14	769	case OP_GETREF_I:
dvander@14	770	{
dvander@14	771	top.sp[-1].i32 = top.sp[-1].ref->getInt();
dvander@14	772	break;
dvander@14	773	}
dvander@14	774
dvander@14	775	case OP_SETREF_I:
dvander@14	776	{
dvander@14	777	top.sp[-2].ref->setInt(top.sp[-1].i32);
dvander@14	778	top.sp[-2].i32 = top.sp[-1].i32;
dvander@23	779	top.sp--;
dvander@14	780	break;
dvander@14	781	}
dvander@14	782
dvander@14	783	case OP_GETREF_F:
dvander@14	784	{
dvander@14	785	top.sp[-1].f = top.sp[-1].ref->getFloat();
dvander@14	786	break;
dvander@14	787	}
dvander@14	788
dvander@14	789	case OP_SETREF_F:
dvander@14	790	{
dvander@14	791	top.sp[-2].ref->setFloat(top.sp[-1].f);
dvander@14	792	top.sp[-2].f = top.sp[-1].f;
dvander@14	793	break;
dvander@14	794	}
dvander@14	795
dvander@21	796	case OP_OBJECT:
dvander@21	797	{
dvander@47	798	top.sp->obj = top.fp->code()->object(READ_UINT32(top.pc));
dvander@21	799	top.sp++;
dvander@21	800	break;
dvander@21	801	}
dvander@21	802
dvander@152	803	case OP_COPYARRAY:
dvander@21	804	{
dvander@21	805	// Note for this assignment opcode, we return the left-hand side, not the
dvander@21	806	// right, since in this case the result of the expression could be different.
dvander@178	807	Local<Array> left(zone, Array::cast(top.sp[-2].array));
dvander@178	808	Local<Array> right(zone, Array::cast(top.sp[-1].array));
dvander@234	809	if (!Array::ShallowCopy(zone, left, right))
dvander@69	810	goto error;
dvander@21	811	top.sp--;
dvander@21	812	break;
dvander@21	813	}
dvander@21	814
dvander@22	815	case OP_DUP:
dvander@22	816	{
dvander@23	817	top.sp++;
dvander@23	818	top.sp[-1] = top.sp[-2];
dvander@22	819	break;
dvander@22	820	}
dvander@22	821
dvander@22	822	case OP_DUP2:
dvander@22	823	{
dvander@23	824	top.sp += 2;
dvander@23	825	top.sp[-2] = top.sp[-4];
dvander@23	826	top.sp[-1] = top.sp[-3];
dvander@23	827	break;
dvander@23	828	}
dvander@23	829
dvander@23	830	case OP_SWAP:
dvander@23	831	{
dvander@23	832	LocalSlot slot = top.sp[-2];
dvander@23	833	top.sp[-2] = top.sp[-1];
dvander@23	834	top.sp[-1] = slot;
dvander@23	835	break;
dvander@23	836	}
dvander@23	837
dvander@23	838	case OP_ROLL3:
dvander@23	839	{
dvander@23	840	LocalSlot slot = top.sp[-3];
dvander@23	841	top.sp[-3] = top.sp[-2];
dvander@23	842	top.sp[-2] = top.sp[-1];
dvander@23	843	top.sp[-1] = slot;
dvander@23	844	break;
dvander@23	845	}
dvander@23	846
dvander@23	847	case OP_PICK2:
dvander@23	848	{
dvander@23	849	top.sp++;
dvander@23	850	top.sp[-1] = top.sp[-3];
dvander@23	851	break;
dvander@23	852	}
dvander@23	853
dvander@23	854	case OP_PICK3:
dvander@23	855	{
dvander@23	856	top.sp++;
dvander@23	857	top.sp[-1] = top.sp[-4];
dvander@22	858	break;
dvander@22	859	}
dvander@22	860
dvander@68	861	case OP_CALLNATIVE:
dvander@68	862	{
dvander@195	863	unsigned argc = READ_UINT32(top.pc);
dvander@68	864
dvander@195	865	Local<Native> native(zone, Native::cast(top.sp[-1].obj));
dvander@195	866	top.sp--;
dvander@68	867
dvander@68	868	int result;
dvander@68	869	void *nativeIdentity = top.fp->code()->module()->nativeIdentity();
dvander@69	870	if (!InvokeNative(zone, native, nativeIdentity, top.sp, argc, &result))
dvander@69	871	goto error;
dvander@68	872
dvander@68	873	top.sp -= argc;
dvander@68	874	PUSH_I32(top, result);
dvander@68	875	break;
dvander@68	876	}
dvander@68	877
dvander@142	878	case OP_BITS_I2F:
dvander@142	879	case OP_BITS_F2I:
dvander@142	880	{
dvander@142	881	// Because the stack is a union, these are actually no-ops in the
dvander@142	882	// interpreter.
dvander@142	883	break;
dvander@142	884	}
dvander@142	885
dvander@143	886	case OP_TRUE:
dvander@143	887	{
dvander@143	888	top.sp++;
dvander@143	889	top.sp[-1].i32 = 1;
dvander@143	890	break;
dvander@143	891	}
dvander@143	892
dvander@143	893	case OP_FALSE:
dvander@143	894	{
dvander@143	895	top.sp++;
dvander@143	896	top.sp[-1].i32 = 0;
dvander@143	897	break;
dvander@143	898	}
dvander@143	899
dvander@152	900	case OP_GETFIELD:
dvander@152	901	{
dvander@152	902	Struct *obj = Struct::cast(top.sp[-1].obj);
dvander@152	903	GetField(obj, READ_UINT32(top.pc), &top.sp[-1]);
dvander@152	904	break;
dvander@152	905	}
dvander@152	906
dvander@152	907	case OP_SETFIELD:
dvander@152	908	{
dvander@152	909	Struct *obj = Struct::cast(top.sp[-2].obj);
dvander@152	910	SetField(zone, obj, READ_UINT32(top.pc), top.sp[-1]);
dvander@152	911	top.sp[-2] = top.sp[-1];
dvander@152	912	top.sp--;
dvander@152	913	break;
dvander@152	914	}
dvander@152	915
dvander@152	916	case OP_COPYSTRUCT:
dvander@152	917	{
dvander@178	918	Local<Struct> left(zone, Struct::cast(top.sp[-2].obj));
dvander@178	919	Local<Struct> right(zone, Struct::cast(top.sp[-1].obj));
dvander@234	920	if (!Struct::Copy(zone, left, right))
dvander@152	921	goto error;
dvander@152	922	top.sp[-2].obj = top.sp[-1].obj;
dvander@152	923	top.sp--;
dvander@152	924	break;
dvander@152	925	}
dvander@152	926
dvander@172	927	case OP_TABLESWITCH:
dvander@172	928	{
dvander@172	929	int value = top.sp[-1].i32;
dvander@172	930	int low = READ_TABLESWITCH_LOW(top.pc);
dvander@172	931	int high = READ_TABLESWITCH_HIGH(top.pc);
dvander@172	932
dvander@172	933	top.sp--;
dvander@172	934
dvander@172	935	unsigned index = unsigned(value - low);
dvander@172	936	unsigned tablesize = TableSwitchEntries(low, high);
dvander@172	937	if (index < tablesize) {
dvander@172	938	top.pc += OP_TABLESWITCH_LENGTH + OP_JUMP_LENGTH;
dvander@172	939	top.pc += index * OP_JUMP_LENGTH;
dvander@172	940	continue;
dvander@172	941	}
dvander@172	942	break;
dvander@172	943	}
dvander@172	944
dvander@194	945	case OP_SIZEOF:
dvander@194	946	{
dvander@194	947	Array *array = Array::cast(top.sp[-1].obj);
dvander@194	948	top.sp[-1].i32 = array->length();
dvander@194	949	break;
dvander@194	950	}
dvander@194	951
dvander@195	952	case OP_PUBLIC:
dvander@195	953	{
dvander@195	954	Local<Function> fun(zone, Function::cast(top.sp[-1].obj));
dvander@195	955	zone->registerPublic(fun);
dvander@195	956	top.sp--;
dvander@195	957	break;
dvander@195	958	}
dvander@195	959
dvander@195	960	case OP_SETGLOBAL:
dvander@195	961	{
dvander@195	962	Local<Code> code(zone, top.fp->code());
dvander@195	963	Local<Struct> obj(zone, code->module()->globals());
dvander@195	964	Local<String> name(zone, String::cast(code->strings()->at(READ_UINT32(top.pc))));
dvander@195	965	SetGlobal(zone, obj, name, top.sp[-1]);
dvander@195	966	break;
dvander@195	967	}
dvander@195	968
dvander@195	969	case OP_GETGLOBAL:
dvander@195	970	{
dvander@195	971	Local<Code> code(zone, top.fp->code());
dvander@195	972	Local<Struct> obj(zone, code->module()->globals());
dvander@195	973	Local<String> name(zone, String::cast(code->strings()->at(READ_UINT32(top.pc))));
dvander@195	974	GetGlobal(zone, obj, name, top.sp);
dvander@195	975	top.sp++;
dvander@195	976	break;
dvander@195	977	}
dvander@195	978
dvander@230	979	case OP_ENTERLOOP:
dvander@230	980	{
dvander@230	981	top.fp->enterLoop(zone);
dvander@230	982	break;
dvander@230	983	}
dvander@230	984
dvander@230	985	case OP_LEAVELOOP:
dvander@230	986	{
dvander@230	987	top.fp->leaveLoop(zone);
dvander@230	988	break;
dvander@230	989	}
dvander@230	990
dvander@0	991	default:
dvander@0	992	assert(false);
dvander@0	993	return false;
dvander@0	994
dvander@0	995	}
dvander@0	996
dvander@0	997	top.pc += OpcodeInfo[op].length;
dvander@174	998	assert(top.sp >= top.fp->stackBase());
dvander@0	999	}
dvander@0	1000
dvander@69	1001	done:
dvander@0	1002	return true;
dvander@69	1003
dvander@69	1004	error:
dvander@69	1005	// Unwind frames until we can continue.
dvander@69	1006	while (top.fp != entryFrame)
dvander@69	1007	zone->stack().popInlineFrame();
dvander@69	1008	return false;
dvander@0	1009	}

author	David Anderson <dvander@alliedmods.net>
	Wed Dec 26 17:18:15 2012 -0800 (2012-12-26)
changeset 242	b7d14a8b918e
parent 236	072f1114ea5d
child 245	9371f058625a
permissions	-rw-r--r--