Supermodel/Src/Debugger/CodeAnalyser.cpp

#ifdef SUPERMODEL_DEBUGGER

#include "CodeAnalyser.h"
#include "CPUDebug.h"
#include "Label.h"

#include <ctype.h>
#include <string.h>

namespace Debugger
{
	CEntryPoint::CEntryPoint(const CEntryPoint &other) : addr(other.addr), autoFlag(other.autoFlag)
	{
		if (other.autoLabel != NULL)
		{
			strncpy(autoLabelStr, other.autoLabel, 254);
			autoLabelStr[254] = '\0';
			autoLabel = autoLabelStr;
		}
		else
			autoLabel = NULL;
	}

	CEntryPoint::CEntryPoint(UINT32 eAddr, ELabelFlags eAutoFlag, const char *eAutoLabel) :
		addr(eAddr), autoFlag(eAutoFlag)
	{
		if (eAutoLabel != NULL)
		{
			strncpy(autoLabelStr, eAutoLabel, 254);
			autoLabelStr[254] = '\0';
			autoLabel = autoLabelStr;
		}
		else
			autoLabel = NULL;
	}

	CEntryPoint &CEntryPoint::operator=(const CEntryPoint &other)
	{
		addr = other.addr;
		autoFlag = other.autoFlag;
		if (other.autoLabel != NULL)
		{
			strncpy(autoLabelStr, other.autoLabel, 254);
			autoLabelStr[254] = '\0';
			autoLabel = autoLabelStr;
		}
		else
			autoLabel = NULL;
		return *this;
	}

	bool CEntryPoint::operator==(const CEntryPoint &other)
	{
		return addr == other.addr && autoFlag == other.autoFlag;
	}

	bool CEntryPoint::operator!=(const CEntryPoint &other)
	{
		return addr != other.addr || autoFlag != other.autoFlag;
	}

	const char *CAutoLabel::s_defaultLabelFmts[] = { "Entry%s", "Ex%s", "Int%s", "Jmp%s", "Loop%s", "Sub%s", NULL };

	const unsigned CAutoLabel::numLabelFlags = sizeof(s_defaultLabelFmts) / sizeof(char*);

	ELabelFlags CAutoLabel::GetLabelFlag(int index)
	{
		if (index < 0 || index >= numLabelFlags)
			return LFNone;
		return (ELabelFlags)(1 << index);
	}

	int CAutoLabel::GetFlagIndex(ELabelFlags flag)
	{
		switch (flag)
		{
			case LFEntryPoint:   return 0;
			case LFExcepHandler: return 1;
			case LFInterHandler: return 2;
			case LFJumpTarget:   return 3;
			case LFLoopPoint:    return 4;
			case LFSubroutine:   return 5;
			case LFUnseenCode:   return 6;
			default:             return -1;
		}
	}

	const char *CAutoLabel::GetFlagString(ELabelFlags flag)
	{
		switch (flag)
		{
			case LFEntryPoint:   return "Entry Point";
			case LFExcepHandler: return "Exception Handler";
			case LFInterHandler: return "Interrupt Handler";
			case LFJumpTarget:   return "Jump Target";
			case LFLoopPoint:    return "Loop Point";
			case LFSubroutine:   return "Subroutine";
			case LFUnseenCode:   return "Unseen Code";
			default:             return "";
		}
	}

	CAutoLabel::CAutoLabel(CCPUDebug *lCPU, UINT32 lAddr) : CAddressRef(lCPU, lAddr), flags(LFNone), m_acquired(0)
	{
		memset(m_subLabels, NULL, sizeof(m_subLabels));
	}

	CAutoLabel::~CAutoLabel()
	{
		// Delete all sub-labels
		for (int index = 0; index < numLabelFlags; index++)
		{
			if (m_subLabels[index] != NULL)
			{
				delete[] m_subLabels[index];
				m_subLabels[index] = NULL;
			}
		}
	}

	void CAutoLabel::Acquire()
	{
		m_acquired++;
	}

	void CAutoLabel::Release()
	{
		if (--m_acquired == 0)
			delete this;
	}

