UNLOZE/sourcemod
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Modernize sp_vm_basecontext.

Browse Source
This commit is contained in:
dvander@alliedmods.net 2015-02-23 13:40:01 -08:00
parent 1b47aa10ca
commit 45c43f4aee
2 changed files with 606 additions and 671 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

366
sourcepawn/jit/sp_vm_basecontext.cpp
View File

@ -1,34 +1,15 @@
/** // vim: set sts=2 ts=8 sw=2 tw=99 et:
* vim: set ts=4 sw=4 tw=99 noet: //
* ============================================================================= // Copyright (C) 2006-2015 AlliedModders LLC
* SourcePawn //
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved. // This file is part of SourcePawn. SourcePawn is free software: you can
* ============================================================================= // redistribute it and/or modify it under the terms of the GNU General Public
* // License as published by the Free Software Foundation, either version 3 of
* This program is free software; you can redistribute it and/or modify it under // the License, or (at your option) any later version.
* the terms of the GNU General Public License, version 3.0, as published by the //
* Free Software Foundation. // You should have received a copy of the GNU General Public License along with
* // SourcePawn. If not, see http://www.gnu.org/licenses/.
* This program is distributed in the hope that it will be useful, but WITHOUT //
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*
* Version: $Id$
*/
#include <string.h> #include <string.h>
#include <stdarg.h> #include <stdarg.h>
#include <assert.h> #include <assert.h>
@ -55,25 +36,19 @@ BaseContext::BaseContext(BaseRuntime *pRuntime)
/* Initialize the null references */ /* Initialize the null references */
uint32_t index; uint32_t index;
if (FindPubvarByName("NULL_VECTOR", &index) == SP_ERROR_NONE) if (FindPubvarByName("NULL_VECTOR", &index) == SP_ERROR_NONE) {
{
sp_pubvar_t *pubvar; sp_pubvar_t *pubvar;
GetPubvarByIndex(index, &pubvar); GetPubvarByIndex(index, &pubvar);
m_pNullVec = pubvar->offs; m_pNullVec = pubvar->offs;
} } else {
else
{
m_pNullVec = NULL; m_pNullVec = NULL;
} }
if (FindPubvarByName("NULL_STRING", &index) == SP_ERROR_NONE) if (FindPubvarByName("NULL_STRING", &index) == SP_ERROR_NONE) {
{
sp_pubvar_t *pubvar; sp_pubvar_t *pubvar;
GetPubvarByIndex(index, &pubvar); GetPubvarByIndex(index, &pubvar);
m_pNullString = pubvar->offs; m_pNullString = pubvar->offs;
} } else {
else
{
m_pNullString = NULL; m_pNullString = NULL;
} }
@ -92,49 +67,58 @@ BaseContext::~BaseContext()
g_Jit.FreeContextVars(&m_ctx); g_Jit.FreeContextVars(&m_ctx);
} }
IVirtualMachine *BaseContext::GetVirtualMachine() IVirtualMachine *
BaseContext::GetVirtualMachine()
{ {
return NULL; return NULL;
} }
sp_context_t *BaseContext::GetContext() sp_context_t *
BaseContext::GetContext()
{ {
return reinterpret_cast<sp_context_t *>((IPluginContext * )this); return reinterpret_cast<sp_context_t *>((IPluginContext * )this);
} }
sp_context_t *BaseContext::GetCtx() sp_context_t *
BaseContext::GetCtx()
{ {
return &m_ctx; return &m_ctx;
} }
bool BaseContext::IsDebugging() bool
BaseContext::IsDebugging()
{ {
return true; return true;
} }
int BaseContext::SetDebugBreak(void *newpfn, void *oldpfn) int
BaseContext::SetDebugBreak(void *newpfn, void *oldpfn)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
IPluginDebugInfo *BaseContext::GetDebugInfo() IPluginDebugInfo *
BaseContext::GetDebugInfo()
{ {
return NULL; return NULL;
} }
int BaseContext::Execute(uint32_t code_addr, cell_t *result) int
BaseContext::Execute(uint32_t code_addr, cell_t *result)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
void BaseContext::SetErrorMessage(const char *msg, va_list ap) void
BaseContext::SetErrorMessage(const char *msg, va_list ap)
{ {
m_CustomMsg = true; m_CustomMsg = true;
vsnprintf(m_MsgCache, sizeof(m_MsgCache), msg, ap); vsnprintf(m_MsgCache, sizeof(m_MsgCache), msg, ap);
} }
void BaseContext::_SetErrorMessage(const char *msg, ...) void
BaseContext::_SetErrorMessage(const char *msg, ...)
{ {
va_list ap; va_list ap;
va_start(ap, msg); va_start(ap, msg);
@ -142,17 +126,15 @@ void BaseContext::_SetErrorMessage(const char *msg, ...)
va_end(ap); va_end(ap);
} }
cell_t BaseContext::ThrowNativeErrorEx(int error, const char *msg, ...) cell_t
BaseContext::ThrowNativeErrorEx(int error, const char *msg, ...)
{ {
if (!m_InExec) if (!m_InExec)
{
return 0; return 0;
}
m_ctx.n_err = error; m_ctx.n_err = error;
if (msg) if (msg) {
{
va_list ap; va_list ap;
va_start(ap, msg); va_start(ap, msg);
SetErrorMessage(msg, ap); SetErrorMessage(msg, ap);
@ -162,17 +144,15 @@ cell_t BaseContext::ThrowNativeErrorEx(int error, const char *msg, ...)
return 0; return 0;
} }
cell_t BaseContext::ThrowNativeError(const char *msg, ...) cell_t
BaseContext::ThrowNativeError(const char *msg, ...)
{ {
if (!m_InExec) if (!m_InExec)
{
return 0; return 0;
}
m_ctx.n_err = SP_ERROR_NATIVE; m_ctx.n_err = SP_ERROR_NATIVE;
if (msg) if (msg) {
{
va_list ap; va_list ap;
va_start(ap, msg); va_start(ap, msg);
SetErrorMessage(msg, ap); SetErrorMessage(msg, ap);
@ -182,7 +162,8 @@ cell_t BaseContext::ThrowNativeError(const char *msg, ...)
return 0; return 0;
} }
int BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys_addr) int
BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys_addr)
{ {
cell_t *addr; cell_t *addr;
ucell_t realmem; ucell_t realmem;
@ -202,9 +183,7 @@ int BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys
* Check if the space between the heap and stack is sufficient. * Check if the space between the heap and stack is sufficient.
*/ */
if ((cell_t)(m_ctx.sp - m_ctx.hp - realmem) < STACKMARGIN) if ((cell_t)(m_ctx.sp - m_ctx.hp - realmem) < STACKMARGIN)
{
return SP_ERROR_HEAPLOW; return SP_ERROR_HEAPLOW;
}
addr = (cell_t *)(m_pRuntime->plugin()->memory + m_ctx.hp); addr = (cell_t *)(m_pRuntime->plugin()->memory + m_ctx.hp);
/* store size of allocation in cells */ /* store size of allocation in cells */
@ -215,16 +194,15 @@ int BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys
*local_addr = m_ctx.hp; *local_addr = m_ctx.hp;
if (phys_addr) if (phys_addr)
{
*phys_addr = addr; *phys_addr = addr;
}
m_ctx.hp += realmem; m_ctx.hp += realmem;
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
int BaseContext::HeapPop(cell_t local_addr) int
BaseContext::HeapPop(cell_t local_addr)
{ {
cell_t cellcount; cell_t cellcount;
cell_t *addr; cell_t *addr;
@ -232,17 +210,13 @@ int BaseContext::HeapPop(cell_t local_addr)
/* check the bounds of this address */ /* check the bounds of this address */
local_addr -= sizeof(cell_t); local_addr -= sizeof(cell_t);
if (local_addr < (cell_t)m_pRuntime->plugin()->data_size || local_addr >= m_ctx.sp) if (local_addr < (cell_t)m_pRuntime->plugin()->data_size || local_addr >= m_ctx.sp)
{
return SP_ERROR_INVALID_ADDRESS; return SP_ERROR_INVALID_ADDRESS;
}
addr = (cell_t *)(m_pRuntime->plugin()->memory + local_addr); addr = (cell_t *)(m_pRuntime->plugin()->memory + local_addr);
cellcount = (*addr) * sizeof(cell_t); cellcount = (*addr) * sizeof(cell_t);
/* check if this memory count looks valid */ /* check if this memory count looks valid */
if ((signed)(m_ctx.hp - cellcount - sizeof(cell_t)) != local_addr) if ((signed)(m_ctx.hp - cellcount - sizeof(cell_t)) != local_addr)
{
return SP_ERROR_INVALID_ADDRESS; return SP_ERROR_INVALID_ADDRESS;
}
m_ctx.hp = local_addr; m_ctx.hp = local_addr;
@ -250,124 +224,139 @@ int BaseContext::HeapPop(cell_t local_addr)
} }
int BaseContext::HeapRelease(cell_t local_addr) int
BaseContext::HeapRelease(cell_t local_addr)
{ {
if (local_addr < (cell_t)m_pRuntime->plugin()->data_size) if (local_addr < (cell_t)m_pRuntime->plugin()->data_size)
{
return SP_ERROR_INVALID_ADDRESS; return SP_ERROR_INVALID_ADDRESS;
}
m_ctx.hp = local_addr - sizeof(cell_t); m_ctx.hp = local_addr - sizeof(cell_t);
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
int BaseContext::FindNativeByName(const char *name, uint32_t *index) int
BaseContext::FindNativeByName(const char *name, uint32_t *index)
{ {
return m_pRuntime->FindNativeByName(name, index); return m_pRuntime->FindNativeByName(name, index);
} }
int BaseContext::GetNativeByIndex(uint32_t index, sp_native_t **native) int
BaseContext::GetNativeByIndex(uint32_t index, sp_native_t **native)
{ {
return m_pRuntime->GetNativeByIndex(index, native); return m_pRuntime->GetNativeByIndex(index, native);
} }
uint32_t
uint32_t BaseContext::GetNativesNum() BaseContext::GetNativesNum()
{ {
return m_pRuntime->GetNativesNum(); return m_pRuntime->GetNativesNum();
} }
int BaseContext::FindPublicByName(const char *name, uint32_t *index) int
BaseContext::FindPublicByName(const char *name, uint32_t *index)
{ {
return m_pRuntime->FindPublicByName(name, index); return m_pRuntime->FindPublicByName(name, index);
} }
int BaseContext::GetPublicByIndex(uint32_t index, sp_public_t **pblic) int
BaseContext::GetPublicByIndex(uint32_t index, sp_public_t **pblic)
{ {
return m_pRuntime->GetPublicByIndex(index, pblic); return m_pRuntime->GetPublicByIndex(index, pblic);
} }
uint32_t BaseContext::GetPublicsNum() uint32_t
BaseContext::GetPublicsNum()
{ {
return m_pRuntime->GetPublicsNum(); return m_pRuntime->GetPublicsNum();
} }
int BaseContext::GetPubvarByIndex(uint32_t index, sp_pubvar_t **pubvar) int
BaseContext::GetPubvarByIndex(uint32_t index, sp_pubvar_t **pubvar)
{ {
return m_pRuntime->GetPubvarByIndex(index, pubvar); return m_pRuntime->GetPubvarByIndex(index, pubvar);
} }
int BaseContext::FindPubvarByName(const char *name, uint32_t *index) int
BaseContext::FindPubvarByName(const char *name, uint32_t *index)
{ {
return m_pRuntime->FindPubvarByName(name, index); return m_pRuntime->FindPubvarByName(name, index);
} }
int BaseContext::GetPubvarAddrs(uint32_t index, cell_t *local_addr, cell_t **phys_addr) int
BaseContext::GetPubvarAddrs(uint32_t index, cell_t *local_addr, cell_t **phys_addr)
{ {
return m_pRuntime->GetPubvarAddrs(index, local_addr, phys_addr); return m_pRuntime->GetPubvarAddrs(index, local_addr, phys_addr);
} }
uint32_t BaseContext::GetPubVarsNum() uint32_t
BaseContext::GetPubVarsNum()
{ {
return m_pRuntime->GetPubVarsNum(); return m_pRuntime->GetPubVarsNum();
} }
int BaseContext::BindNatives(const sp_nativeinfo_t *natives, unsigned int num, int overwrite) int
BaseContext::BindNatives(const sp_nativeinfo_t *natives, unsigned int num, int overwrite)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::BindNative(const sp_nativeinfo_t *native) int
BaseContext::BindNative(const sp_nativeinfo_t *native)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::BindNativeToIndex(uint32_t index, SPVM_NATIVE_FUNC func) int
BaseContext::BindNativeToIndex(uint32_t index, SPVM_NATIVE_FUNC func)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::BindNativeToAny(SPVM_NATIVE_FUNC native) int
BaseContext::BindNativeToAny(SPVM_NATIVE_FUNC native)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::LocalToPhysAddr(cell_t local_addr, cell_t **phys_addr) int
BaseContext::LocalToPhysAddr(cell_t local_addr, cell_t **phys_addr)
{ {
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
|| (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size)) (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{ {
return SP_ERROR_INVALID_ADDRESS; return SP_ERROR_INVALID_ADDRESS;
} }
if (phys_addr) if (phys_addr)
{
*phys_addr = (cell_t *)(m_pRuntime->plugin()->memory + local_addr); *phys_addr = (cell_t *)(m_pRuntime->plugin()->memory + local_addr);
}
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
int BaseContext::PushCell(cell_t value) int
BaseContext::PushCell(cell_t value)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::PushCellsFromArray(cell_t array[], unsigned int numcells) int
BaseContext::PushCellsFromArray(cell_t array[], unsigned int numcells)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::PushCellArray(cell_t *local_addr, cell_t **phys_addr, cell_t array[], unsigned int numcells) int
BaseContext::PushCellArray(cell_t *local_addr, cell_t **phys_addr, cell_t array[], unsigned int numcells)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::LocalToString(cell_t local_addr, char **addr) int
BaseContext::LocalToString(cell_t local_addr, char **addr)
{ {
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
|| (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size)) (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{ {
return SP_ERROR_INVALID_ADDRESS; return SP_ERROR_INVALID_ADDRESS;
} }
@ -376,34 +365,32 @@ int BaseContext::LocalToString(cell_t local_addr, char **addr)
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
int BaseContext::PushString(cell_t *local_addr, char **phys_addr, const char *string) int
BaseContext::PushString(cell_t *local_addr, char **phys_addr, const char *string)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
int BaseContext::StringToLocal(cell_t local_addr, size_t bytes, const char *source) int
BaseContext::StringToLocal(cell_t local_addr, size_t bytes, const char *source)
{ {
char *dest; char *dest;
size_t len; size_t len;
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
|| (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size)) (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{ {
return SP_ERROR_INVALID_ADDRESS; return SP_ERROR_INVALID_ADDRESS;
} }
if (bytes == 0) if (bytes == 0)
{
return SP_ERROR_NONE; return SP_ERROR_NONE;
}
len = strlen(source); len = strlen(source);
dest = (char *)(m_pRuntime->plugin()->memory + local_addr); dest = (char *)(m_pRuntime->plugin()->memory + local_addr);
if (len >= bytes) if (len >= bytes)
{
len = bytes - 1; len = bytes - 1;
}
memmove(dest, source, len); memmove(dest, source, len);
dest[len] = '\0'; dest[len] = '\0';
@ -411,15 +398,14 @@ int BaseContext::StringToLocal(cell_t local_addr, size_t bytes, const char *sour
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
inline int __CheckValidChar(char *c) static inline int
__CheckValidChar(char *c)
{ {
int count; int count;
int bytecount = 0; int bytecount = 0;
for (count=1; (*c & 0xC0) == 0x80; count++) for (count=1; (*c & 0xC0) == 0x80; count++)
{
c--; c--;
}
switch (*c & 0xF0) switch (*c & 0xF0)
{ {
@ -442,109 +428,99 @@ inline int __CheckValidChar(char *c)
} }
if (bytecount != count) if (bytecount != count)
{
return count; return count;
}
return 0; return 0;
} }
int BaseContext::StringToLocalUTF8(cell_t local_addr, size_t maxbytes, const char *source, size_t *wrtnbytes) int
BaseContext::StringToLocalUTF8(cell_t local_addr, size_t maxbytes, const char *source, size_t *wrtnbytes)
{ {
char *dest; char *dest;
size_t len; size_t len;
bool needtocheck = false; bool needtocheck = false;
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
|| (local_addr < 0) (local_addr < 0) ||
|| ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size)) ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{ {
return SP_ERROR_INVALID_ADDRESS; return SP_ERROR_INVALID_ADDRESS;
} }
if (maxbytes == 0) if (maxbytes == 0)
{
return SP_ERROR_NONE; return SP_ERROR_NONE;
}
len = strlen(source); len = strlen(source);
dest = (char *)(m_pRuntime->plugin()->memory + local_addr); dest = (char *)(m_pRuntime->plugin()->memory + local_addr);
if ((size_t)len >= maxbytes) if ((size_t)len >= maxbytes) {
{
len = maxbytes - 1; len = maxbytes - 1;
needtocheck = true; needtocheck = true;
} }
memmove(dest, source, len); memmove(dest, source, len);
if ((dest[len-1] & 1<<7) && needtocheck) if ((dest[len-1] & 1<<7) && needtocheck)
{
len -= __CheckValidChar(dest+len-1); len -= __CheckValidChar(dest+len-1);
}
dest[len] = '\0'; dest[len] = '\0';
if (wrtnbytes) if (wrtnbytes)
{
*wrtnbytes = len; *wrtnbytes = len;
}
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
IPluginFunction *BaseContext::GetFunctionById(funcid_t func_id) IPluginFunction *
BaseContext::GetFunctionById(funcid_t func_id)
{ {
return m_pRuntime->GetFunctionById(func_id); return m_pRuntime->GetFunctionById(func_id);
} }
IPluginFunction *BaseContext::GetFunctionByName(const char *public_name) IPluginFunction *
BaseContext::GetFunctionByName(const char *public_name)
{ {
return m_pRuntime->GetFunctionByName(public_name); return m_pRuntime->GetFunctionByName(public_name);
} }
int BaseContext::LocalToStringNULL(cell_t local_addr, char **addr) int
BaseContext::LocalToStringNULL(cell_t local_addr, char **addr)
{ {
int err; int err;
if ((err = LocalToString(local_addr, addr)) != SP_ERROR_NONE) if ((err = LocalToString(local_addr, addr)) != SP_ERROR_NONE)
{
return err; return err;
}
if ((cell_t *)*addr == m_pNullString) if ((cell_t *)*addr == m_pNullString)
{
*addr = NULL; *addr = NULL;
}
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
SourceMod::IdentityToken_t *BaseContext::GetIdentity() SourceMod::IdentityToken_t *
BaseContext::GetIdentity()
{ {
SourceMod::IdentityToken_t *tok; SourceMod::IdentityToken_t *tok;
if (GetKey(1, (void **)&tok)) if (GetKey(1, (void **)&tok))
{
return tok; return tok;
}
return NULL; return NULL;
} }
cell_t *BaseContext::GetNullRef(SP_NULL_TYPE type) cell_t *
BaseContext::GetNullRef(SP_NULL_TYPE type)
{ {
if (type == SP_NULL_VECTOR) if (type == SP_NULL_VECTOR)
{
return m_pNullVec; return m_pNullVec;
}
return NULL; return NULL;
} }
bool BaseContext::IsInExec() bool
BaseContext::IsInExec()
{ {
return m_InExec; return m_InExec;
} }
int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsigned int num_params, cell_t *result) int
BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsigned int num_params, cell_t *result)
{ {
int ir; int ir;
int serial; int serial;
@ -579,20 +555,16 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
EnterProfileScope scriptScope("SourcePawn", cfun->FullName()); EnterProfileScope scriptScope("SourcePawn", cfun->FullName());
/* See if we have to compile the callee. */ /* See if we have to compile the callee. */
if (g_engine2.IsJitEnabled() && (fn = m_pRuntime->m_PubJitFuncs[public_id]) == NULL) if (g_engine2.IsJitEnabled() &&
(fn = m_pRuntime->m_PubJitFuncs[public_id]) == NULL)
{ {
/* We might not have to - check pcode offset. */ /* We might not have to - check pcode offset. */
fn = m_pRuntime->GetJittedFunctionByOffset(cfun->Public()->code_offs); fn = m_pRuntime->GetJittedFunctionByOffset(cfun->Public()->code_offs);
if (fn) if (fn) {
{
m_pRuntime->m_PubJitFuncs[public_id] = fn; m_pRuntime->m_PubJitFuncs[public_id] = fn;
} } else {
else
{
if ((fn = g_Jit.CompileFunction(m_pRuntime, cfun->Public()->code_offs, &ir)) == NULL) if ((fn = g_Jit.CompileFunction(m_pRuntime, cfun->Public()->code_offs, &ir)) == NULL)
{
return ir; return ir;
}
m_pRuntime->m_PubJitFuncs[public_id] = fn; m_pRuntime->m_PubJitFuncs[public_id] = fn;
} }
} }
@ -617,9 +589,7 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
sp[0] = num_params; sp[0] = num_params;
for (unsigned int i = 0; i < num_params; i++) for (unsigned int i = 0; i < num_params; i++)
{
sp[i + 1] = params[i]; sp[i + 1] = params[i];
}
/* Clear internal state */ /* Clear internal state */
m_ctx.n_err = SP_ERROR_NONE; m_ctx.n_err = SP_ERROR_NONE;
@ -639,25 +609,21 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
m_InExec = save_exec; m_InExec = save_exec;
if (ir == SP_ERROR_NONE) if (ir == SP_ERROR_NONE) {
{
m_ctx.n_err = SP_ERROR_NONE; m_ctx.n_err = SP_ERROR_NONE;
if (m_ctx.sp != save_sp) if (m_ctx.sp != save_sp) {
{
ir = SP_ERROR_STACKLEAK; ir = SP_ERROR_STACKLEAK;
_SetErrorMessage("Stack leak detected: sp:%d should be %d!", _SetErrorMessage("Stack leak detected: sp:%d should be %d!",
m_ctx.sp, m_ctx.sp,
save_sp); save_sp);
} }
if (m_ctx.hp != save_hp) if (m_ctx.hp != save_hp) {
{
ir = SP_ERROR_HEAPLEAK; ir = SP_ERROR_HEAPLEAK;
_SetErrorMessage("Heap leak detected: hp:%d should be %d!", _SetErrorMessage("Heap leak detected: hp:%d should be %d!",
m_ctx.hp, m_ctx.hp,
save_hp); save_hp);
} }
if (m_ctx.rp != save_rp) if (m_ctx.rp != save_rp) {
{
ir = SP_ERROR_STACKLEAK; ir = SP_ERROR_STACKLEAK;
_SetErrorMessage("Return stack leak detected: rp:%d should be %d!", _SetErrorMessage("Return stack leak detected: rp:%d should be %d!",
m_ctx.rp, m_ctx.rp,
@ -669,9 +635,7 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
g_WatchdogTimer.NotifyTimeoutReceived(); g_WatchdogTimer.NotifyTimeoutReceived();
if (ir != SP_ERROR_NONE) if (ir != SP_ERROR_NONE)
{
g_engine1.ReportError(m_pRuntime, ir, m_MsgCache, save_rp); g_engine1.ReportError(m_pRuntime, ir, m_MsgCache, save_rp);
}
m_ctx.sp = save_sp; m_ctx.sp = save_sp;
m_ctx.hp = save_hp; m_ctx.hp = save_hp;
@ -686,7 +650,8 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
return ir; return ir;
} }
IPluginRuntime *BaseContext::GetRuntime() IPluginRuntime *
BaseContext::GetRuntime()
{ {
return m_pRuntime; return m_pRuntime;
} }
@ -697,57 +662,50 @@ DebugInfo::DebugInfo(sp_plugin_t *plugin) : m_pPlugin(plugin)
#define USHR(x) ((unsigned int)(x)>>1) #define USHR(x) ((unsigned int)(x)>>1)
int DebugInfo::LookupFile(ucell_t addr, const char **filename) int
DebugInfo::LookupFile(ucell_t addr, const char **filename)
{ {
int high, low, mid; int high, low, mid;
high = m_pPlugin->debug.files_num; high = m_pPlugin->debug.files_num;
low = -1; low = -1;
while (high - low > 1) while (high - low > 1) {
{
mid = USHR(low + high); mid = USHR(low + high);
if (m_pPlugin->debug.files[mid].addr <= addr) if (m_pPlugin->debug.files[mid].addr <= addr)
{
low = mid; low = mid;
} else { else
high = mid; high = mid;
} }
}
if (low == -1) if (low == -1)
{
return SP_ERROR_NOT_FOUND; return SP_ERROR_NOT_FOUND;
}
*filename = m_pPlugin->debug.stringbase + m_pPlugin->debug.files[low].name; *filename = m_pPlugin->debug.stringbase + m_pPlugin->debug.files[low].name;
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
int DebugInfo::LookupFunction(ucell_t addr, const char **name) int
{ DebugInfo::LookupFunction(ucell_t addr, const char **name)
if (!m_pPlugin->debug.unpacked)
{ {
if (!m_pPlugin->debug.unpacked) {
uint32_t max, iter; uint32_t max, iter;
sp_fdbg_symbol_t *sym; sp_fdbg_symbol_t *sym;
uint8_t *cursor = (uint8_t *)(m_pPlugin->debug.symbols); uint8_t *cursor = (uint8_t *)(m_pPlugin->debug.symbols);
max = m_pPlugin->debug.syms_num; max = m_pPlugin->debug.syms_num;
for (iter = 0; iter < max; iter++) for (iter = 0; iter < max; iter++) {
{
sym = (sp_fdbg_symbol_t *)cursor; sym = (sp_fdbg_symbol_t *)cursor;
if (sym->ident == sp::IDENT_FUNCTION if (sym->ident == sp::IDENT_FUNCTION &&
&& sym->codestart <= addr sym->codestart <= addr &&
&& sym->codeend > addr) sym->codeend > addr)
{ {
*name = m_pPlugin->debug.stringbase + sym->name; *name = m_pPlugin->debug.stringbase + sym->name;
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
if (sym->dimcount > 0) if (sym->dimcount > 0) {
{
cursor += sizeof(sp_fdbg_symbol_t); cursor += sizeof(sp_fdbg_symbol_t);
cursor += sizeof(sp_fdbg_arraydim_t) * sym->dimcount; cursor += sizeof(sp_fdbg_arraydim_t) * sym->dimcount;
continue; continue;
@ -757,28 +715,24 @@ int DebugInfo::LookupFunction(ucell_t addr, const char **name)
} }
return SP_ERROR_NOT_FOUND; return SP_ERROR_NOT_FOUND;
} } else {
else
{
uint32_t max, iter; uint32_t max, iter;
sp_u_fdbg_symbol_t *sym; sp_u_fdbg_symbol_t *sym;
uint8_t *cursor = (uint8_t *)(m_pPlugin->debug.symbols); uint8_t *cursor = (uint8_t *)(m_pPlugin->debug.symbols);
max = m_pPlugin->debug.syms_num; max = m_pPlugin->debug.syms_num;
for (iter = 0; iter < max; iter++) for (iter = 0; iter < max; iter++) {
{
sym = (sp_u_fdbg_symbol_t *)cursor; sym = (sp_u_fdbg_symbol_t *)cursor;
if (sym->ident == sp::IDENT_FUNCTION if (sym->ident == sp::IDENT_FUNCTION &&
&& sym->codestart <= addr sym->codestart <= addr &&
&& sym->codeend > addr) sym->codeend > addr)
{ {
*name = m_pPlugin->debug.stringbase + sym->name; *name = m_pPlugin->debug.stringbase + sym->name;
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
if (sym->dimcount > 0) if (sym->dimcount > 0) {
{
cursor += sizeof(sp_u_fdbg_symbol_t); cursor += sizeof(sp_u_fdbg_symbol_t);
cursor += sizeof(sp_u_fdbg_arraydim_t) * sym->dimcount; cursor += sizeof(sp_u_fdbg_arraydim_t) * sym->dimcount;
continue; continue;
@ -791,28 +745,24 @@ int DebugInfo::LookupFunction(ucell_t addr, const char **name)
} }
} }
int DebugInfo::LookupLine(ucell_t addr, uint32_t *line) int
DebugInfo::LookupLine(ucell_t addr, uint32_t *line)
{ {
int high, low, mid; int high, low, mid;
high = m_pPlugin->debug.lines_num; high = m_pPlugin->debug.lines_num;
low = -1; low = -1;
while (high - low > 1) while (high - low > 1) {
{
mid = USHR(low + high); mid = USHR(low + high);
if (m_pPlugin->debug.lines[mid].addr <= addr) if (m_pPlugin->debug.lines[mid].addr <= addr)
{
low = mid; low = mid;
} else { else
high = mid; high = mid;
} }
}
if (low == -1) if (low == -1)
{
return SP_ERROR_NOT_FOUND; return SP_ERROR_NOT_FOUND;
}
/* Since the CIP occurs BEFORE the line, we have to add one */ /* Since the CIP occurs BEFORE the line, we have to add one */
*line = m_pPlugin->debug.lines[low].line + 1; *line = m_pPlugin->debug.lines[low].line + 1;
@ -822,40 +772,40 @@ int DebugInfo::LookupLine(ucell_t addr, uint32_t *line)
#undef USHR #undef USHR
int BaseContext::GetLastNativeError() int
BaseContext::GetLastNativeError()
{ {
return m_ctx.n_err; return m_ctx.n_err;
} }
cell_t *BaseContext::GetLocalParams() cell_t *
BaseContext::GetLocalParams()
{ {
return (cell_t *)(m_pRuntime->plugin()->memory + m_ctx.frm + (2 * sizeof(cell_t))); return (cell_t *)(m_pRuntime->plugin()->memory + m_ctx.frm + (2 * sizeof(cell_t)));
} }
void BaseContext::SetKey(int k, void *value) void
BaseContext::SetKey(int k, void *value)
{ {
if (k < 1 || k > 4) if (k < 1 || k > 4)
{
return; return;
}
m_keys[k - 1] = value; m_keys[k - 1] = value;
m_keys_set[k - 1] = true; m_keys_set[k - 1] = true;
} }
bool BaseContext::GetKey(int k, void **value) bool
BaseContext::GetKey(int k, void **value)
{ {
if (k < 1 || k > 4 || m_keys_set[k - 1] == false) if (k < 1 || k > 4 || m_keys_set[k - 1] == false)
{
return false; return false;
}
*value = m_keys[k - 1]; *value = m_keys[k - 1];
return true; return true;
} }
void BaseContext::ClearLastNativeError() void
BaseContext::ClearLastNativeError()
{ {
m_ctx.n_err = SP_ERROR_NONE; m_ctx.n_err = SP_ERROR_NONE;
} }

47
sourcepawn/jit/sp_vm_basecontext.h
View File

@ -1,34 +1,15 @@
/** // vim: set sts=2 ts=8 sw=2 tw=99 et:
* vim: set ts=4 : //
* ============================================================================= // Copyright (C) 2006-2015 AlliedModders LLC
* SourcePawn //
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved. // This file is part of SourcePawn. SourcePawn is free software: you can
* ============================================================================= // redistribute it and/or modify it under the terms of the GNU General Public
* // License as published by the Free Software Foundation, either version 3 of
* This program is free software; you can redistribute it and/or modify it under // the License, or (at your option) any later version.
* the terms of the GNU General Public License, version 3.0, as published by the //
* Free Software Foundation. // You should have received a copy of the GNU General Public License along with
* // SourcePawn. If not, see http://www.gnu.org/licenses/.
* This program is distributed in the hope that it will be useful, but WITHOUT //
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*
* Version: $Id$
*/
#ifndef _INCLUDE_SOURCEPAWN_BASECONTEXT_H_ #ifndef _INCLUDE_SOURCEPAWN_BASECONTEXT_H_
#define _INCLUDE_SOURCEPAWN_BASECONTEXT_H_ #define _INCLUDE_SOURCEPAWN_BASECONTEXT_H_
@ -46,6 +27,7 @@ class BaseContext : public IPluginContext
public: public:
BaseContext(BaseRuntime *pRuntime); BaseContext(BaseRuntime *pRuntime);
~BaseContext(); ~BaseContext();
public: //IPluginContext public: //IPluginContext
IVirtualMachine *GetVirtualMachine(); IVirtualMachine *GetVirtualMachine();
sp_context_t *GetContext(); sp_context_t *GetContext();
@ -94,11 +76,14 @@ public: //IPluginContext
bool GetKey(int k, void **value); bool GetKey(int k, void **value);
void Refresh(); void Refresh();
void ClearLastNativeError(); void ClearLastNativeError();
public: public:
bool IsInExec(); bool IsInExec();
private: private:
void SetErrorMessage(const char *msg, va_list ap); void SetErrorMessage(const char *msg, va_list ap);
void _SetErrorMessage(const char *msg, ...); void _SetErrorMessage(const char *msg, ...);
private: private:
cell_t *m_pNullVec; cell_t *m_pNullVec;
cell_t *m_pNullString; cell_t *m_pNullString;