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

Merge pull request #270 from alliedmodders/modernize-vm-style

Browse Source 
Modernize sourcepawn/jit style.
This commit is contained in:
David Anderson 2015-02-23 14:38:28 -08:00
commit 7d64ade621
8 changed files with 1382 additions and 1497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
sourcepawn/jit/engine2.cpp
View File

@ -1,4 +1,15 @@
// vim: set ts=4 sw=4 tw=99 noet: // vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// Copyright (C) 2006-2015 AlliedModders LLC
//
// 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
// the License, or (at your option) any later version.
//
// You should have received a copy of the GNU General Public License along with
// SourcePawn. If not, see http://www.gnu.org/licenses/.
//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -18,27 +29,27 @@ SourcePawnEngine2::SourcePawnEngine2()
jit_enabled_ = true; jit_enabled_ = true;
} }
IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file, int *err) IPluginRuntime *
SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file, int *err)
{ {
sp_file_hdr_t hdr; sp_file_hdr_t hdr;
uint8_t *base; uint8_t *base;
int z_result; int z_result;
int error; int error;
size_t ignore;
BaseRuntime *pRuntime; BaseRuntime *pRuntime;
FILE *fp = fopen(file, "rb"); FILE *fp = fopen(file, "rb");
if (!fp) if (!fp) {
{
error = SP_ERROR_NOT_FOUND; error = SP_ERROR_NOT_FOUND;
goto return_error; goto return_error;
} }
/* Rewind for safety */ /* Rewind for safety */
fread(&hdr, sizeof(sp_file_hdr_t), 1, fp); ignore = fread(&hdr, sizeof(sp_file_hdr_t), 1, fp);
if (hdr.magic != SmxConsts::FILE_MAGIC) if (hdr.magic != SmxConsts::FILE_MAGIC) {
{
error = SP_ERROR_FILE_FORMAT; error = SP_ERROR_FILE_FORMAT;
goto return_error; goto return_error;
} }
@ -56,8 +67,8 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
void *uncompdata = malloc(uncompsize); void *uncompdata = malloc(uncompsize);
void *sectheader = malloc(sectsize); void *sectheader = malloc(sectsize);
fread(sectheader, sectsize, 1, fp); ignore = fread(sectheader, sectsize, 1, fp);
fread(tempbuf, compsize, 1, fp); ignore = fread(tempbuf, compsize, 1, fp);
z_result = uncompress((Bytef *)uncompdata, &destlen, (Bytef *)tempbuf, compsize); z_result = uncompress((Bytef *)uncompdata, &destlen, (Bytef *)tempbuf, compsize);
free(tempbuf); free(tempbuf);
@ -81,7 +92,7 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
{ {
base = (uint8_t *)malloc(hdr.imagesize); base = (uint8_t *)malloc(hdr.imagesize);
rewind(fp); rewind(fp);
fread(base, hdr.imagesize, 1, fp); ignore = fread(base, hdr.imagesize, 1, fp);
break; break;
} }
default: default:
@ -92,8 +103,7 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
} }
pRuntime = new BaseRuntime(); pRuntime = new BaseRuntime();
if ((error = pRuntime->CreateFromMemory(&hdr, base)) != SP_ERROR_NONE) if ((error = pRuntime->CreateFromMemory(&hdr, base)) != SP_ERROR_NONE) {
{
delete pRuntime; delete pRuntime;
goto return_error; goto return_error;
} }
@ -114,10 +124,10 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
} }
} }
(void)ignore;
if (!pRuntime->plugin()->name) if (!pRuntime->plugin()->name)
{
pRuntime->SetName(file); pRuntime->SetName(file);
}
pRuntime->ApplyCompilationOptions(co); pRuntime->ApplyCompilationOptions(co);
@ -135,65 +145,74 @@ return_error:
return NULL; return NULL;
} }
SPVM_NATIVE_FUNC SourcePawnEngine2::CreateFakeNative(SPVM_FAKENATIVE_FUNC callback, void *pData) SPVM_NATIVE_FUNC
SourcePawnEngine2::CreateFakeNative(SPVM_FAKENATIVE_FUNC callback, void *pData)
{ {
return g_Jit.CreateFakeNative(callback, pData); return g_Jit.CreateFakeNative(callback, pData);
} }
void SourcePawnEngine2::DestroyFakeNative(SPVM_NATIVE_FUNC func) void
SourcePawnEngine2::DestroyFakeNative(SPVM_NATIVE_FUNC func)
{ {
g_Jit.DestroyFakeNative(func); g_Jit.DestroyFakeNative(func);
} }
const char *SourcePawnEngine2::GetEngineName() const char *
SourcePawnEngine2::GetEngineName()
{ {
return "SourcePawn 1.7, jit-x86"; return "SourcePawn 1.7, jit-x86";
} }
const char *SourcePawnEngine2::GetVersionString() const char *
SourcePawnEngine2::GetVersionString()
{ {
return SOURCEMOD_VERSION; return SOURCEMOD_VERSION;
} }
IDebugListener *SourcePawnEngine2::SetDebugListener(IDebugListener *listener) IDebugListener *
SourcePawnEngine2::SetDebugListener(IDebugListener *listener)
{ {
return g_engine1.SetDebugListener(listener); return g_engine1.SetDebugListener(listener);
} }
unsigned int SourcePawnEngine2::GetAPIVersion() unsigned int
SourcePawnEngine2::GetAPIVersion()
{ {
return SOURCEPAWN_ENGINE2_API_VERSION; return SOURCEPAWN_ENGINE2_API_VERSION;
} }
ICompilation *SourcePawnEngine2::StartCompilation() ICompilation *
SourcePawnEngine2::StartCompilation()
{ {
return g_Jit.StartCompilation(); return g_Jit.StartCompilation();
} }
const char *SourcePawnEngine2::GetErrorString(int err) const char *
SourcePawnEngine2::GetErrorString(int err)
{ {
return g_engine1.GetErrorString(err); return g_engine1.GetErrorString(err);
} }
bool SourcePawnEngine2::Initialize() bool
SourcePawnEngine2::Initialize()
{ {
return g_Jit.InitializeJIT(); return g_Jit.InitializeJIT();
} }
void SourcePawnEngine2::Shutdown() void
SourcePawnEngine2::Shutdown()
{ {
g_WatchdogTimer.Shutdown(); g_WatchdogTimer.Shutdown();
g_Jit.ShutdownJIT(); g_Jit.ShutdownJIT();
} }
IPluginRuntime *SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t memory) IPluginRuntime *
SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t memory)
{ {
int err; int err;
BaseRuntime *rt;
rt = new BaseRuntime(); BaseRuntime *rt = new BaseRuntime();
if ((err = rt->CreateBlank(memory)) != SP_ERROR_NONE) if ((err = rt->CreateBlank(memory)) != SP_ERROR_NONE) {
{
delete rt; delete rt;
return NULL; return NULL;
} }
@ -205,7 +224,8 @@ IPluginRuntime *SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t
return rt; return rt;
} }
bool SourcePawnEngine2::InstallWatchdogTimer(size_t timeout_ms) bool
SourcePawnEngine2::InstallWatchdogTimer(size_t timeout_ms)
{ {
return g_WatchdogTimer.Initialize(timeout_ms); return g_WatchdogTimer.Initialize(timeout_ms);
} }