	void CAutoLabel::AddFlag(ELabelFlags flag, const char *subLabel)
	{
		int index = GetFlagIndex(flag);
		if (index == -1)
			return;
		flags = (ELabelFlags)((unsigned)flags | (unsigned)flag);
		if (subLabel != NULL)
		{
			size_t len = strlen(subLabel);
			char *label = new char[len + 1];
			strncpy(label, subLabel, len);
			label[len] = '\0';
			m_subLabels[index] = label;
		}
		else
			m_subLabels[index] = CreateDefaultSubLabel(flag);
	}

	bool CAutoLabel::GetLabel(char *labelStr, ELabelFlags subFlags)
	{	
		char *p = labelStr;
		*p = '\0';
		for (int index = 0; index < numLabelFlags; index++)
		{
			ELabelFlags flag = GetLabelFlag(index);
			if (!(subFlags & flag))
				continue;
			const char *subLabel = m_subLabels[index];
			if (subLabel == NULL)
				continue;
			if (p > labelStr)
			{
				(*p++) = '/';
				*p = '\0';
			}
			strcat(p, subLabel);
			p += strlen(subLabel);
			*p = '\0';
		}
		return p > labelStr;
	}

	bool CAutoLabel::ContainsSubLabel(const char *subLabel)
	{
		for (int i = 0; i < numLabelFlags; i++)
		{
			if (m_subLabels[i] != NULL && stricmp(subLabel, m_subLabels[i]) == 0)
				return true;
		}
		return false;
	}

	const char *CAutoLabel::CreateDefaultSubLabel(ELabelFlags flag)
	{
		int index = GetFlagIndex(flag);
		if (index == -1)
			return NULL;
		const char *labelFmt = s_defaultLabelFmts[index];
		if (labelFmt == NULL)
			return NULL;
		char addrStr[50];
		cpu->debugger->FormatData(addrStr, Hex, (unsigned)(cpu->memBusWidth / 8), (UINT64)addr);
		char *label = new char[255];
		sprintf(label, labelFmt, addrStr);
		return label;
	}

	CCodeAnalysis::CCodeAnalysis(CCodeAnalyser *aAnalyser) : analyser(aAnalyser)
	{
		//
	}

	CCodeAnalysis::CCodeAnalysis(CCodeAnalyser *aAnalyser, unsigned aTotalIndices, vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs) : 
		analyser(aAnalyser), m_entryPoints(entryPoints), m_unseenEntryAddrs(unseenEntryAddrs), 
		m_seenIndices(aTotalIndices), m_validIndices(aTotalIndices), m_acquired(0)
	{
		//
	}

	CCodeAnalysis::CCodeAnalysis(CCodeAnalysis *oldAnalysis, vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs) :
		analyser(oldAnalysis->analyser), m_entryPoints(entryPoints), m_unseenEntryAddrs(unseenEntryAddrs), 
		m_seenIndices(oldAnalysis->m_seenIndices), m_validIndices(oldAnalysis->m_validIndices), 
		m_autoLabelsMap(oldAnalysis->m_autoLabelsMap), m_acquired(0), validIndexSet(oldAnalysis->validIndexSet)
	{
		for (map<unsigned,CAutoLabel*>::iterator it = m_autoLabelsMap.begin(); it != m_autoLabelsMap.end(); it++)
			it->second->Acquire();
	}

	CCodeAnalysis::~CCodeAnalysis()
	{
		for (vector<CAutoLabel*>::iterator it = autoLabels.begin(); it != autoLabels.end(); it++)
			(*it)->Release();
		autoLabels.clear();
		m_autoLabelsMap.clear();
	}

	void CCodeAnalysis::Acquire()
	{
		m_acquired++;
	}

	void CCodeAnalysis::Release()
	{
		if (--m_acquired == 0)
			delete this;
	}

	void CCodeAnalysis::FinishAnalysis()
	{
		for (map<UINT32,CAutoLabel*>::iterator it = m_autoLabelsMap.begin(); it != m_autoLabelsMap.end(); it++)
			autoLabels.push_back(it->second);
	}

	bool CCodeAnalysis::IsAddrValid(UINT32 addr)
	{
		unsigned index;
		if (!analyser->GetIndexOfAddr(addr, index))
			return false;
		return IsIndexValid(index);
	}

