repo: implement fast pcall & implement missing gc barrier

Author: RaphaelIT7

source/lua.cpp

@@ -267,7 +267,7 @@ LuaUserData* Lua::GetHolyLibUserData(GarrysMod::Lua::ILuaInterface * LUA, int nS
 	GCudata* luaData = udataV(val); // Very "safe" I know :3
 	if (luaData->udtype >= GarrysMod::Lua::Type::UserData)
 	{
-		return (LuaUserData*)luaData;
+		return static_cast<LuaUserData*>(static_cast<void*>(luaData));
 	}
 
 	return nullptr;
@@ -457,6 +457,11 @@ void Lua::CreateLuaData(GarrysMod::Lua::ILuaInterface* LUA, bool bNullOut)
 	Lua::StateData* data = new Lua::StateData;
 	data->pLua = LUA;
 	data->pProxy = new CLuaInterfaceProxy(LUA);
+	
+	CLuaInterface* pLua = (CLuaInterface*)LUA;
+	LUA->ReferencePush(pLua->m_nLuaErrorReporter);
+	data->SetErrorFunc();
+
 	*reinterpret_cast<Lua::StateData**>(pathID + 24) = data;
 	g_pLuaStates.insert(data);
 	Msg("holylib - Created thread data %p (%s)\n", data, pathID);

source/lua.h

@@ -83,6 +83,11 @@ namespace Lua
 	struct LuaMetaEntry {
 		unsigned char iType = UCHAR_MAX;
 		GCRef metatable; // Direct reference allowing for faster setting.
+
+		LuaMetaEntry()
+		{
+			setgcrefnull(metatable);
+		}
 	};
 
 	/*
@@ -141,9 +146,31 @@ namespace Lua
 		std::unordered_map<void*, LuaUserData*> pPushedUserData; // Would love to get rid of this
 		GarrysMod::Lua::ILuaInterface* pLua = NULL;
 		CLuaInterfaceProxy* pProxy;
+		GCRef nErrorFunc;
+
+		StateData()
+		{
+			setgcrefnull(nErrorFunc);
+		}
 
 		~StateData();
 
+		// When called we expect the error function to be pushed onto the stack. We'll pop it.
+		inline void SetErrorFunc()
+		{
+			lua_State* L = pLua->GetState();
+			TValue* pVal = RawLua::index2adr(L, -1);
+			if (!tvistab(pVal))
+			{
+				Warning(PROJECT_NAME " - RegisterMetaTable: MetaTable is NOT a table?!? What the heck!\n");
+				pLua->Pop(1);
+				return;
+			}
+
+			setgcref(nErrorFunc, obj2gco(tabV(pVal)));
+			pLua->Pop(1); // it's stored in the registry so everything will be fine :3
+		}
+
 		inline void RegisterMetaTable(LuaTypes type, int metaID)
 		{
 			pLuaTypes[type].iType = (unsigned char)metaID;
@@ -222,6 +249,28 @@ namespace Lua
 		{
 			return pPushedUserData;
 		}
+
+		inline bool FastPCall(int nArgs, int nRets, bool bShowError)
+		{
+			lua_State* L = pLua->GetState();
+			int nRet = Util::func_lua_pcall(L, nArgs, nRets, 0);
+			if (nRet > 0)
+			{
+				// We use the ILuaInterface here since on errors we really don't expect speed.
+				if (bShowError)
+				{
+					const char* pError = pLua->GetString(-1);
+					pLua->Pop(1);
+					pLua->ErrorFromLua(pError);
+				} else {
+					pLua->Pop(1);
+				}
+
+				return false;
+			}
+
+			return true;
+		}
 	};
 
 	/*
@@ -464,7 +513,7 @@ struct LuaUserData : GCudata_holylib { // No constructor/deconstructor since its
 	{
 		setgcrefnull(nextgc);
 		gct = 0x0;
-		marked = 0x0;
+		marked = 0x3; // mark white
 	}
 
 	inline void Init(GarrysMod::Lua::ILuaInterface* LUA, const Lua::LuaMetaEntry& pMetaEntry, void* pData, bool bNoGC = false, bool bNoUserTable = false)
@@ -491,7 +540,7 @@ struct LuaUserData : GCudata_holylib { // No constructor/deconstructor since its
 			flags |= UDATA_NO_USERTABLE;
 			// setgcrefnull(usertable); // Verify: Do we need to always have a valid usertable? iirc the gc is missing a null check
 		} else {
-			ClearLuaTable(LUA);
+			ClearLuaTable(LUA, true);
 		}
 
 		/*global_StateGMOD *g = (global_StateGMOD*)G(LUA->GetState());
@@ -505,7 +554,7 @@ struct LuaUserData : GCudata_holylib { // No constructor/deconstructor since its
 #if HOLYLIB_UTIL_DEBUG_LUAUSERDATA
 		g_pLuaUserData.insert(this);
 #if HOLYLIB_UTIL_DEBUG_LUAUSERDATA == 2
-		Msg("holylib - util: LuaUserdata got initialized %p - %p - %i\n", this, LUA, type);
+		Msg("holylib - util: LuaUserdata got initialized %p - %p - %i\n", this, LUA, pMetaEntry.iType);
 #endif
 #endif
 	}
@@ -571,13 +620,13 @@ struct LuaUserData : GCudata_holylib { // No constructor/deconstructor since its
 		}
 	}
 
-	inline void ClearLuaTable(GarrysMod::Lua::ILuaInterface* pLua)
+	inline void ClearLuaTable(GarrysMod::Lua::ILuaInterface* pLua, bool bFresh = false) // bFresh = if we got freshly created / are in a white state
 	{
 		if (flags & UDATA_NO_USERTABLE)
 			return;
 
 		lua_State* L = pLua->GetState();
-		if (Util::func_lj_tab_new)
+		if (Util::func_lj_tab_new && (bFresh || Util::func_lj_gc_barrierf))
 		{
 			// We cannot free it since the GC would kill itself... We also SHOULDN'T since the gc handles it already, so NO touching >:(
 			// Why does the GC kill itself? Because inside the GCHeader of the usertable, the next GC object is stored.
@@ -586,9 +635,30 @@ struct LuaUserData : GCudata_holylib { // No constructor/deconstructor since its
 			// And lj_tab_free also doesn't take care of this, it just frees the memory, so this caused crashes, memory corruption and infinite loops.
 			// Util::func_lj_tab_free(G(L), gco2tab(gcref(usertable)));
 			setgcref(usertable, obj2gco(Util::func_lj_tab_new(L, 0, 0)));
+			
+			if (!bFresh)
+			{ // lj_gc_objbarrier unwrapped since we need to ensure this.
+				if (((((GCobj*)(gcref(usertable))))->gch.marked & (0x01 | 0x02)) && ((((GCobj*)(this)))->gch.marked & 0x04))
+							Util::func_lj_gc_barrierf(G(L), ((GCobj*)(this)), ((GCobj*)(gcref(usertable))));
+			}
 		} else {
 			pLua->CreateTable();
-			setgcref(usertable, obj2gco(tabV(L->top-1)));
+			if (!bFresh)
+			{
+				if (Util::func_lj_gc_barrierf)
+				{
+					setgcref(usertable, obj2gco(tabV(L->top-1)));
+
+					{ // lj_gc_objbarrier unwrapped since we need to ensure this.
+						if (((((GCobj*)(gcref(usertable))))->gch.marked & (0x01 | 0x02)) && ((((GCobj*)(this)))->gch.marked & 0x04))
+							Util::func_lj_gc_barrierf(G(L), ((GCobj*)(this)), ((GCobj*)(gcref(usertable))));
+					}
+				} else {
+					Util::func_lua_setfenv(L, -2); // Internally has the gc barrier
+				}
+			} else {
+				setgcref(usertable, obj2gco(tabV(L->top-1)));
+			}
 			pLua->Pop(1);
 		}
 	}

source/lua/CLuaInterface.cpp

@@ -787,7 +787,7 @@ bool CLuaInterface::Init( GarrysMod::Lua::ILuaGameCallback* callback, bool bIsSe
 	lua_atpanic(state, LuaPanic);
 
 	lua_pushcclosure(state, AdvancedLuaErrorReporter, 0);
-	lua_setglobal(state, "AdvancedLuaErrorReporter");
+	m_nLuaErrorReporter = luaL_ref(state, LUA_REGISTRYINDEX); // Since this is the first ever ref call luaErrorReporter will always be 1
 
 	{
 		luaJIT_setmode(state, -1, LUAJIT_MODE_WRAPCFUNC|LUAJIT_MODE_ON);
@@ -1514,37 +1514,22 @@ void CLuaInterface::Msg( const char* fmt, ... )
 void CLuaInterface::PushPath( const char* path )
 {
 	LuaDebugPrint(2, "CLuaInterface::PushPath %s\n", path);
-	char* str = new char[strlen(path)];
-	V_strncpy( str, path, strlen(path) );
-	str[ strlen(path) - 1 ] = '\0'; // nuke the last /
-	m_sCurrentPath = str;
-	m_pPaths.push_back( str );
-	++m_iPushedPaths;
+	
+	m_CurrentPaths.Push();
+	V_strncpy(m_CurrentPaths.Top().path, path, MAX_PATH);
 }
 
 void CLuaInterface::PopPath()
 {
 	LuaDebugPrint(2, "CLuaInterface::PopPath\n");
-	char* str = m_pPaths.back();
-	delete[] str;
-	m_pPaths.pop_back();
-
-	--m_iPushedPaths;
-	if ( m_iPushedPaths > 0 )
-		m_sCurrentPath = m_pPaths.back();
-	else
-		m_sCurrentPath = NULL;
+	
+	m_CurrentPaths.Pop();
 }
 
 const char* CLuaInterface::GetPath()
 {
-	LuaDebugPrint(2, "CLuaInterface::GetPath\n");
-
-	if ( m_iPushedPaths <= 0 )
-		return NULL;
-
-	LuaDebugPrint(2, "CLuaInterface::GetPath %s\n", (const char*)m_pPaths.back());
-	return m_pPaths.back();
+	LuaDebugPrint(2, "CLuaInterface::GetPath %s\n", (const char*)m_CurrentPaths.Top().path);
+	return m_CurrentPaths.Top().path;
 }
 
 int CLuaInterface::GetColor(int iStackPos) // Probably returns the StackPos
@@ -1785,7 +1770,11 @@ bool CLuaInterface::CallFunctionProtected(int iArgs, int iRets, bool showError)
 		return false;
 	}
 
-	int ret = PCall(iArgs, iRets, 0);
+	int nPos = lua_gettop(state) - iArgs;
+	lua_rawgeti(state, LUA_REGISTRYINDEX, m_nLuaErrorReporter);
+	lua_insert(state, nPos);
+	int ret = PCall(iArgs, iRets, -1);
+	lua_remove(state, nPos);
 	if (ret != 0)
 	{
 		GarrysMod::Lua::ILuaGameCallback::CLuaError* err = ReadStackIntoError(state);

source/lua/CLuaInterface.h

@@ -6,6 +6,7 @@
 #include "GarrysMod/Lua/LuaGameCallback.h"
 #include "GarrysMod/Lua/LuaObject.h"
 #include <list>
+#include "tier1/utlstack.h"
 
 #define GMOD
 
@@ -177,21 +178,15 @@ class CLuaInterface : public GarrysMod::Lua::ILuaInterface
 		m_pGameCallback = callback;
 	}
 
-private: // We keep gmod's structure in case any modules depend on it.
-	int _1 = 1; // Always 1?
-	char* m_sCurrentPath = new char[32]; // not how gmod does it :/
-	int _3 = 0;
-	int _4 = 0;
-	int m_iPushedPaths = 0;
-	const char* m_sLastPath = NULL;
-	std::list<GarrysMod::Lua::ILuaThreadedCall*> m_pThreadedCalls;
-
-#ifdef __APPLE__
-
-	size_t _7; // 1 * sizeof(size_t) = 4 (x86) or 8 (x86-64) bytes
-
-#endif
+public: // We keep gmod's structure in case any modules depend on it.
+	struct Path
+	{
+		char path[MAX_PATH];
+	};
 
+	int m_nLuaErrorReporter = -1; // Always 1 since it's always the first registry reference.
+	CUtlStack<Path> m_CurrentPaths;
+	std::list<GarrysMod::Lua::ILuaThreadedCall*> m_pThreadedCalls;
 	GarrysMod::Lua::ILuaObject* m_ProtectedFunctionReturns[4] = {nullptr};
 	GarrysMod::Lua::ILuaObject* m_TempObjects[LUA_MAX_TEMP_OBJECTS] = {nullptr};
 	unsigned char m_iRealm = (unsigned char)2; // CLIENT = 0, SERVER = 1, MENU = 2
@@ -204,7 +199,6 @@ class CLuaInterface : public GarrysMod::Lua::ILuaInterface
 	unsigned char m_iMetaTableIDCounter = GarrysMod::Lua::Type::COUNT;
 	GarrysMod::Lua::ILuaObject* m_pMetaTables[255] = {nullptr}; // Their index is based off their type. means m_MetaTables[Type::Entity] returns the Entity metatable.
 private: // NOT GMOD stuff
-	std::list<char*> m_pPaths;
 	CThreadFastMutex m_pThreadedCallsMutex;
 
 public:

source/modules/bitbuf.cpp

@@ -945,12 +945,10 @@ LUA_FUNCTION_STATIC(bitbuf_CreateStackReadBuffer)
 
 	// Pushes it onto the stack, since we never use the Push_ HolyLib function.
 	// this will be untracked by the GC BUT you'll have to pop it off the stack BEFORE we leave the scope!
-	LuaUserData pStackLuaData;
-	pStackLuaData.Init(LUA, Lua::GetLuaData(LUA)->GetMetaEntry(Lua::bf_read), &pNewBf, true, true);
-	pStackLuaData.Push(LUA);
+	LuaUserData* pStackLuaData = Push_bf_read(LUA, &pNewBf, false);
 
-	LUA->CallFunctionProtected(1, 0, true);
-	pStackLuaData.Release(LUA);
+	Lua::GetLuaData(LUA)->FastPCall(1, 0, true);
+	pStackLuaData->Release(LUA);
 
 	return 0;
 }

source/modules/luajit.cpp

@@ -477,6 +477,10 @@ void CLuaJITModule::InitDetour(bool bPreServer)
 	Util::func_lua_touserdata = &lua_touserdata;
 	Util::func_lua_type = &lua_type;
 	Util::func_luaL_checklstring = &luaL_checklstring;
+	Util::func_lua_pcall = &lua_pcall;
+	Util::func_lua_insert = &lua_insert;
+	Util::func_lua_toboolean = &lua_toboolean;
+	Util::func_lj_gc_barrierf = (Symbols::lj_gc_barrierf)&lj_gc_barrierf;
 
 	m_bIsEnabled = true;
 }

source/symbols.cpp

@@ -51,6 +51,8 @@ namespace Symbols
 
 	const Symbol lj_tab_newSym = Symbol::FromName("lj_tab_new");
 
+	const Symbol lj_gc_barrierfSym = Symbol::FromName("lj_gc_barrierf");
+
 	const Symbol lua_setfenvSym = Symbol::FromName("lua_setfenv");
 
 	const Symbol lua_touserdataSym = Symbol::FromName("lua_touserdata");
@@ -59,6 +61,12 @@ namespace Symbols
 
 	const Symbol luaL_checklstringSym = Symbol::FromName("luaL_checklstring");
 
+	const Symbol lua_pcallSym = Symbol::FromName("lua_pcall");
+
+	const Symbol lua_insertSym = Symbol::FromName("lua_insert");
+
+	const Symbol lua_tobooleanSym = Symbol::FromName("lua_toboolean");
+
 	const std::vector<Symbol> CGetSym = { // 64x ToDo
 		Symbol::FromName("get"),
 	};

source/symbols.h

@@ -146,6 +146,9 @@ namespace Symbols
 	typedef GCtab* (*lj_tab_new)(lua_State *L, uint32_t nArray, uint32_t nRec);
 	extern const Symbol lj_tab_newSym;
 
+	typedef void (*lj_gc_barrierf)(global_State *g, void *o, void *v);
+	extern const Symbol lj_gc_barrierfSym;
+
 	typedef int (*lua_setfenv)(lua_State *L, int idx);
 	extern const Symbol lua_setfenvSym;
 
@@ -158,6 +161,15 @@ namespace Symbols
 	typedef const char* (*luaL_checklstring)(lua_State *L, int idx, size_t* len);
 	extern const Symbol luaL_checklstringSym;
 
+	typedef int (*lua_pcall)(lua_State *L, int nArgs, int nRets, int nErrorFunc);
+	extern const Symbol lua_pcallSym;
+
+	typedef void (*lua_insert)(lua_State *L, int idx);
+	extern const Symbol lua_insertSym;
+
+	typedef int (*lua_toboolean)(lua_State *L, int idx);
+	extern const Symbol lua_tobooleanSym;
+
 	extern const std::vector<Symbol> CGetSym;
 	extern const std::vector<Symbol> gEntListSym;
 

source/util.cpp

@@ -498,10 +498,14 @@ Symbols::lua_rawgeti Util::func_lua_rawgeti = nullptr;
 IGameEventManager2* Util::gameeventmanager = nullptr;
 IServerGameDLL* Util::servergamedll = nullptr;
 Symbols::lj_tab_new Util::func_lj_tab_new = nullptr;
+Symbols::lj_gc_barrierf Util::func_lj_gc_barrierf = nullptr;
 Symbols::lua_setfenv Util::func_lua_setfenv = nullptr;
 Symbols::lua_touserdata Util::func_lua_touserdata = nullptr;
 Symbols::lua_type Util::func_lua_type = nullptr;
 Symbols::luaL_checklstring Util::func_luaL_checklstring = nullptr;
+Symbols::lua_pcall Util::func_lua_pcall = nullptr;
+Symbols::lua_insert Util::func_lua_insert = nullptr;
+Symbols::lua_toboolean Util::func_lua_toboolean = nullptr;
 void Util::AddDetour()
 {
 	if (g_pModuleManager.GetAppFactory())
@@ -612,7 +616,19 @@ void Util::AddDetour()
 	func_luaL_checklstring = (Symbols::luaL_checklstring)Detour::GetFunction(lua_shared_loader.GetModule(), Symbols::luaL_checklstringSym);
 	Detour::CheckFunction((void*)func_luaL_checklstring, "luaL_checklstring");
 
-	if (!func_lua_touserdata || !func_lua_type || !func_lua_setfenv)
+	func_lua_pcall = (Symbols::lua_pcall)Detour::GetFunction(lua_shared_loader.GetModule(), Symbols::lua_pcallSym);
+	Detour::CheckFunction((void*)func_lua_pcall, "lua_pcall");
+
+	func_lua_insert = (Symbols::lua_insert)Detour::GetFunction(lua_shared_loader.GetModule(), Symbols::lua_insertSym);
+	Detour::CheckFunction((void*)func_lua_insert, "lua_insert");
+
+	func_lua_toboolean = (Symbols::lua_toboolean)Detour::GetFunction(lua_shared_loader.GetModule(), Symbols::lua_tobooleanSym);
+	Detour::CheckFunction((void*)func_lua_toboolean, "lua_toboolean");
+
+	func_lj_gc_barrierf = (Symbols::lj_gc_barrierf)Detour::GetFunction(lua_shared_loader.GetModule(), Symbols::lj_gc_barrierfSym);
+	Detour::CheckFunction((void*)func_lj_gc_barrierf, "lj_gc_barrierf");
+
+	if (!func_lua_touserdata || !func_lua_type || !func_lua_setfenv || !func_luaL_checklstring || !func_lua_pcall || !func_lua_insert || !func_lua_toboolean)
 	{
 		// This is like the ONLY dependency we have on symbols that without we cannot function.
 		Error(PROJECT_NAME " - core: Failed to load an important symbol which we utterly depend on.\n");