32
sourcepawn/jit/engine2.h
View File

@ -1,18 +1,30 @@
// vim: set ts=4 sw=4 tw=99 noet: // vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// Copyright (C) 2006-2015 AlliedModders LLC
//
// 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
// the License, or (at your option) any later version.
//
// You should have received a copy of the GNU General Public License along with
// SourcePawn. If not, see http://www.gnu.org/licenses/.
//
#ifndef _INCLUDE_SOURCEPAWN_ENGINE_2_H_ #ifndef _INCLUDE_SOURCEPAWN_ENGINE_2_H_
#define _INCLUDE_SOURCEPAWN_ENGINE_2_H_ #define _INCLUDE_SOURCEPAWN_ENGINE_2_H_
#include <sp_vm_api.h> #include <sp_vm_api.h>
namespace SourcePawn namespace SourcePawn {
{
/** /**
* @brief Outlines the interface a Virtual Machine (JIT) must expose * @brief Outlines the interface a Virtual Machine (JIT) must expose
*/ */
class SourcePawnEngine2 : public ISourcePawnEngine2 class SourcePawnEngine2 : public ISourcePawnEngine2
{ {
public: public:
SourcePawnEngine2(); SourcePawnEngine2();
public: public:
unsigned int GetAPIVersion(); unsigned int GetAPIVersion();
const char *GetEngineName(); const char *GetEngineName();
@ -58,18 +70,20 @@ namespace SourcePawn
IProfilingTool *GetProfiler() { IProfilingTool *GetProfiler() {
return profiler_; return profiler_;
} }
private: private:
IProfilingTool *profiler_; IProfilingTool *profiler_;
bool jit_enabled_; bool jit_enabled_;
bool profiling_enabled_; bool profiling_enabled_;
}; };
}
} // namespace SourcePawn
extern SourcePawn::SourcePawnEngine2 g_engine2; extern SourcePawn::SourcePawnEngine2 g_engine2;
class EnterProfileScope class EnterProfileScope
{ {
public: public:
EnterProfileScope(const char *group, const char *name) EnterProfileScope(const char *group, const char *name)
{ {
if (g_engine2.IsProfilingEnabled()) if (g_engine2.IsProfilingEnabled())

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;
} }

57
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_
@ -43,10 +24,11 @@
class BaseContext : public IPluginContext 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();
sp_context_t *GetCtx(); sp_context_t *GetCtx();
@ -94,12 +76,15 @@ 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;
char m_MsgCache[1024]; char m_MsgCache[1024];

167
sourcepawn/jit/sp_vm_engine.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 et: //
* ============================================================================= // 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 <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <assert.h> #include <assert.h>
@ -93,13 +74,11 @@ static const char *g_ErrorMsgTable[] =
"Script execution timed out" "Script execution timed out"
}; };
const char *SourcePawnEngine::GetErrorString(int error) const char *
SourcePawnEngine::GetErrorString(int error)
{ {
if (error < 1 || error > ERROR_MESSAGE_MAX) if (error < 1 || error > ERROR_MESSAGE_MAX)
{
return NULL; return NULL;
}
return g_ErrorMsgTable[error]; return g_ErrorMsgTable[error];
} }
@ -112,7 +91,8 @@ SourcePawnEngine::~SourcePawnEngine()
{ {
} }
void *SourcePawnEngine::ExecAlloc(size_t size) void *
SourcePawnEngine::ExecAlloc(size_t size)
{ {
#if defined WIN32 #if defined WIN32
return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE); return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
@ -122,8 +102,7 @@ void *SourcePawnEngine::ExecAlloc(size_t size)
# else # else
void *base = memalign(sysconf(_SC_PAGESIZE), size); void *base = memalign(sysconf(_SC_PAGESIZE), size);
# endif # endif
if (mprotect(base, size, PROT_READ|PROT_WRITE|PROT_EXEC) != 0) if (mprotect(base, size, PROT_READ|PROT_WRITE|PROT_EXEC) != 0) {
{
free(base); free(base);
return NULL; return NULL;
} }
@ -131,27 +110,32 @@ void *SourcePawnEngine::ExecAlloc(size_t size)
#endif #endif
} }
void *SourcePawnEngine::AllocatePageMemory(size_t size) void *
SourcePawnEngine::AllocatePageMemory(size_t size)
{ {
return g_Jit.AllocCode(size); return g_Jit.AllocCode(size);
} }
void SourcePawnEngine::SetReadExecute(void *ptr) void
SourcePawnEngine::SetReadExecute(void *ptr)
{ {
/* already re */ /* already re */
} }
void SourcePawnEngine::SetReadWrite(void *ptr) void
SourcePawnEngine::SetReadWrite(void *ptr)
{ {
/* already rw */ /* already rw */
} }
void SourcePawnEngine::FreePageMemory(void *ptr) void
SourcePawnEngine::FreePageMemory(void *ptr)
{ {
g_Jit.FreeCode(ptr); g_Jit.FreeCode(ptr);
} }
void SourcePawnEngine::ExecFree(void *address) void
SourcePawnEngine::ExecFree(void *address)
{ {
#if defined WIN32 #if defined WIN32
VirtualFree(address, 0, MEM_RELEASE); VirtualFree(address, 0, MEM_RELEASE);
@ -160,48 +144,51 @@ void SourcePawnEngine::ExecFree(void *address)
#endif #endif
} }
void SourcePawnEngine::SetReadWriteExecute(void *ptr) void
SourcePawnEngine::SetReadWriteExecute(void *ptr)
{ {
//:TODO: g_ExeMemory.SetRWE(ptr); //:TODO: g_ExeMemory.SetRWE(ptr);
SetReadExecute(ptr); SetReadExecute(ptr);
} }
void *SourcePawnEngine::BaseAlloc(size_t size) void *
SourcePawnEngine::BaseAlloc(size_t size)
{ {
return malloc(size); return malloc(size);
} }
void SourcePawnEngine::BaseFree(void *memory) void
SourcePawnEngine::BaseFree(void *memory)
{ {
free(memory); free(memory);
} }
sp_plugin_t *SourcePawnEngine::LoadFromFilePointer(FILE *fp, int *err) sp_plugin_t *
SourcePawnEngine::LoadFromFilePointer(FILE *fp, int *err)
{ {
if (err != NULL) if (err != NULL)
{
*err = SP_ERROR_ABORTED; *err = SP_ERROR_ABORTED;
}
return NULL; return NULL;
} }
sp_plugin_t *SourcePawnEngine::LoadFromMemory(void *base, sp_plugin_t *plugin, int *err) sp_plugin_t *
SourcePawnEngine::LoadFromMemory(void *base, sp_plugin_t *plugin, int *err)
{ {
if (err != NULL) if (err != NULL)
{
*err = SP_ERROR_ABORTED; *err = SP_ERROR_ABORTED;
}
return NULL; return NULL;
} }
int SourcePawnEngine::FreeFromMemory(sp_plugin_t *plugin) int
SourcePawnEngine::FreeFromMemory(sp_plugin_t *plugin)
{ {
return SP_ERROR_ABORTED; return SP_ERROR_ABORTED;
} }
IDebugListener *SourcePawnEngine::SetDebugListener(IDebugListener *pListener) IDebugListener *
SourcePawnEngine::SetDebugListener(IDebugListener *pListener)
{ {
IDebugListener *old = m_pDebugHook; IDebugListener *old = m_pDebugHook;
@ -210,22 +197,23 @@ IDebugListener *SourcePawnEngine::SetDebugListener(IDebugListener *pListener)
return old; return old;
} }
unsigned int SourcePawnEngine::GetEngineAPIVersion() unsigned int
SourcePawnEngine::GetEngineAPIVersion()
{ {
return SOURCEPAWN_ENGINE_API_VERSION; return SOURCEPAWN_ENGINE_API_VERSION;
} }
unsigned int SourcePawnEngine::GetContextCallCount() unsigned int
SourcePawnEngine::GetContextCallCount()
{ {
return 0; return 0;
} }
void SourcePawnEngine::ReportError(BaseRuntime *runtime, int err, const char *errstr, cell_t rp_start) void
SourcePawnEngine::ReportError(BaseRuntime *runtime, int err, const char *errstr, cell_t rp_start)
{ {
if (m_pDebugHook == NULL) if (m_pDebugHook == NULL)
{
return; return;
}
CContextTrace trace(runtime, err, errstr, rp_start); CContextTrace trace(runtime, err, errstr, rp_start);
@ -233,54 +221,56 @@ void SourcePawnEngine::ReportError(BaseRuntime *runtime, int err, const char *er
} }
CContextTrace::CContextTrace(BaseRuntime *pRuntime, int err, const char *errstr, cell_t start_rp) CContextTrace::CContextTrace(BaseRuntime *pRuntime, int err, const char *errstr, cell_t start_rp)
: m_pRuntime(pRuntime), m_Error(err), m_pMsg(errstr), m_StartRp(start_rp), m_Level(0) : m_pRuntime(pRuntime),
m_Error(err),
m_pMsg(errstr),
m_StartRp(start_rp),
m_Level(0)
{ {
m_ctx = pRuntime->m_pCtx->GetCtx(); m_ctx = pRuntime->m_pCtx->GetCtx();
m_pDebug = m_pRuntime->GetDebugInfo(); m_pDebug = m_pRuntime->GetDebugInfo();
} }
bool CContextTrace::DebugInfoAvailable() bool
CContextTrace::DebugInfoAvailable()
{ {
return (m_pDebug != NULL); return (m_pDebug != NULL);
} }
const char *CContextTrace::GetCustomErrorString() const char *
CContextTrace::GetCustomErrorString()
{ {
return m_pMsg; return m_pMsg;
} }
int CContextTrace::GetErrorCode() int
CContextTrace::GetErrorCode()
{ {
return m_Error; return m_Error;
} }
const char *CContextTrace::GetErrorString() const char *
CContextTrace::GetErrorString()
{ {
if (m_Error > ERROR_MESSAGE_MAX || m_Error < 1) if (m_Error > ERROR_MESSAGE_MAX || m_Error < 1)
{
return "Invalid error code"; return "Invalid error code";
}
else
{
return g_ErrorMsgTable[m_Error]; return g_ErrorMsgTable[m_Error];
}
} }
void CContextTrace::ResetTrace() void
CContextTrace::ResetTrace()
{ {
m_Level = 0; m_Level = 0;
} }
bool CContextTrace::GetTraceInfo(CallStackInfo *trace) bool
CContextTrace::GetTraceInfo(CallStackInfo *trace)
{ {
cell_t cip; cell_t cip;
if (m_Level == 0) if (m_Level == 0) {
{
cip = m_ctx->cip; cip = m_ctx->cip;
} } else if (m_ctx->rp > 0) {
else if (m_ctx->rp > 0)
{
/* Entries go from ctx.rp - 1 to m_StartRp */ /* Entries go from ctx.rp - 1 to m_StartRp */
cell_t offs, start, end; cell_t offs, start, end;
@ -294,60 +284,47 @@ bool CContextTrace::GetTraceInfo(CallStackInfo *trace)
} }
cip = m_ctx->rstk_cips[start - offs]; cip = m_ctx->rstk_cips[start - offs];
} } else {
else
{
return false; return false;
} }
if (trace == NULL) if (trace == NULL) {
{
m_Level++; m_Level++;
return true; return true;
} }
if (m_pDebug->LookupFile(cip, &(trace->filename)) != SP_ERROR_NONE) if (m_pDebug->LookupFile(cip, &(trace->filename)) != SP_ERROR_NONE)
{
trace->filename = NULL; trace->filename = NULL;
}
if (m_pDebug->LookupFunction(cip, &(trace->function)) != SP_ERROR_NONE) if (m_pDebug->LookupFunction(cip, &(trace->function)) != SP_ERROR_NONE)
{
trace->function = NULL; trace->function = NULL;
}
if (m_pDebug->LookupLine(cip, &(trace->line)) != SP_ERROR_NONE) if (m_pDebug->LookupLine(cip, &(trace->line)) != SP_ERROR_NONE)
{
trace->line = 0; trace->line = 0;
}
m_Level++; m_Level++;
return true; return true;
} }
const char *CContextTrace::GetLastNative(uint32_t *index) const char *
CContextTrace::GetLastNative(uint32_t *index)
{ {
if (m_ctx->n_err == SP_ERROR_NONE) if (m_ctx->n_err == SP_ERROR_NONE)
{
return NULL; return NULL;
}
sp_native_t *native; sp_native_t *native;
if (m_pRuntime->GetNativeByIndex(m_ctx->n_idx, &native) != SP_ERROR_NONE) if (m_pRuntime->GetNativeByIndex(m_ctx->n_idx, &native) != SP_ERROR_NONE)
{
return NULL; return NULL;
}
if (index) if (index)
{
*index = m_ctx->n_idx; *index = m_ctx->n_idx;
}
return native->name; return native->name;
} }
IDebugListener *SourcePawnEngine::GetDebugHook() IDebugListener *
SourcePawnEngine::GetDebugHook()
{ {
return m_pDebugHook; return m_pDebugHook;
} }