	bool CCodeAnalysis::GetNextValidAddr(UINT32 &addr)
	{
		unsigned index;
		if (!analyser->GetIndexOfAddr(addr, index))
			return false;
		if (IsIndexValid(index))
			return true;
		set<unsigned>::iterator it = validIndexSet.lower_bound(index);
		if (it == validIndexSet.end())
			return false;
		return analyser->GetAddrOfIndex(*it, addr);
	}

	bool CCodeAnalysis::IsIndexValid(unsigned index)
	{
		return index < m_validIndices.size() && m_validIndices[index];
	}

	bool CCodeAnalysis::GetNextValidIndex(unsigned &index)
	{
		if (IsIndexValid(index))
			return true;
		set<unsigned>::iterator it = validIndexSet.lower_bound(index);
		if (it == validIndexSet.end())
			return false;
		index = *it;
		return true;
	}

	bool CCodeAnalysis::HasSeenAddr(UINT32 addr)
	{
		unsigned index;
		if (!analyser->GetIndexOfAddr(addr, index))
			return false;
		return HaveSeenIndex(index);
	}

	bool CCodeAnalysis::HaveSeenIndex(unsigned index)
	{
		return index < m_seenIndices.size() && m_seenIndices[index];
	}

	CAutoLabel *CCodeAnalysis::GetAutoLabel(UINT32 addr)
	{
		map<UINT32,CAutoLabel*>::iterator it = m_autoLabelsMap.find(addr);
		if (it == m_autoLabelsMap.end())
			return NULL;
		return it->second;
	}

	CAutoLabel *CCodeAnalysis::GetAutoLabel(const char *subLabel)
	{
		for (vector<CAutoLabel*>::iterator it = autoLabels.begin(); it != autoLabels.end(); it++)
		{
			if ((*it)->ContainsSubLabel(subLabel))
				return *it;
		}
		return NULL;
	}

	vector<CAutoLabel*> CCodeAnalysis::GetAutoLabels(ELabelFlags flag)
	{
		vector<CAutoLabel*> matched;
		for (vector<CAutoLabel*>::iterator it = autoLabels.begin(); it != autoLabels.end(); it++)
		{
			if ((*it)->flags & flag)
				matched.push_back(*it);
		}
		return matched;
	}	

	CCodeAnalyser::CCodeAnalyser(CCPUDebug *aCPU) : cpu(aCPU), emptyAnalysis(this), analysis(&emptyAnalysis)
	{
		instrAlign = cpu->minInstrLen;

		totalIndices = 0;
		for (vector<CRegion*>::iterator it = cpu->regions.begin(); it != cpu->regions.end(); it++)
		{
			if (!(*it)->isCode)
				continue;
			m_codeRegions.push_back(*it);
			totalIndices += (*it)->size / instrAlign;
			m_indexBounds.push_back(totalIndices);
		}
	}

	CCodeAnalyser::~CCodeAnalyser()
	{
		if (analysis != &emptyAnalysis)
			analysis->Release();
	}

	void CCodeAnalyser::Reset()
	{
		CCodeAnalysis *oldAnalysis = analysis;
		analysis = &emptyAnalysis;
		if (oldAnalysis != &emptyAnalysis)
			oldAnalysis->Release();
	}

	bool CCodeAnalyser::GetAddrOfIndex(unsigned index, UINT32 &addr)
	{
		unsigned regIndex = 0;
		unsigned prevBound = 0;
		for (vector<unsigned>::iterator it = m_indexBounds.begin(); it != m_indexBounds.end(); it++)
		{
			if (*it > index)
			{
				addr = m_codeRegions[regIndex]->addr + (UINT32)(index - prevBound) * instrAlign;
				return true;
			}
			prevBound = *it;
			regIndex++;
		}
		return false;
	}

	bool CCodeAnalyser::GetIndexOfAddr(UINT32 addr, unsigned &index)
	{
		unsigned regIndex = 0;
		for (vector<CRegion*>::iterator it = m_codeRegions.begin(); it != m_codeRegions.end(); it++)
		{
			if ((*it)->addr <= addr && addr <= (*it)->addrEnd)
			{
				unsigned offset = (unsigned)((addr - (*it)->addr) / instrAlign);
				index = (regIndex > 0 ? m_indexBounds[regIndex - 1] + offset : (unsigned)offset);
				return true;
			}
			regIndex++;
		}
		return false;
	}

