sourcepawn2: src/Interpreter.cpp@23189d937087 (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@28	28	#include "Heap-inl.h"
dvander@0	29
dvander@59	30	using namespace ke;
dvander@0	31
dvander@0	32	#define PUSH_I32(top, value) \
dvander@0	33	do { \
dvander@0	34	top.sp->i32 = value; \
dvander@0	35	top.sp++; \
dvander@0	36	} while (0)
dvander@0	37
dvander@4	38	#define PUSH_F(top, value) \
dvander@4	39	do { \
dvander@4	40	top.sp->f = value; \
dvander@4	41	top.sp++; \
dvander@4	42	} while (0)
dvander@4	43
dvander@0	44	static inline int
dvander@0	45	POP_I32(Top &top)
dvander@0	46	{
dvander@0	47	int value = top.sp[-1].i32;
dvander@0	48	top.sp--;
dvander@0	49	return value;
dvander@0	50	}
dvander@0	51
dvander@4	52	static inline float
dvander@4	53	POP_F(Top &top)
dvander@4	54	{
dvander@4	55	float value = top.sp[-1].f;
dvander@4	56	top.sp--;
dvander@4	57	return value;
dvander@4	58	}
dvander@4	59
dvander@77	60	// Pawn's original semantics specify some kind of floor operation, so
dvander@77	61	// (8 / -3 == -3) and (-8 / 3 == -1). The SourcePawn 1 compiler (spcomp) uses
dvander@77	62	// the upstream algorithm when constant folding. However the SourcePawn 1 JIT
dvander@77	63	// does not. My guess is that Borja freaked out seeing the 13-instruction x86
dvander@77	64	// sequence necessary to get this functionality (I vaguely recall a thread
dvander@77	65	// where we discussed this with Mark Peter? But the ITB forums are gone...),
dvander@77	66	// and we just decided to break the damn thing. So SP1 was inconsistent, but
dvander@77	67	// we are not. And for completeness, we assert that the C compiler does the
dvander@77	68	// right thing, since C89 leaves it unspecified.
dvander@77	69	STATIC_ASSERT(8 / -3 == -2);
dvander@77	70	STATIC_ASSERT(-8 / 3 == -2);
dvander@77	71
dvander@0	72	static inline bool
dvander@14	73	PushNewRef(Zone zone, Top &top, void location, Heap::Tenure tenure)
dvander@14	74	{
dvander@14	75	Reference *ref = Reference::NewStack(zone, location, tenure);
dvander@14	76	if (!ref)
dvander@14	77	return false;
dvander@14	78	top.sp->ref = ref;
dvander@14	79	top.sp++;
dvander@14	80	return true;
dvander@14	81	}
dvander@14	82
dvander@12	83	// Generate an array with completely static sizes.
dvander@12	84	static Array *
dvander@85	85	GenerateArray(Zone *zone, Handle<ArrayMap> map, Heap::Tenure tenure)
dvander@0	86	{
dvander@12	87	assert(map->type()->elements() != -1);
dvander@0	88
dvander@85	89	Local<Array> array(zone, Array::New(zone, map, map->type()->elements(), tenure));
dvander@12	90	if (!array)
dvander@0	91	return NULL;
dvander@0	92
dvander@12	93	if (map->type()->levels() == 1)
dvander@12	94	return array;
dvander@0	95
dvander@27	96	Local<ArrayMap> contained(zone, map->contained());
dvander@43	97	Local<Array> sub(zone);
dvander@12	98	for (unsigned i = 0; i < unsigned(map->type()->elements()); i++) {
dvander@85	99	sub = GenerateArray(zone, contained, tenure);
dvander@12	100	if (!sub)
dvander@0	101	return NULL;
dvander@12	102	array->writeObject(zone, i, sub);
dvander@0	103	}
dvander@0	104
dvander@12	105	return array;
dvander@0	106	}
dvander@0	107
dvander@21	108	static bool
dvander@21	109	CopyArray(Zone zone, Array source, Array *dest)
dvander@21	110	{
dvander@21	111	assert(source->type()->levels() == 1);
dvander@21	112	assert(dest->type()->levels() == 1);
dvander@21	113	assert(source->type()->contained()->primitive() ==
dvander@21	114	dest->type()->contained()->primitive());
dvander@21	115	assert(source->nelements() >= dest->nelements());
dvander@21	116	assert(dest->elementSize() == source->elementSize());
dvander@21	117
dvander@21	118	memcpy(source->vec(), dest->vec(), dest->nelements() * dest->elementSize());
dvander@21	119	return true;
dvander@21	120	}
dvander@21	121
dvander@68	122	static bool
dvander@68	123	InvokeNative(Zone zone, Handle<Native> native, void identity, LocalSlot *args, unsigned argc,
dvander@68	124	int *result)
dvander@68	125	{
dvander@68	126	NativeArgs guard;
dvander@68	127
dvander@68	128	if (!zone->stack().pushNativeFrame(native, guard, argc + 1))
dvander@68	129	return false;
dvander@68	130
dvander@68	131	intptr_t *cells = guard.args();
dvander@68	132
dvander@68	133	// params[0] == argc, in ISPE
dvander@68	134	cells[0] = argc;
dvander@68	135
dvander@68	136	// Pass the formal arguments.
dvander@68	137	Local<Type> type(zone, native->type());
dvander@68	138	Local<Type> param(zone);
dvander@68	139	for (unsigned i = 0; i < type->parameters()->length(); i++) {
dvander@68	140	param = type->parameterAt(i);
dvander@68	141
dvander@68	142	// For floats, we rely on the aliasing of \|i32\| and \|f\|.
dvander@68	143	LocalSlot &arg = args[-int(i) - 1];
dvander@68	144	if (param->isInt32() \|\| param->isFloat()) {
dvander@68	145	cells[i + 1] = arg.i32;
dvander@68	146	} else if (param->isReference()) {
dvander@68	147	cells[i + 1] = reinterpret_cast<intptr_t>(arg.ref->location());
dvander@68	148	} else {
dvander@68	149	assert(param->isArray());
dvander@68	150	cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->vec());
dvander@68	151	}
dvander@68	152	}
dvander@68	153
dvander@68	154	// For variadic arguments, the compiler left either arrays or references.
dvander@68	155	for (unsigned i = type->parameters()->length(); i < argc; i++) {
dvander@68	156	LocalSlot &arg = args[-int(i) - 1];
dvander@68	157
dvander@68	158	if (arg.obj->is(MapKind_Reference)) {
dvander@68	159	cells[i + 1] = reinterpret_cast<intptr_t>(arg.ref->location());
dvander@68	160	} else {
dvander@68	161	assert(arg.obj->is(MapKind_Array));
dvander@68	162	cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->vec());
dvander@68	163	}
dvander@68	164	}
dvander@68	165
dvander@68	166	typedef intptr_t (INVOKE)(void , intptr_t *);
dvander@68	167	INVOKE invoke = (INVOKE)native->function();
dvander@68	168	*result = invoke(identity, cells);
dvander@68	169
dvander@69	170	return !zone->hasPendingException();
dvander@68	171	}
dvander@68	172
dvander@0	173	bool
dvander@59	174	ke::Interpret(Zone zone, Frame entryFrame, LocalSlot *result)
dvander@0	175	{
dvander@42	176	Top &top = *zone->stack().top();
dvander@69	177	if (!entryFrame)
dvander@69	178	entryFrame = top.fp;
dvander@69	179
dvander@47	180	LocalSlot *locals = entryFrame->locals();
dvander@0	181
dvander@0	182	for (;;) {
dvander@0	183	Opcode op = Opcode(*top.pc);
dvander@0	184	switch (op) {
dvander@0	185
dvander@0	186	case OP_NOP:
dvander@0	187	break;
dvander@0	188
dvander@0	189	case OP_INT:
dvander@0	190	PUSH_I32(top, READ_INT32(top.pc));
dvander@0	191	break;
dvander@0	192
dvander@4	193	case OP_FLOAT:
dvander@4	194	PUSH_F(top, READ_FLOAT(top.pc));
dvander@4	195	break;
dvander@4	196
dvander@0	197	case OP_RETURN:
dvander@72	198	case OP_RETURNVOID:
dvander@72	199	case OP_STOP:
dvander@0	200	{
dvander@72	201	if (op == OP_RETURN)
dvander@72	202	result = --top.sp;
dvander@72	203
dvander@69	204	if (top.fp == entryFrame)
dvander@69	205	goto done;
dvander@0	206
dvander@72	207	// This must not GC.
dvander@65	208	zone->stack().popInlineFrame();
dvander@47	209	locals = top.fp->locals();
dvander@72	210
dvander@72	211	if (op == OP_RETURN)
dvander@72	212	top.sp++ = result;
dvander@72	213
dvander@0	214	top.pc += OpcodeInfo[*top.pc].length;
dvander@0	215	continue;
dvander@0	216	}
dvander@0	217
dvander@80	218	case OP_POP:
dvander@80	219	{
dvander@80	220	top.sp--;
dvander@80	221	break;
dvander@80	222	}
dvander@80	223
dvander@0	224	#define RELATIONAL_JUMP(op) \
dvander@0	225	{ \
dvander@0	226	int right = POP_I32(top); \
dvander@0	227	int left = POP_I32(top); \
dvander@0	228	if (left op right) { \
dvander@0	229	top.pc += READ_INT32(top.pc); \
dvander@0	230	continue; \
dvander@0	231	} \
dvander@0	232	}
dvander@0	233
dvander@0	234	case OP_JL:
dvander@0	235	RELATIONAL_JUMP(<);
dvander@0	236	break;
dvander@0	237
dvander@0	238	case OP_JLE:
dvander@0	239	RELATIONAL_JUMP(<=);
dvander@0	240	break;
dvander@0	241
dvander@0	242	case OP_JG:
dvander@0	243	RELATIONAL_JUMP(>);
dvander@0	244	break;
dvander@0	245
dvander@0	246	case OP_JGE:
dvander@0	247	RELATIONAL_JUMP(>=);
dvander@0	248	break;
dvander@0	249
dvander@0	250	case OP_JEQ:
dvander@0	251	RELATIONAL_JUMP(==);
dvander@0	252	break;
dvander@0	253
dvander@0	254	case OP_JNE:
dvander@0	255	RELATIONAL_JUMP(!=);
dvander@0	256	break;
dvander@0	257
dvander@74	258	#undef RELATIONAL_JUMP
dvander@74	259
dvander@0	260	case OP_JT:
dvander@0	261	{
dvander@0	262	int value = POP_I32(top);
dvander@0	263	if (value) {
dvander@0	264	top.pc += READ_INT32(top.pc);
dvander@0	265	continue;
dvander@0	266	}
dvander@0	267	break;
dvander@0	268	}
dvander@0	269
dvander@0	270	case OP_JF:
dvander@0	271	{
dvander@0	272	int value = POP_I32(top);
dvander@0	273	if (!value) {
dvander@0	274	top.pc += READ_INT32(top.pc);
dvander@0	275	continue;
dvander@0	276	}
dvander@0	277	break;
dvander@0	278	}
dvander@0	279
dvander@74	280	#define RELATIONAL_JUMP_F(op) \
dvander@74	281	{ \
dvander@74	282	float right = POP_F(top); \
dvander@74	283	float left = POP_F(top); \
dvander@74	284	if (left op right) { \
dvander@74	285	top.pc += READ_INT32(top.pc); \
dvander@74	286	continue; \
dvander@74	287	} \
dvander@74	288	}
dvander@74	289
dvander@74	290	case OP_JL_F:
dvander@74	291	RELATIONAL_JUMP_F(<);
dvander@74	292	break;
dvander@74	293
dvander@74	294	case OP_JLE_F:
dvander@74	295	RELATIONAL_JUMP_F(<=);
dvander@74	296	break;
dvander@74	297
dvander@74	298	case OP_JG_F:
dvander@74	299	RELATIONAL_JUMP_F(>);
dvander@74	300	break;
dvander@74	301
dvander@74	302	case OP_JGE_F:
dvander@74	303	RELATIONAL_JUMP_F(>=);
dvander@74	304	break;
dvander@74	305
dvander@74	306	case OP_JEQ_F:
dvander@74	307	RELATIONAL_JUMP_F(==);
dvander@74	308	break;
dvander@74	309
dvander@74	310	case OP_JNE_F:
dvander@74	311	RELATIONAL_JUMP_F(!=);
dvander@74	312	break;
dvander@74	313
dvander@74	314	case OP_JT_F:
dvander@74	315	{
dvander@74	316	float value = POP_F(top);
dvander@74	317	if (value) {
dvander@74	318	top.pc += READ_INT32(top.pc);
dvander@74	319	continue;
dvander@74	320	}
dvander@74	321	break;
dvander@74	322	}
dvander@74	323
dvander@74	324	case OP_JF_F:
dvander@74	325	{
dvander@74	326	float value = POP_F(top);
dvander@74	327	if (!value) {
dvander@74	328	top.pc += READ_INT32(top.pc);
dvander@74	329	continue;
dvander@74	330	}
dvander@74	331	break;
dvander@74	332	}
dvander@74	333
dvander@0	334	case OP_JUMP:
dvander@0	335	top.pc += READ_INT32(top.pc);
dvander@0	336	continue;
dvander@0	337
dvander@0	338	case OP_GETLOCAL:
dvander@0	339	{
dvander@0	340	int slot = READ_INT32(top.pc);
dvander@0	341	*top.sp++ = locals[slot];
dvander@0	342	break;
dvander@0	343	}
dvander@0	344
dvander@0	345	case OP_SETLOCAL:
dvander@0	346	{
dvander@0	347	int slot = READ_INT32(top.pc);
dvander@0	348	locals[slot] = top.sp[-1];
dvander@0	349	break;
dvander@0	350	}
dvander@0	351
dvander@0	352	case OP_ADD:
dvander@0	353	{
dvander@77	354	top.sp[-2].i32 = top.sp[-2].i32 + top.sp[-1].i32;
dvander@77	355	top.sp--;
dvander@0	356	break;
dvander@0	357	}
dvander@0	358
dvander@0	359	case OP_SUB:
dvander@0	360	{
dvander@77	361	top.sp[-2].i32 = top.sp[-2].i32 - top.sp[-1].i32;
dvander@77	362	top.sp--;
dvander@0	363	break;
dvander@0	364	}
dvander@0	365
dvander@0	366	case OP_MUL:
dvander@0	367	{
dvander@77	368	top.sp[-2].i32 = top.sp[-2].i32 * top.sp[-1].i32;
dvander@77	369	top.sp--;
dvander@0	370	break;
dvander@0	371	}
dvander@0	372
dvander@0	373	case OP_DIV:
dvander@0	374	{
dvander@77	375	if (top.sp[-1].i32 == 0) {
dvander@69	376	zone->reportError(Message_IntegerDivideByZero);
dvander@69	377	goto error;
dvander@69	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@82	384	case OP_MOD:
dvander@82	385	{
dvander@82	386	if (top.sp[-1].i32 == 0) {
dvander@82	387	zone->reportError(Message_IntegerDivideByZero);
dvander@82	388	goto error;
dvander@82	389	}
dvander@82	390	top.sp[-2].i32 = top.sp[-2].i32 % top.sp[-1].i32;
dvander@82	391	top.sp--;
dvander@82	392	break;
dvander@82	393	}
dvander@82	394
dvander@74	395	case OP_LT:
dvander@74	396	{
dvander@74	397	top.sp[-2].i32 = top.sp[-2].i32 < top.sp[-1].i32;
dvander@74	398	top.sp--;
dvander@74	399	break;
dvander@74	400	}
dvander@74	401
dvander@74	402	case OP_LE:
dvander@74	403	{
dvander@74	404	top.sp[-2].i32 = top.sp[-2].i32 <= top.sp[-1].i32;
dvander@74	405	top.sp--;
dvander@74	406	break;
dvander@74	407	}
dvander@74	408
dvander@74	409	case OP_GT:
dvander@74	410	{
dvander@74	411	top.sp[-2].i32 = top.sp[-2].i32 > top.sp[-1].i32;
dvander@74	412	top.sp--;
dvander@74	413	break;
dvander@74	414	}
dvander@74	415
dvander@74	416	case OP_GE:
dvander@74	417	{
dvander@74	418	top.sp[-2].i32 = top.sp[-2].i32 >= top.sp[-1].i32;
dvander@74	419	top.sp--;
dvander@74	420	break;
dvander@74	421	}
dvander@74	422
dvander@74	423	case OP_EQ:
dvander@74	424	{
dvander@74	425	top.sp[-2].i32 = (top.sp[-2].i32 == top.sp[-1].i32);
dvander@74	426	top.sp--;
dvander@74	427	break;
dvander@74	428	}
dvander@74	429
dvander@74	430	case OP_NE:
dvander@74	431	{
dvander@74	432	top.sp[-2].i32 = (top.sp[-2].i32 != top.sp[-1].i32);
dvander@74	433	top.sp--;
dvander@74	434	break;
dvander@74	435	}
dvander@74	436
dvander@4	437	case OP_ADD_F:
dvander@4	438	{
dvander@77	439	top.sp[-2].f = top.sp[-2].f + top.sp[-1].f;
dvander@77	440	top.sp--;
dvander@4	441	break;
dvander@4	442	}
dvander@4	443
dvander@4	444	case OP_SUB_F:
dvander@4	445	{
dvander@77	446	top.sp[-2].f = top.sp[-2].f - top.sp[-1].f;
dvander@77	447	top.sp--;
dvander@4	448	break;
dvander@4	449	}
dvander@4	450
dvander@4	451	case OP_MUL_F:
dvander@4	452	{
dvander@77	453	top.sp[-2].f = top.sp[-2].f * top.sp[-1].f;
dvander@77	454	top.sp--;
dvander@4	455	break;
dvander@4	456	}
dvander@4	457
dvander@4	458	case OP_DIV_F:
dvander@4	459	{
dvander@77	460	top.sp[-2].f = top.sp[-2].f / top.sp[-1].f;
dvander@77	461	top.sp--;
dvander@4	462	break;
dvander@4	463	}
dvander@4	464
dvander@74	465	case OP_LT_F:
dvander@74	466	{
dvander@74	467	top.sp[-2].f = top.sp[-2].f < top.sp[-1].f;
dvander@74	468	top.sp--;
dvander@74	469	break;
dvander@74	470	}
dvander@74	471
dvander@74	472	case OP_LE_F:
dvander@74	473	{
dvander@74	474	top.sp[-2].f = top.sp[-2].f <= top.sp[-1].f;
dvander@74	475	top.sp--;
dvander@74	476	break;
dvander@74	477	}
dvander@74	478
dvander@74	479	case OP_GT_F:
dvander@74	480	{
dvander@74	481	top.sp[-2].f = top.sp[-2].f > top.sp[-1].f;
dvander@74	482	top.sp--;
dvander@74	483	break;
dvander@74	484	}
dvander@74	485
dvander@74	486	case OP_GE_F:
dvander@74	487	{
dvander@74	488	top.sp[-2].f = top.sp[-2].f >= top.sp[-1].f;
dvander@74	489	top.sp--;
dvander@74	490	break;
dvander@74	491	}
dvander@74	492
dvander@74	493	case OP_EQ_F:
dvander@74	494	{
dvander@74	495	top.sp[-2].i32 = (top.sp[-2].f == top.sp[-1].f);
dvander@74	496	top.sp--;
dvander@74	497	break;
dvander@74	498	}
dvander@74	499
dvander@74	500	case OP_NE_F:
dvander@74	501	{
dvander@74	502	top.sp[-2].i32 = (top.sp[-2].f != top.sp[-1].f);
dvander@74	503	top.sp--;
dvander@74	504	break;
dvander@74	505	}
dvander@74	506
dvander@8	507	case OP_SHL:
dvander@8	508	{
dvander@77	509	top.sp[-2].i32 = top.sp[-2].i32 << top.sp[-1].i32;
dvander@77	510	top.sp--;
dvander@8	511	break;
dvander@8	512	}
dvander@8	513
dvander@8	514	case OP_SHR:
dvander@8	515	{
dvander@77	516	top.sp[-2].i32 = top.sp[-2].i32 >> top.sp[-1].i32;
dvander@77	517	top.sp--;
dvander@8	518	break;
dvander@8	519	}
dvander@8	520
dvander@8	521	case OP_USHR:
dvander@8	522	{
dvander@77	523	top.sp[-2].i32 = unsigned(top.sp[-2].i32) << unsigned(top.sp[-1].i32);
dvander@77	524	top.sp--;
dvander@8	525	break;
dvander@8	526	}
dvander@8	527
dvander@8	528	case OP_BITAND:
dvander@8	529	{
dvander@77	530	top.sp[-2].i32 = top.sp[-2].i32 & top.sp[-1].i32;
dvander@77	531	top.sp--;
dvander@8	532	break;
dvander@8	533	}
dvander@8	534
dvander@8	535	case OP_BITOR:
dvander@8	536	{
dvander@77	537	top.sp[-2].i32 = top.sp[-2].i32 \| top.sp[-1].i32;
dvander@77	538	top.sp--;
dvander@8	539	break;
dvander@8	540	}
dvander@8	541
dvander@8	542	case OP_BITXOR:
dvander@8	543	{
dvander@77	544	top.sp[-2].i32 = top.sp[-2].i32 ^ top.sp[-1].i32;
dvander@77	545	top.sp--;
dvander@8	546	break;
dvander@8	547	}
dvander@8	548
dvander@78	549	case OP_BITNOT:
dvander@78	550	{
dvander@78	551	top.sp[-1].i32 = ~top.sp[-1].i32;
dvander@78	552	break;
dvander@78	553	}
dvander@78	554
dvander@79	555	case OP_NOT:
dvander@79	556	{
dvander@79	557	top.sp[-1].i32 = top.sp[-1].i32 ? 0 : 1;
dvander@79	558	break;
dvander@79	559	}
dvander@79	560
dvander@79	561	case OP_NOT_F:
dvander@79	562	{
dvander@79	563	top.sp[-1].i32 = top.sp[-1].f ? 0 : 1;
dvander@79	564	break;
dvander@79	565	}
dvander@79	566
dvander@80	567	case OP_NEG:
dvander@79	568	{
dvander@80	569	top.sp[-1].i32 = -top.sp[-1].i32;
dvander@80	570	break;
dvander@80	571	}
dvander@80	572
dvander@80	573	case OP_NEG_F:
dvander@80	574	{
dvander@80	575	top.sp[-1].f = -top.sp[-1].f;
dvander@0	576	break;
dvander@79	577	}
dvander@0	578
dvander@73	579	case OP_CALL:
dvander@0	580	{
dvander@73	581	Local<Function> newFun(zone, top.sp[-1].fun);
dvander@73	582	top.sp--;
dvander@73	583
dvander@69	584	if (!zone->stack().pushInlineFrame(newFun))
dvander@69	585	goto error;
dvander@0	586
dvander@47	587	locals = top.fp->locals();
dvander@0	588	continue;
dvander@0	589	}
dvander@0	590
dvander@0	591	case OP_GETARG:
dvander@0	592	{
dvander@0	593	unsigned slot = READ_UINT32(top.pc);
dvander@47	594	*top.sp++ = top.fp->arg(slot);
dvander@0	595	break;
dvander@0	596	}
dvander@0	597
dvander@0	598	case OP_SETARG:
dvander@0	599	{
dvander@0	600	unsigned slot = READ_UINT32(top.pc);
dvander@47	601	top.fp->arg(slot) = *--top.sp;
dvander@0	602	break;
dvander@0	603	}
dvander@0	604
dvander@19	605	case OP_BOUNDS:
dvander@0	606	{
dvander@12	607	Array *array = top.sp[-2].array;
dvander@0	608	int index = top.sp[-1].i32;
dvander@69	609	if (index < 0 \|\| unsigned(index) >= array->nelements()) {
dvander@69	610	zone->reportError(Message_ArrayIndexOutOfBounds, index, array->nelements());
dvander@69	611	goto error;
dvander@69	612	}
dvander@0	613	break;
dvander@0	614	}
dvander@0	615
dvander@6	616	case OP_GETARRAY_I:
dvander@0	617	{
dvander@12	618	Array *array = top.sp[-2].array;
dvander@0	619	int index = top.sp[-1].i32;
dvander@0	620	top.sp[-2].i32 = array->readInt32(index);
dvander@0	621	top.sp--;
dvander@0	622	break;
dvander@0	623	}
dvander@0	624
dvander@7	625	case OP_GETARRAY_F:
dvander@7	626	{
dvander@12	627	Array *array = top.sp[-2].array;
dvander@7	628	int index = top.sp[-1].i32;
dvander@7	629	top.sp[-2].f = array->readFloat(index);
dvander@7	630	top.sp--;
dvander@7	631	break;
dvander@7	632	}
dvander@7	633
dvander@21	634	case OP_GETARRAY_C:
dvander@21	635	{
dvander@21	636	Array *array = top.sp[-2].array;
dvander@21	637	int index = top.sp[-1].i32;
dvander@21	638	top.sp[-2].i32 = array->readChar(index);
dvander@21	639	top.sp--;
dvander@21	640	break;
dvander@21	641	}
dvander@21	642
dvander@6	643	case OP_SETARRAY_I:
dvander@0	644	{
dvander@12	645	Array *array = top.sp[-3].array;
dvander@0	646	int index = top.sp[-2].i32;
dvander@0	647	array->writeInt32(index, top.sp[-1].i32);
dvander@0	648	top.sp[-3] = top.sp[-1];
dvander@0	649	top.sp -= 2;
dvander@0	650	break;
dvander@0	651	}
dvander@0	652
dvander@7	653	case OP_SETARRAY_F:
dvander@7	654	{
dvander@12	655	Array *array = top.sp[-3].array;
dvander@7	656	int index = top.sp[-2].i32;
dvander@7	657	array->writeFloat(index, top.sp[-1].f);
dvander@7	658	top.sp[-3] = top.sp[-1];
dvander@7	659	top.sp -= 2;
dvander@7	660	break;
dvander@7	661	}
dvander@7	662
dvander@21	663	case OP_SETARRAY_C:
dvander@21	664	{
dvander@21	665	Array *array = top.sp[-3].array;
dvander@21	666	int index = top.sp[-2].i32;
dvander@21	667	array->writeChar(index, top.sp[-1].i32);
dvander@21	668	top.sp[-3] = top.sp[-1];
dvander@21	669	top.sp -= 2;
dvander@21	670	break;
dvander@21	671	}
dvander@21	672
dvander@19	673	case OP_GETARRAY_O:
dvander@0	674	{
dvander@12	675	Array *array = top.sp[-2].array;
dvander@0	676	int index = top.sp[-1].i32;
dvander@12	677	top.sp[-2].array = Array::cast(array->readObject(index));
dvander@0	678	top.sp--;
dvander@0	679	break;
dvander@0	680	}
dvander@0	681
dvander@4	682	case OP_CVT_I2F:
dvander@4	683	{
dvander@4	684	int ival = POP_I32(top);
dvander@4	685	float fval = (float)ival;
dvander@4	686	PUSH_F(top, fval);
dvander@4	687	break;
dvander@4	688	}
dvander@4	689
dvander@85	690	case OP_NEWARRAY:
dvander@12	691	{
dvander@85	692	Heap::Tenure tenure = (Heap::Tenure)top.pc[1];
dvander@85	693	Local<ArrayMap> map(zone, ArrayMap::cast(top.fp->code()->map(READ_UINT32(top.pc + 1))));
dvander@85	694	Array *array = GenerateArray(zone, map, tenure);
dvander@69	695	if (!array)
dvander@69	696	goto error;
dvander@12	697	top.sp->obj = array;
dvander@12	698	top.sp++;
dvander@12	699	break;
dvander@12	700	}
dvander@12	701
dvander@12	702	case OP_SAVELIFO:
dvander@10	703	{
dvander@10	704	unsigned slot = READ_UINT32(top.pc);
dvander@42	705	locals[slot].address = zone->heap().lifoPosition();
dvander@12	706	break;
dvander@12	707	}
dvander@12	708
dvander@12	709	case OP_UNWINDLIFO:
dvander@12	710	{
dvander@12	711	unsigned slot = READ_UINT32(top.pc);
dvander@42	712	zone->heap().unwindLifo(locals[slot].address);
dvander@10	713	break;
dvander@10	714	}
dvander@10	715
dvander@14	716	case OP_VARREF_LIFO:
dvander@14	717	{
dvander@14	718	unsigned slot = READ_UINT32(top.pc);
dvander@69	719	if (!PushNewRef(zone, top, &locals[slot], Heap::Tenure_Stack))
dvander@69	720	goto error;
dvander@14	721	break;
dvander@14	722	}
dvander@14	723
dvander@14	724	case OP_ARGREF_LIFO:
dvander@14	725	{
dvander@14	726	unsigned slot = READ_UINT32(top.pc);
dvander@69	727	if (!PushNewRef(zone, top, &top.fp->arg(slot), Heap::Tenure_Stack))
dvander@69	728	goto error;
dvander@14	729	break;
dvander@14	730	}
dvander@14	731
dvander@17	732	case OP_ARRAYREF_LIFO:
dvander@17	733	{
dvander@42	734	Local<Array> array(zone, top.sp[-2].array);
dvander@42	735	Local<Reference> ref(zone, Reference::NewArray(zone, array, top.sp[-1].i32, Heap::Tenure_Stack));
dvander@69	736	if (!ref)
dvander@69	737	goto error;
dvander@17	738	top.sp[-2].ref = ref;
dvander@17	739	top.sp--;
dvander@17	740	break;
dvander@17	741	}
dvander@17	742
dvander@16	743	case OP_SLOTREF_LIFO:
dvander@16	744	{
dvander@42	745	Reference *ref = Reference::NewStack(zone, top.sp[-1], Heap::Tenure_Stack);
dvander@69	746	if (!ref)
dvander@69	747	goto error;
dvander@16	748	top.sp[-1].ref = ref;
dvander@16	749	break;
dvander@16	750	}
dvander@16	751
dvander@14	752	case OP_GETREF_I:
dvander@14	753	{
dvander@14	754	top.sp[-1].i32 = top.sp[-1].ref->getInt();
dvander@14	755	break;
dvander@14	756	}
dvander@14	757
dvander@14	758	case OP_SETREF_I:
dvander@14	759	{
dvander@14	760	top.sp[-2].ref->setInt(top.sp[-1].i32);
dvander@14	761	top.sp[-2].i32 = top.sp[-1].i32;
dvander@23	762	top.sp--;
dvander@14	763	break;
dvander@14	764	}
dvander@14	765
dvander@14	766	case OP_GETREF_F:
dvander@14	767	{
dvander@14	768	top.sp[-1].f = top.sp[-1].ref->getFloat();
dvander@14	769	break;
dvander@14	770	}
dvander@14	771
dvander@14	772	case OP_SETREF_F:
dvander@14	773	{
dvander@14	774	top.sp[-2].ref->setFloat(top.sp[-1].f);
dvander@14	775	top.sp[-2].f = top.sp[-1].f;
dvander@14	776	break;
dvander@14	777	}
dvander@14	778
dvander@21	779	case OP_OBJECT:
dvander@21	780	{
dvander@47	781	top.sp->obj = top.fp->code()->object(READ_UINT32(top.pc));
dvander@21	782	top.sp++;
dvander@21	783	break;
dvander@21	784	}
dvander@21	785
dvander@21	786	case OP_ARRAYCOPY:
dvander@21	787	{
dvander@21	788	// Note for this assignment opcode, we return the left-hand side, not the
dvander@21	789	// right, since in this case the result of the expression could be different.
dvander@69	790	if (!CopyArray(zone, top.sp[-2].array, top.sp[-1].array))
dvander@69	791	goto error;
dvander@21	792	top.sp--;
dvander@21	793	break;
dvander@21	794	}
dvander@21	795
dvander@22	796	case OP_DUP:
dvander@22	797	{
dvander@23	798	top.sp++;
dvander@23	799	top.sp[-1] = top.sp[-2];
dvander@22	800	break;
dvander@22	801	}
dvander@22	802
dvander@22	803	case OP_DUP2:
dvander@22	804	{
dvander@23	805	top.sp += 2;
dvander@23	806	top.sp[-2] = top.sp[-4];
dvander@23	807	top.sp[-1] = top.sp[-3];
dvander@23	808	break;
dvander@23	809	}
dvander@23	810
dvander@23	811	case OP_SWAP:
dvander@23	812	{
dvander@23	813	LocalSlot slot = top.sp[-2];
dvander@23	814	top.sp[-2] = top.sp[-1];
dvander@23	815	top.sp[-1] = slot;
dvander@23	816	break;
dvander@23	817	}
dvander@23	818
dvander@23	819	case OP_ROLL3:
dvander@23	820	{
dvander@23	821	LocalSlot slot = top.sp[-3];
dvander@23	822	top.sp[-3] = top.sp[-2];
dvander@23	823	top.sp[-2] = top.sp[-1];
dvander@23	824	top.sp[-1] = slot;
dvander@23	825	break;
dvander@23	826	}
dvander@23	827
dvander@23	828	case OP_PICK2:
dvander@23	829	{
dvander@23	830	top.sp++;
dvander@23	831	top.sp[-1] = top.sp[-3];
dvander@23	832	break;
dvander@23	833	}
dvander@23	834
dvander@23	835	case OP_PICK3:
dvander@23	836	{
dvander@23	837	top.sp++;
dvander@23	838	top.sp[-1] = top.sp[-4];
dvander@22	839	break;
dvander@22	840	}
dvander@22	841
dvander@68	842	case OP_CALLNATIVE:
dvander@68	843	{
dvander@68	844	unsigned index = READ_UINT32(top.pc);
dvander@68	845	unsigned argc = READ_UINT32(top.pc + 4);
dvander@68	846
dvander@68	847	Local<Native> native(zone, Native::cast(top.fp->code()->module()->natives()->at(index)));
dvander@68	848	if (!native->function()) {
dvander@69	849	zone->reportError(Message_NativeNotBound, native->name()->chars());
dvander@69	850	goto error;
dvander@68	851	}
dvander@68	852
dvander@68	853	int result;
dvander@68	854	void *nativeIdentity = top.fp->code()->module()->nativeIdentity();
dvander@69	855	if (!InvokeNative(zone, native, nativeIdentity, top.sp, argc, &result))
dvander@69	856	goto error;
dvander@68	857
dvander@68	858	top.sp -= argc;
dvander@68	859	PUSH_I32(top, result);
dvander@68	860	break;
dvander@68	861	}
dvander@68	862
dvander@73	863	case OP_MODULE:
dvander@73	864	{
dvander@73	865	top.sp++;
dvander@73	866	top.sp[-1].module = top.fp->code()->module();
dvander@73	867	break;
dvander@73	868	}
dvander@73	869
dvander@73	870	case OP_GETMODULE_FN:
dvander@73	871	{
dvander@73	872	top.sp[-1].fun = top.sp[-1].module->getFunction(READ_UINT32(top.pc));
dvander@73	873	break;
dvander@73	874	}
dvander@73	875
dvander@85	876	case OP_GETGLOBAL_I:
dvander@85	877	{
dvander@85	878	unsigned slot = READ_UINT32(top.pc);
dvander@85	879	top.sp++;
dvander@85	880	top.sp[-1].i32 = top.fp->code()->module()->environment()->getInt32(slot);
dvander@85	881	break;
dvander@85	882	}
dvander@85	883
dvander@85	884	case OP_GETGLOBAL_F:
dvander@85	885	{
dvander@85	886	unsigned slot = READ_UINT32(top.pc);
dvander@85	887	top.sp++;
dvander@85	888	top.sp[-1].f = top.fp->code()->module()->environment()->getFloat(slot);
dvander@85	889	break;
dvander@85	890	}
dvander@85	891
dvander@85	892	case OP_GETGLOBAL_O:
dvander@85	893	{
dvander@85	894	unsigned slot = READ_UINT32(top.pc);
dvander@85	895	top.sp++;
dvander@85	896	top.sp[-1].obj = top.fp->code()->module()->environment()->getObject(slot);
dvander@85	897	break;
dvander@85	898	}
dvander@85	899
dvander@85	900	case OP_SETGLOBAL_I:
dvander@85	901	{
dvander@85	902	unsigned slot = READ_UINT32(top.pc);
dvander@85	903	top.fp->code()->module()->environment()->setInt32(slot, top.sp[-1].i32);
dvander@85	904	break;
dvander@85	905	}
dvander@85	906
dvander@85	907	case OP_SETGLOBAL_F:
dvander@85	908	{
dvander@85	909	unsigned slot = READ_UINT32(top.pc);
dvander@85	910	top.fp->code()->module()->environment()->setFloat(slot, top.sp[-1].f);
dvander@85	911	break;
dvander@85	912	}
dvander@85	913
dvander@85	914	case OP_SETGLOBAL_O:
dvander@85	915	{
dvander@85	916	unsigned slot = READ_UINT32(top.pc);
dvander@85	917	top.fp->code()->module()->environment()->setObject(slot, top.sp[-1].obj);
dvander@85	918	break;
dvander@85	919	}
dvander@85	920
dvander@0	921	default:
dvander@0	922	assert(false);
dvander@0	923	return false;
dvander@0	924
dvander@0	925	}
dvander@0	926
dvander@0	927	top.pc += OpcodeInfo[op].length;
dvander@0	928	}
dvander@0	929
dvander@69	930	done:
dvander@0	931	return true;
dvander@69	932
dvander@69	933	error:
dvander@69	934	// Unwind frames until we can continue.
dvander@69	935	while (top.fp != entryFrame)
dvander@69	936	zone->stack().popInlineFrame();
dvander@69	937	return false;
dvander@0	938	}

author	David Anderson <danderson@mozilla.com>
	Wed Jul 25 01:32:49 2012 -0700 (2012-07-25)
changeset 93	23189d937087
parent 91	5f4402180204
child 142	a000bafece09
permissions	-rw-r--r--