62
sourcepawn/jit/sp_vm_engine.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_VM_ENGINE_H_ #ifndef _INCLUDE_SOURCEPAWN_VM_ENGINE_H_
#define _INCLUDE_SOURCEPAWN_VM_ENGINE_H_ #define _INCLUDE_SOURCEPAWN_VM_ENGINE_H_
@ -39,9 +20,10 @@ class BaseContext;
class CContextTrace : public IContextTrace class CContextTrace : public IContextTrace
{ {
public: public:
CContextTrace(BaseRuntime *pRuntime, int err, const char *errstr, cell_t start_rp); CContextTrace(BaseRuntime *pRuntime, int err, const char *errstr, cell_t start_rp);
public:
public:
int GetErrorCode(); int GetErrorCode();
const char *GetErrorString(); const char *GetErrorString();
bool DebugInfoAvailable(); bool DebugInfoAvailable();
@ -49,7 +31,8 @@ public:
bool GetTraceInfo(CallStackInfo *trace); bool GetTraceInfo(CallStackInfo *trace);
void ResetTrace(); void ResetTrace();
const char *GetLastNative(uint32_t *index); const char *GetLastNative(uint32_t *index);
private:
private:
BaseRuntime *m_pRuntime; BaseRuntime *m_pRuntime;
sp_context_t *m_ctx; sp_context_t *m_ctx;
int m_Error; int m_Error;
@ -61,10 +44,11 @@ private:
class SourcePawnEngine : public ISourcePawnEngine class SourcePawnEngine : public ISourcePawnEngine
{ {
public: public:
SourcePawnEngine(); SourcePawnEngine();
~SourcePawnEngine(); ~SourcePawnEngine();
public: //ISourcePawnEngine
public: //ISourcePawnEngine
sp_plugin_t *LoadFromFilePointer(FILE *fp, int *err); sp_plugin_t *LoadFromFilePointer(FILE *fp, int *err);
sp_plugin_t *LoadFromMemory(void *base, sp_plugin_t *plugin, int *err); sp_plugin_t *LoadFromMemory(void *base, sp_plugin_t *plugin, int *err);
int FreeFromMemory(sp_plugin_t *plugin); int FreeFromMemory(sp_plugin_t *plugin);
@ -82,11 +66,13 @@ public: //ISourcePawnEngine
void FreePageMemory(void *ptr); void FreePageMemory(void *ptr);
const char *GetErrorString(int err); const char *GetErrorString(int err);
void ReportError(BaseRuntime *runtime, int err, const char *errstr, cell_t rp_start); void ReportError(BaseRuntime *runtime, int err, const char *errstr, cell_t rp_start);
public: //Plugin function stuff
public: //Plugin function stuff
CFunction *GetFunctionFromPool(funcid_t f, IPluginContext *plugin); CFunction *GetFunctionFromPool(funcid_t f, IPluginContext *plugin);
void ReleaseFunctionToPool(CFunction *func); void ReleaseFunctionToPool(CFunction *func);
IDebugListener *GetDebugHook(); IDebugListener *GetDebugHook();
private:
private:
IDebugListener *m_pDebugHook; IDebugListener *m_pDebugHook;
}; };

164
sourcepawn/jit/sp_vm_function.cpp
View File

@ -1,31 +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-2009 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>.
*/
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@ -41,28 +25,34 @@ CFunction::~CFunction()
delete [] full_name_; delete [] full_name_;
} }
bool CFunction::IsRunnable() bool
CFunction::IsRunnable()
{ {
return !m_pRuntime->IsPaused(); return !m_pRuntime->IsPaused();
} }
int CFunction::CallFunction(const cell_t *params, unsigned int num_params, cell_t *result) int
CFunction::CallFunction(const cell_t *params, unsigned int num_params, cell_t *result)
{ {
return CallFunction2(m_pRuntime->GetDefaultContext(), params, num_params, result); return CallFunction2(m_pRuntime->GetDefaultContext(), params, num_params, result);
} }
int CFunction::CallFunction2(IPluginContext *pContext, const cell_t *params, unsigned int num_params, cell_t *result) int
CFunction::CallFunction2(IPluginContext *pContext, const cell_t *params, unsigned int num_params, cell_t *result)
{ {
return pContext->Execute2(this, params, num_params, result); return pContext->Execute2(this, params, num_params, result);
} }
IPluginContext *CFunction::GetParentContext() IPluginContext *
CFunction::GetParentContext()
{ {
return m_pRuntime->GetDefaultContext(); return m_pRuntime->GetDefaultContext();
} }
CFunction::CFunction(BaseRuntime *runtime, funcid_t id, uint32_t pub_id) : CFunction::CFunction(BaseRuntime *runtime, funcid_t id, uint32_t pub_id)
m_curparam(0), m_errorstate(SP_ERROR_NONE), m_FnId(id) : m_curparam(0),
m_errorstate(SP_ERROR_NONE),
m_FnId(id)
{ {
m_pRuntime = runtime; m_pRuntime = runtime;
@ -80,9 +70,7 @@ CFunction::CFunction(BaseRuntime *runtime, funcid_t id, uint32_t pub_id) :
int CFunction::PushCell(cell_t cell) int CFunction::PushCell(cell_t cell)
{ {
if (m_curparam >= SP_MAX_EXEC_PARAMS) if (m_curparam >= SP_MAX_EXEC_PARAMS)
{
return SetError(SP_ERROR_PARAMS_MAX); return SetError(SP_ERROR_PARAMS_MAX);
}
m_info[m_curparam].marked = false; m_info[m_curparam].marked = false;
m_params[m_curparam] = cell; m_params[m_curparam] = cell;
@ -91,24 +79,28 @@ int CFunction::PushCell(cell_t cell)
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
int CFunction::PushCellByRef(cell_t *cell, int flags) int
CFunction::PushCellByRef(cell_t *cell, int flags)
{ {
return PushArray(cell, 1, flags); return PushArray(cell, 1, flags);
} }
int CFunction::PushFloat(float number) int
CFunction::PushFloat(float number)
{ {
cell_t val = *(cell_t *)&number; cell_t val = *(cell_t *)&number;
return PushCell(val); return PushCell(val);
} }
int CFunction::PushFloatByRef(float *number, int flags) int
CFunction::PushFloatByRef(float *number, int flags)
{ {
return PushCellByRef((cell_t *)number, flags); return PushCellByRef((cell_t *)number, flags);
} }
int CFunction::PushArray(cell_t *inarray, unsigned int cells, int copyback) int
CFunction::PushArray(cell_t *inarray, unsigned int cells, int copyback)
{ {
if (m_curparam >= SP_MAX_EXEC_PARAMS) if (m_curparam >= SP_MAX_EXEC_PARAMS)
{ {
@ -128,22 +120,23 @@ int CFunction::PushArray(cell_t *inarray, unsigned int cells, int copyback)
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
int CFunction::PushString(const char *string) int
CFunction::PushString(const char *string)
{ {
return _PushString(string, SM_PARAM_STRING_COPY, 0, strlen(string)+1); return _PushString(string, SM_PARAM_STRING_COPY, 0, strlen(string)+1);
} }
int CFunction::PushStringEx(char *buffer, size_t length, int sz_flags, int cp_flags) int
CFunction::PushStringEx(char *buffer, size_t length, int sz_flags, int cp_flags)
{ {
return _PushString(buffer, sz_flags, cp_flags, length); return _PushString(buffer, sz_flags, cp_flags, length);
} }
int CFunction::_PushString(const char *string, int sz_flags, int cp_flags, size_t len) int
CFunction::_PushString(const char *string, int sz_flags, int cp_flags, size_t len)
{ {
if (m_curparam >= SP_MAX_EXEC_PARAMS) if (m_curparam >= SP_MAX_EXEC_PARAMS)
{
return SetError(SP_ERROR_PARAMS_MAX); return SetError(SP_ERROR_PARAMS_MAX);
}
ParamInfo *info = &m_info[m_curparam]; ParamInfo *info = &m_info[m_curparam];
@ -159,33 +152,31 @@ int CFunction::_PushString(const char *string, int sz_flags, int cp_flags, size_
return SP_ERROR_NONE; return SP_ERROR_NONE;
} }
void CFunction::Cancel() void
CFunction::Cancel()
{ {
if (!m_curparam) if (!m_curparam)
{
return; return;
}
m_errorstate = SP_ERROR_NONE; m_errorstate = SP_ERROR_NONE;
m_curparam = 0; m_curparam = 0;
} }
int CFunction::Execute(cell_t *result) int
CFunction::Execute(cell_t *result)
{ {
return Execute2(m_pRuntime->GetDefaultContext(), result); return Execute2(m_pRuntime->GetDefaultContext(), result);
} }
int CFunction::Execute2(IPluginContext *ctx, cell_t *result) int
CFunction::Execute2(IPluginContext *ctx, cell_t *result)
{ {
int err = SP_ERROR_NONE; int err = SP_ERROR_NONE;
if (!IsRunnable()) if (!IsRunnable())
{
m_errorstate = SP_ERROR_NOT_RUNNABLE; m_errorstate = SP_ERROR_NOT_RUNNABLE;
}
if (m_errorstate != SP_ERROR_NONE) if (m_errorstate != SP_ERROR_NONE) {
{
err = m_errorstate; err = m_errorstate;
Cancel(); Cancel();
return err; return err;
@ -206,13 +197,10 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
m_curparam = 0; m_curparam = 0;
/* Browse the parameters and build arrays */ /* Browse the parameters and build arrays */
for (i=0; i<numparams; i++) for (i=0; i<numparams; i++) {
{
/* Is this marked as an array? */ /* Is this marked as an array? */
if (temp_info[i].marked) if (temp_info[i].marked) {
{ if (!temp_info[i].str.is_sz) {
if (!temp_info[i].str.is_sz)
{
/* Allocate a normal/generic array */ /* Allocate a normal/generic array */
if ((err=ctx->HeapAlloc(temp_info[i].size, if ((err=ctx->HeapAlloc(temp_info[i].size,
&(temp_info[i].local_addr), &(temp_info[i].local_addr),
@ -225,9 +213,7 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
{ {
memcpy(temp_info[i].phys_addr, temp_info[i].orig_addr, sizeof(cell_t) * temp_info[i].size); memcpy(temp_info[i].phys_addr, temp_info[i].orig_addr, sizeof(cell_t) * temp_info[i].size);
} }
} } else {
else
{
/* Calculate cells required for the string */ /* Calculate cells required for the string */
size_t cells = (temp_info[i].size + sizeof(cell_t) - 1) / sizeof(cell_t); size_t cells = (temp_info[i].size + sizeof(cell_t) - 1) / sizeof(cell_t);
@ -243,8 +229,7 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
if ((temp_info[i].str.sz_flags & SM_PARAM_STRING_COPY) && (temp_info[i].orig_addr != NULL)) if ((temp_info[i].str.sz_flags & SM_PARAM_STRING_COPY) && (temp_info[i].orig_addr != NULL))
{ {
/* Cut off UTF-8 properly */ /* Cut off UTF-8 properly */
if (temp_info[i].str.sz_flags & SM_PARAM_STRING_UTF8) if (temp_info[i].str.sz_flags & SM_PARAM_STRING_UTF8) {
{
if ((err=ctx->StringToLocalUTF8(temp_info[i].local_addr, if ((err=ctx->StringToLocalUTF8(temp_info[i].local_addr,
temp_info[i].size, temp_info[i].size,
(const char *)temp_info[i].orig_addr, (const char *)temp_info[i].orig_addr,
@ -274,52 +259,34 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
} /* End array/string calculation */ } /* End array/string calculation */
/* Update the pushed parameter with the byref local address */ /* Update the pushed parameter with the byref local address */
temp_params[i] = temp_info[i].local_addr; temp_params[i] = temp_info[i].local_addr;
} } else {
else
{
/* Just copy the value normally */ /* Just copy the value normally */
temp_params[i] = m_params[i]; temp_params[i] = m_params[i];
} }
} }
/* Make the call if we can */ /* Make the call if we can */
if (err == SP_ERROR_NONE) if (err == SP_ERROR_NONE) {
{
if ((err = CallFunction2(ctx, temp_params, numparams, result)) != SP_ERROR_NONE) if ((err = CallFunction2(ctx, temp_params, numparams, result)) != SP_ERROR_NONE)
{
docopies = false; docopies = false;
} } else {
}
else
{
docopies = false; docopies = false;
} }
/* i should be equal to the last valid parameter + 1 */ /* i should be equal to the last valid parameter + 1 */
while (i--) while (i--) {
{
if (!temp_info[i].marked) if (!temp_info[i].marked)
{
continue; continue;
}
if (docopies && (temp_info[i].flags & SM_PARAM_COPYBACK)) if (docopies && (temp_info[i].flags & SM_PARAM_COPYBACK)) {
{ if (temp_info[i].orig_addr) {
if (temp_info[i].orig_addr) if (temp_info[i].str.is_sz) {
{
if (temp_info[i].str.is_sz)
{
memcpy(temp_info[i].orig_addr, temp_info[i].phys_addr, temp_info[i].size); memcpy(temp_info[i].orig_addr, temp_info[i].phys_addr, temp_info[i].size);
} } else {
else if (temp_info[i].size == 1) {
{
if (temp_info[i].size == 1)
{
*temp_info[i].orig_addr = *(temp_info[i].phys_addr); *temp_info[i].orig_addr = *(temp_info[i].phys_addr);
} } else {
else
{
memcpy(temp_info[i].orig_addr, memcpy(temp_info[i].orig_addr,
temp_info[i].phys_addr, temp_info[i].phys_addr,
temp_info[i].size * sizeof(cell_t)); temp_info[i].size * sizeof(cell_t));
@ -329,25 +296,26 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
} }
if ((err=ctx->HeapPop(temp_info[i].local_addr)) != SP_ERROR_NONE) if ((err=ctx->HeapPop(temp_info[i].local_addr)) != SP_ERROR_NONE)
{
return err; return err;
} }
}
return err; return err;
} }
IPluginRuntime *CFunction::GetParentRuntime() IPluginRuntime *
CFunction::GetParentRuntime()
{ {
return m_pRuntime; return m_pRuntime;
} }
funcid_t CFunction::GetFunctionID() funcid_t
CFunction::GetFunctionID()
{ {
return m_FnId; return m_FnId;
} }
int CFunction::SetError(int err) int
CFunction::SetError(int err)
{ {
m_errorstate = err; m_errorstate = err;

63
sourcepawn/jit/sp_vm_function.h
View File

@ -1,32 +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-2009 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>.
*/
#ifndef _INCLUDE_SOURCEMOD_BASEFUNCTION_H_ #ifndef _INCLUDE_SOURCEMOD_BASEFUNCTION_H_
#define _INCLUDE_SOURCEMOD_BASEFUNCTION_H_ #define _INCLUDE_SOURCEMOD_BASEFUNCTION_H_
@ -44,8 +27,7 @@ struct ParamInfo
cell_t *phys_addr; /* Physical address of our copy */ cell_t *phys_addr; /* Physical address of our copy */
cell_t *orig_addr; /* Original address to copy back to */ cell_t *orig_addr; /* Original address to copy back to */
ucell_t size; /* Size of array in bytes */ ucell_t size; /* Size of array in bytes */
struct struct {
{
bool is_sz; /* is a string */ bool is_sz; /* is a string */
int sz_flags; /* has sz flags */ int sz_flags; /* has sz flags */
} str; } str;
@ -57,12 +39,12 @@ class JitFunction;
class CFunction : public IPluginFunction class CFunction : public IPluginFunction
{ {
friend class SourcePawnEngine; friend class SourcePawnEngine;
public:
CFunction(BaseRuntime *pRuntime, public:
funcid_t fnid, CFunction(BaseRuntime *pRuntime, funcid_t fnid, uint32_t pub_id);
uint32_t pub_id);
~CFunction(); ~CFunction();
public:
public:
virtual int PushCell(cell_t cell); virtual int PushCell(cell_t cell);
virtual int PushCellByRef(cell_t *cell, int flags); virtual int PushCellByRef(cell_t *cell, int flags);
virtual int PushFloat(float number); virtual int PushFloat(float number);
@ -82,17 +64,20 @@ public:
unsigned int num_params, unsigned int num_params,
cell_t *result); cell_t *result);
IPluginRuntime *GetParentRuntime(); IPluginRuntime *GetParentRuntime();
public:
public:
const char *FullName() const { const char *FullName() const {
return full_name_; return full_name_;
} }
sp_public_t *Public() const { sp_public_t *Public() const {
return public_; return public_;
} }
private:
private:
int _PushString(const char *string, int sz_flags, int cp_flags, size_t len); int _PushString(const char *string, int sz_flags, int cp_flags, size_t len);
int SetError(int err); int SetError(int err);
private:
private:
BaseRuntime *m_pRuntime; BaseRuntime *m_pRuntime;
cell_t m_params[SP_MAX_EXEC_PARAMS]; cell_t m_params[SP_MAX_EXEC_PARAMS];
ParamInfo m_info[SP_MAX_EXEC_PARAMS]; ParamInfo m_info[SP_MAX_EXEC_PARAMS];