	void CCodeAnalyser::CheckEntryPoints(vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs, vector<CEntryPoint> &prevPoints,
		bool &needsAnalysis, bool &reanalyse)
	{
		needsAnalysis = false;

		// Gather entry points
		GatherEntryPoints(entryPoints, unseenEntryAddrs, reanalyse);
		if (reanalyse)
		{
			needsAnalysis = true;
			return;
		}

		// Compare new entry points with previous ones
		for (size_t i = 0; i < entryPoints.size(); i++)
		{
			// Check if have more than before
			if (i >= prevPoints.size())
			{
				needsAnalysis = true;
				return;
			}
			// Check if any have changed
			if (entryPoints[i] != prevPoints[i])
			{
				// If entry points, exception handlers or interrupt handlers have changed, then force reanalysis
				if (entryPoints[i].autoFlag == LFEntryPoint || prevPoints[i].autoFlag == LFEntryPoint ||
					entryPoints[i].autoFlag == LFExcepHandler || prevPoints[i].autoFlag == LFExcepHandler ||
					entryPoints[i].autoFlag == LFInterHandler || prevPoints[i].autoFlag == LFInterHandler)
					reanalyse = true;
				needsAnalysis = true;
				return;
			}
		}
		// Check if have less than before
		if (entryPoints.size() < prevPoints.size())
		{
			// If so, force reanalysis
			reanalyse = true;
			needsAnalysis = true;
			return;
		}		
	}

	void CCodeAnalyser::GatherEntryPoints(vector<CEntryPoint> &entryPoints, vector<UINT32> &unseenEntryAddrs, bool &reanalyse)
	{
		char labelStr[255];
		UINT32 addr;
		unsigned index;

		entryPoints.clear();
		reanalyse = false;

		// Add reset address as main entry point
		AddEntryPoint(entryPoints, cpu->GetResetAddr(), LFEntryPoint, "MainEntry");

		// Add exception handlers as entry points
		for (vector<CException*>::iterator it = cpu->exceps.begin(); it != cpu->exceps.end(); it++)
		{
			if (!cpu->GetHandlerAddr(*it, addr))
				continue;
			sprintf(labelStr, "Ex%s", (*it)->id);
			AddEntryPoint(entryPoints, addr, LFExcepHandler, labelStr);
		}

		// Add interrupt handlers as entry points
		for (vector<CInterrupt*>::iterator it = cpu->inters.begin(); it != cpu->inters.end(); it++)
		{
			if (!cpu->GetHandlerAddr(*it, addr))
				continue;
			sprintf(labelStr, "Int%s", (*it)->id);
			AddEntryPoint(entryPoints, addr, LFInterHandler, labelStr);
		}

		// Add custom entry addresses
		unsigned i = 0;
		for (vector<UINT32>::iterator it = m_customEntryAddrs.begin(); it != m_customEntryAddrs.end(); it++)
		{
			sprintf(labelStr, "Custom%u", i++);
			AddEntryPoint(entryPoints, *it, LFEntryPoint, labelStr);
		}

		// If current PC address is at an unseen location or at location that was previously invalid, then add address as unseen entry point
		if (cpu->instrCount > 0 && GetIndexOfAddr(cpu->pc, index) && (!analysis->HaveSeenIndex(index) || !analysis->IsIndexValid(index)))
		{
			// If at location that was previously seen and was invalid, then force reanalysis (ie because code may have been modified)
			if (analysis->HaveSeenIndex(index) && !analysis->IsIndexValid(index))
				reanalyse = true;

			// Check that address not already included in previous entry points
			bool unseen = true;
			for (vector<CEntryPoint>::iterator it = entryPoints.begin(); it != entryPoints.end(); it++)
			{
				if ((*it).addr == cpu->pc)
				{
					unseen = false;
					break;
				}
			}
			if (unseen && find(unseenEntryAddrs.begin(), unseenEntryAddrs.end(), cpu->pc) == unseenEntryAddrs.end())
				unseenEntryAddrs.push_back(cpu->pc);
		}

		// Add unseen entry points
		for (vector<UINT32>::iterator it = unseenEntryAddrs.begin(); it != unseenEntryAddrs.end(); it++)
			AddEntryPoint(entryPoints, *it, LFUnseenCode, NULL);
	}

	void CCodeAnalyser::AddEntryPoint(vector<CEntryPoint> &entryPoints, UINT32 addr, ELabelFlags autoFlag, const char *autoLabel)
	{
		CEntryPoint entryPoint(addr, autoFlag, autoLabel);
		if (find(entryPoints.begin(), entryPoints.end(), entryPoint) == entryPoints.end())
			entryPoints.push_back(entryPoint);
	}

	bool CCodeAnalyser::NeedsAnalysis()
	{
		vector<CEntryPoint> entryPoints;
		vector<UINT32> unseenEntryAddrs(analysis->m_unseenEntryAddrs);
		bool needsAnalysis;
		bool reanalyse;
		CheckEntryPoints(entryPoints, unseenEntryAddrs, analysis->m_entryPoints, needsAnalysis, reanalyse);
		return needsAnalysis;
	}

	bool CCodeAnalyser::AnalyseCode()
	{
		m_abortAnalysis = false;

		CCodeAnalysis *oldAnalysis = analysis;
		
		vector<CEntryPoint> entryPoints;
		vector<UINT32> unseenEntryAddrs(oldAnalysis->m_unseenEntryAddrs);
		bool needsAnalysis;
		bool reanalyse;
		CheckEntryPoints(entryPoints, unseenEntryAddrs, oldAnalysis->m_entryPoints, needsAnalysis, reanalyse);
		if (!needsAnalysis)
			return false;

		CCodeAnalysis *newAnalysis;
		if (reanalyse || oldAnalysis == &emptyAnalysis)
			newAnalysis = new CCodeAnalysis(this, totalIndices, entryPoints, unseenEntryAddrs);
		else
			newAnalysis = new CCodeAnalysis(oldAnalysis, entryPoints, unseenEntryAddrs);
		newAnalysis->Acquire();

		for (vector<CEntryPoint>::iterator it = newAnalysis->m_entryPoints.begin(); it != newAnalysis->m_entryPoints.end(); it++)
		{
			AddFlagToAddr(newAnalysis->m_autoLabelsMap, it->addr, it->autoFlag, it->autoLabel);
			AnalyseCode(newAnalysis->m_seenIndices, newAnalysis->m_validIndices, newAnalysis->validIndexSet, newAnalysis->m_autoLabelsMap, it->addr);
		}
		newAnalysis->FinishAnalysis();

		if (m_abortAnalysis)
		{
			newAnalysis->Release();
			return false;
		}

		analysis = newAnalysis;
		if (oldAnalysis != &emptyAnalysis)
			oldAnalysis->Release();

		cpu->debugger->AnalysisUpdated(this);
		return true;
	}

	void CCodeAnalyser::AnalyseCode(vector<bool> &seenIndices, vector<bool> &validIndices, set<unsigned> &validIndexSet,
		map<UINT32,CAutoLabel*> &autoLabelsMap, UINT32 addr)
	{
		if (m_abortAnalysis)
			return;

		unsigned index;
		if (!GetIndexOfAddr(addr, index) || seenIndices[index])
			return;
		
		CRegion *region = cpu->GetRegion(addr);
		if (region == NULL || !region->isCode)
			return;

		set<unsigned>::iterator setIt = validIndexSet.end();

		unsigned startIndex = index;
		do
		{
			if (m_abortAnalysis)
				return;

			// Flag that have seen this address index
			seenIndices[index] = true;

			// If unit is not valid (ie doesn't disassemble) then code block must be invalid (TODO - invalidate whole code block?)
			int codesLen = cpu->GetOpLength(addr);
			if (codesLen <= 0)
				return;

			validIndices[index] = true;
			if (setIt != validIndexSet.end())
				setIt = validIndexSet.insert(setIt, index);
			else
				setIt = validIndexSet.insert(index).first;
			
			UINT32 opcode = cpu->GetOpcode(addr);
			EOpFlags opFlags = cpu->GetOpFlags(addr, opcode);

			// See if instruction is jump
			if (opFlags & (JumpSimple|JumpLoop|JumpSub))
			{
				// If so, see if address is valid (ie known at disassemble time)
				UINT32 jumpAddr;
				if (cpu->GetJumpAddr(addr, opcode, jumpAddr))
				{
					// If so, add flags to jump address and analyse destination code block too
					if      (opFlags & JumpSub)  AddFlagToAddr(autoLabelsMap, jumpAddr, LFSubroutine, NULL);
					else if (opFlags & JumpLoop) AddFlagToAddr(autoLabelsMap, jumpAddr, LFLoopPoint, NULL);
					else                         AddFlagToAddr(autoLabelsMap, jumpAddr, LFJumpTarget, NULL);
					AnalyseCode(seenIndices, validIndices, validIndexSet, autoLabelsMap, jumpAddr);
				}
			}

			// Finish if instruction terminates code block (ie is not conditional and is either a non-returning jump, a return or some sort
			// of reset/halting instruction)
			if (!(opFlags & Conditional) && (opFlags & (JumpSimple|JumpLoop|ReturnEx|ReturnSub|HaltExec)))
				return;

			// Move to next index
			index += (unsigned)codesLen / instrAlign;

			// If reach end of address indices, code block must be invalid (TODO - invalidate whole code block?)
			if (index >= totalIndices)
				return;

			// Move to next address
			addr += (UINT32)codesLen;
			
			// If move between regions, check new region is valid
			if (addr > region->addrEnd)
			{
				region = cpu->GetRegion(addr);
				if (region == NULL || !region->isCode) // (TODO - invalidate whole code block?)
					return;
			}
		}
		while (!seenIndices[index]);
	}

	void CCodeAnalyser::AddFlagToAddr(map<UINT32,CAutoLabel*> &autoLabelsMap, UINT32 addr, ELabelFlags flag, const char *subLabel)
	{
		if (flag == LFNone)
			return;
		map<UINT32,CAutoLabel*>::iterator it = autoLabelsMap.find(addr);
		CAutoLabel *label;
		if (it == autoLabelsMap.end())
		{
			label = new CAutoLabel(cpu, addr);
			label->Acquire();
			autoLabelsMap[addr] = label;
		}
		else
			label = it->second;
		label->AddFlag(flag, subLabel);
	}
	
	void CCodeAnalyser::AbortAnalysis()
	{
		m_abortAnalysis = true;
	}
	
	void CCodeAnalyser::ClearCustomEntryAddrs()
	{
		m_customEntryAddrs.clear();
	}

	void CCodeAnalyser::AddCustomEntryAddr(UINT32 entryAddr)
	{
		if (find(m_customEntryAddrs.begin(), m_customEntryAddrs.end(), entryAddr) == m_customEntryAddrs.end())
			m_customEntryAddrs.push_back(entryAddr);
	}

	bool CCodeAnalyser::RemoveCustomEntryAddr(UINT32 entryAddr)
	{
		vector<UINT32>::iterator it = find(m_customEntryAddrs.begin(), m_customEntryAddrs.end(), entryAddr);
		if (it == m_customEntryAddrs.end())
			return false;
		m_customEntryAddrs.erase(it);
		return true;
	}

#ifdef DEBUGGER_HASBLOCKFILE
	bool CCodeAnalyser::LoadState(CBlockFile *state)
	{
		// Load custom entry addresses
		char blockStr[255];
		sprintf(blockStr, "%s.entryaddrs", cpu->name);
		if (state->FindBlock(blockStr) == OKAY)
		{
			m_customEntryAddrs.clear();
			UINT32 numAddrs;
			state->Read(&numAddrs, sizeof(numAddrs));
			for (UINT32 i = 0; i < numAddrs; i++)
			{
				UINT32 addr;
				state->Read(&addr, sizeof(addr));
				m_customEntryAddrs.push_back(addr);
			}
		}
		return true;
	}

	bool CCodeAnalyser::SaveState(CBlockFile *state)
	{
		// Save custom entry addresses
		char blockStr[255];
		sprintf(blockStr, "%s.entryaddrs", cpu->name);
		state->NewBlock(blockStr, __FILE__);
		UINT32 numAddrs = m_customEntryAddrs.size();
		state->Write(&numAddrs, sizeof(numAddrs));
		for (UINT32 i = 0; i < numAddrs; i++)
		{
			UINT32 addr = m_customEntryAddrs[i];
			state->Write(&addr, sizeof(addr));
		}
		return true;
	}
#endif // DEBUGGER_HASBLOCKFILE
}
#endif  // SUPERMODEL_DEBUGGER