Revert "Auto stash before merge of "master" and "origin/master""

This reverts commit c0c0db74851633a93b27a35a2d2adcd502bde612.

IDE/BeefProj.toml

@@ -26,6 +26,7 @@ OptimizationLevel = "O0"
 TargetDirectory = "$(WorkspaceDir)/dist"
 TargetName = "BeefIDE_d"
 OtherLinkFlags = "$(LinkFlags) Comdlg32.lib kernel32.lib user32.lib advapi32.lib shell32.lib IDEHelper64_d.lib"
+DebugCommandArguments = "-proddir=C:\\Beef\\IDE"
 DebugWorkingDirectory = "c:\\Beef\\IDE\\Tests\\EmptyTest"
 EnvironmentVars = ["_NO_DEBUG_HEAP=1"]
 
@@ -52,7 +53,7 @@ TargetDirectory = "$(WorkspaceDir)/dist"
 TargetName = "BeefIDE_d2"
 OtherLinkFlags = "$(LinkFlags) Comdlg32.lib kernel32.lib user32.lib advapi32.lib shell32.lib IDEHelper64_d.lib BeefySysLib64_d.lib wsock32.lib"
 BeefLibType = "DynamicDebug"
-DebugCommandArguments = "-workspace=c:\\beef\\beeftools\\DocPrep"
+DebugCommandArguments = "-workspace=c:\\beef\\ide\\mintest"
 DebugWorkingDirectory = "$(ProjectDir)\\dist"
 EnvironmentVars = ["_NO_DEBUG_HEAP=1"]
 

IDE/mintest/src/main3.bf

@@ -0,0 +1,237 @@
+//GORB
+#pragma warning disable 168
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+
+//#define A
+//#define B
+
+class ClassA
+{
+	public virtual void ClassA0()
+	{
+
+	}
+
+	public virtual void ClassA1()
+	{
+
+	}
+}
+
+class ClassB
+{
+	
+}
+
+#if B
+class ClassC : ClassB
+{
+	public override void ToString(System.String strBuffer)
+	{
+		base.ToString(strBuffer);
+	}
+}
+#elif A
+class ClassC : ClassA
+{
+	public override void ToString(System.String strBuffer)
+	{
+		base.ToString(strBuffer);
+	}
+}
+#endif
+
+class ClassD
+{
+	public String mStr;
+	int mA6;
+
+	public virtual void Poo()
+	{
+		PrintF("Poo\n");
+	}
+
+	public virtual void Poo2()
+	{
+		PrintF("Poo2\n");
+	}
+}
+
+class ClassD2
+{
+	int mA5;
+
+}
+
+class ClassE : ClassD
+{
+	public void Zog2()
+	{
+
+	}
+}
+
+class ClassF : ClassE
+{
+
+}
+
+[NoDiscard("Use this value!")]
+struct TestStruct
+{
+	public int mA;
+	public int mB;
+}
+
+class Bloozer
+{
+	int mA;
+}
+
+enum Zorf : IDisposable
+{
+	case A;
+	case B;
+
+	public void Dispose()
+	{
+
+	}
+}
+
+class IFaceA
+{
+	public static void Fart()
+	{
+
+	}
+}
+
+class Zlips : IFaceA, IDisposable
+{
+	static void Fart()
+	{
+
+	}
+
+	public void Dispose()
+	{
+		PrintF("Disposed");
+	}
+}
+
+class Testo
+{
+	public this()
+	{
+		PrintF("Testo this %p\n", this);
+	}
+
+	public ~this()
+	{
+		PrintF("Testo ~this %p\n", this);
+	}
+}
+
+class Blurg
+{
+	delegate void() mFuncA;
+	delegate void() mFuncB;
+
+	int mA = 123;
+
+	public this()
+	{
+		
+	}
+
+	void TestIt(String a, String b)
+	{
+
+	}
+
+	TestStruct GetTS()
+	{
+		return .();
+	}
+
+	static void Test(int a, int b)
+	{
+
+	}
+
+	static void Test(int a, int b, int c)
+	{
+
+	}
+
+	public static void Use<T>(T val) where T : IFaceA
+	{
+		IFaceA.Fart();
+	}
+
+	public static void Hey()
+	{
+		Loop:
+		for (int i < 10)
+		{
+			defer
+			{
+				//for ()
+				JLoop: for (int j < 5)
+				{
+					//continue Loop;
+				}
+
+				//break JLoop;
+
+				int z = 3;
+
+				/*void Zorg()
+				{
+					
+				}
+
+				Zorg();*/
+				//return;
+
+				//break Loop;
+			}
+		}
+
+		defer
+		{
+			scope:: Testo();
+
+			int i = 0;
+			if (i == 0)
+				scope:: Testo();
+			if (i == 1)
+				scope:: Testo();
+		}
+
+		
+
+		int aaaaaa = 123;
+		if (aaaaaa == 123)
+			return;//A
+
+		int bbbbbbb = 222;
+		return;//B
+	}
+
+}
+
+class CustomAlloc
+{
+	public void* Alloc(int size, int align)
+	{
+		//return Internal.Malloc(size);
+		return null;
+	}
+}
+

IDEHelper/COFF.cpp

@@ -0,0 +1,6884 @@
+#include "COFF.h"
+#include "BeefySysLib/FileStream.h"
+#include "BeefySysLib/MemStream.h"
+#include "codeview/cvinfo.h"
+#include "DebugTarget.h"
+#include "DebugManager.h"
+#include "DWARFInfo.h"
+#include "BeefySysLib/Util/PerfTimer.h"
+#include "BeefySysLib/Util/Dictionary.h"
+#include "BeefySysLib/Util/BeefPerf.h"
+#include "BeefySysLib/platform/PlatformHelper.h"
+#include "WinDebugger.h"
+#include "MiniDumpDebugger.h"
+#include "Linker/BlHash.h"
+#include "Backend/BeLibManger.h"
+#include <shlobj.h>
+
+#include "BeefySysLib/util/AllocDebug.h"
+
+USING_NS_BF_DBG;
+
+#define MSF_SIGNATURE_700 "Microsoft C/C++ MSF 7.00\r\n\032DS\0\0"
+static const int NUM_ROOT_DIRS = 73;
+
+#pragma warning(default:4800)
+
+#define ADDR_FLAG_ABS 0x8000000000000000L
+
+#define GET(T) *((T*)(data += sizeof(T)) - 1)
+#define GET_INTO(T, name) T name = GET(T)
+#define GET_FROM(ptr, T) *((T*)(ptr += sizeof(T)) - 1)
+
+#define PTR_ALIGN(ptr, origPtr, alignSize) ptr = ( (origPtr)+( ((ptr - origPtr) + (alignSize - 1)) & ~(alignSize - 1) ) )
+
+static const char* DataGetString(uint8*& data)
+{
+	const char* prevVal = (const char*)data;
+	while (*data != 0)
+		data++;
+	data++;
+	return prevVal;
+}
+
+#define CREATE_PRIMITIVE(pdbTypeCode, dwTypeCode, typeName, type) \
+	BP_ALLOC_T(DbgType); \
+	dbgType = mAlloc.Alloc<DbgType>(); \
+	dbgType->mCompileUnit = mMasterCompileUnit; \
+	dbgType->mTypeName = typeName; \
+	dbgType->mName = typeName; \
+	dbgType->mTypeCode = dwTypeCode; \
+	dbgType->mSize = sizeof(type); \
+	dbgType->mAlign = sizeof(type); \
+	mCvSystemTypes[(int)pdbTypeCode] = dbgType; \
+	\
+	BP_ALLOC_T(DbgType); \
+	ptrType = mAlloc.Alloc<DbgType>(); \
+	ptrType->mCompileUnit = mMasterCompileUnit; \
+	ptrType->mTypeCode = DbgType_Ptr; \
+	ptrType->mSize = sizeof(addr_target); \
+	ptrType->mAlign = sizeof(addr_target); \
+	ptrType->mTypeParam = dbgType; \
+	dbgType->mPtrType = ptrType; \
+	mCvSystemTypes[(int)pdbTypeCode | ptrMask] = ptrType;
+
+#define REGISTER_PRIMITIVE() mTypeMap.Insert(dbgType)
+
+static const char* GetLastDoubleColon(const char* name)
+{
+	int templateDepth = 0;
+	int parenDepth = 0;
+	const char* lastDblColon = NULL;
+	for (const char* checkPtr = name; *checkPtr != '\0'; checkPtr++)
+	{
+		char c = checkPtr[0];
+		if (c == '<')
+			templateDepth++;
+		else if (c == '>')
+			templateDepth--;
+		else if (c == '(')
+			parenDepth++;
+		else if (c == ')')
+			parenDepth--;
+		if ((templateDepth == 0) && (parenDepth == 0) && (c == ':') && (checkPtr[1] == ':'))
+			lastDblColon = checkPtr;
+		if ((templateDepth == 0) && (parenDepth == 0) && (c == ' '))
+		{
+			// This catches cases like "Beefy::BfMethodRef::operator Beefy::BfMethodInstance*", where we want to match the :: right before "operator"
+			break;
+		}
+	}
+	return lastDblColon;
+}
+
+static const char* GetNamespaceEnd(const char* name)
+{
+	int templateDepth = 0;
+	const char* lastDblColon = NULL;
+	for (const char* checkPtr = name; *checkPtr != '\0'; checkPtr++)
+	{
+		char c = checkPtr[0];
+		if ((c == '<') || (c == ' '))
+			return NULL;
+		if ((c == ':') && (checkPtr[1] == ':'))
+			lastDblColon = checkPtr;		
+	}
+	return lastDblColon;
+}
+
+// This version inserts namespaces that contain specialized methods, but since we don't (at the time of this comment) support
+//  calling specialized methods, we don't bother doing this -- it increases the scan time
+#if 0
+static const char* GetNamespaceEnd(const char* name)
+{
+	bool hadTemplate = false;
+	int templateDepth = 0;
+	const char* lastDblColon = NULL;
+	for (const char* checkPtr = name; *checkPtr != '\0'; checkPtr++)
+	{
+		char c = checkPtr[0];
+		if (c == '<')
+		{
+			hadTemplate = true;
+			templateDepth++;
+		}
+		else if (c == '>')
+			templateDepth--;
+		if ((templateDepth == 0) && (c == ':') && (checkPtr[1] == ':'))
+		{
+			if (hadTemplate)
+			{
+				// This is to reject cases like NameSpace::TypeName<int>::sField - since we know that there's a typename attached and we just want 'loose' namespaces,
+				// But this still allows NameSpace::Method<int>, where "NameSpace" is indeed a loose namespace we need to catch
+				return NULL;
+			}
+			lastDblColon = checkPtr;
+		}
+		if ((templateDepth == 0) && (c == ' '))
+		{
+			// This catches cases like "Beefy::BfMethodRef::operator Beefy::BfMethodInstance*", where we want to match the :: right before "operator"
+			//  In these cases we do know this is an operator method name so it's not in a loose namespace
+			return NULL;
+		}
+	}
+	return lastDblColon;
+}
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+
+uint8* CvStreamReader::GetTempPtr(int offset, int size, bool mayRecurse, bool* madeCopy)
+{
+	int pageStart = offset >> mPageBits;
+	int pageEnd = (offset + size - 1) >> mPageBits;
+
+	if (pageStart >= pageEnd)
+		return mStreamPtrs.mVals[pageStart] + (offset & ((1<<mPageBits) - 1));
+
+	// Handle the relatively-rare case of spanning multiple pages	
+	if (madeCopy != NULL)
+		*madeCopy = true;
+
+	uint8* destPtr;
+	if (mayRecurse)
+	{
+		if (mCOFF->mTempBufIdx >= mCOFF->mTempBufs.size())
+			mCOFF->mTempBufs.push_back(Array<uint8>());
+		auto& arr = mCOFF->mTempBufs[mCOFF->mTempBufIdx++];
+		if (arr.size() < size)
+			arr.Resize(size);
+		destPtr = arr.mVals;
+	}
+	else
+	{		
+		if (mTempData.size() < size)
+			mTempData.Resize(size);
+		destPtr = mTempData.mVals;
+	}	
+	
+	uint8* dest = destPtr;
+	while (size > 0)
+	{
+		int copyPage = offset >> mPageBits;
+		int pageOffset = offset & ((1 << mPageBits) - 1);
+		int copyBytes = BF_MIN(mCOFF->mCvPageSize - pageOffset, size);
+		memcpy(destPtr, mStreamPtrs.mVals[copyPage] + pageOffset, copyBytes);
+		destPtr += copyBytes;
+		offset += copyBytes;
+		size -= copyBytes;		
+	}
+	return dest;
+}
+
+uint8* CvStreamReader::GetPermanentPtr(int offset, int size, bool* madeCopy)
+{
+	int pageStart = offset >> mPageBits;
+	int pageEnd = (offset + size - 1) >> mPageBits;
+
+	if (pageStart == pageEnd)	
+		return mStreamPtrs.mVals[pageStart] + (offset & ((1 << mPageBits) - 1));	
+	
+	// Handle the relatively-rare case of spanning multiple pages	
+	BP_ALLOC("GetPermanentPtr", size);
+	uint8* destData = mCOFF->mAlloc.AllocBytes(size, "GetPermanentPtr");
+	if (madeCopy != NULL)
+		*madeCopy = true;
+		
+	uint8* destPtr = destData;
+	while (size > 0)
+	{
+		int copyPage = offset >> mPageBits;
+		int pageOffset = offset & ((1 << mPageBits) - 1);
+		int copyBytes = BF_MIN(mCOFF->mCvPageSize - pageOffset, size);
+		memcpy(destPtr, mStreamPtrs.mVals[copyPage] + pageOffset, copyBytes);
+		destPtr += copyBytes;
+		offset += copyBytes;
+		size -= copyBytes;
+	}
+	return destData;
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+COFF::COFF(DebugTarget* debugTarget) : DbgModule(debugTarget)
+{
+	mParseKind = ParseKind_Full;
+	memset(mPDBGuid, 0, 16);
+	mDebugAge = -1;
+	mFileAge = -1;
+	mCvMinTag = -1;
+	mCvMaxTag = -1;		
+	mCvIPIMinTag = -1;
+	mCvIPIMaxTag = -1;
+	mMasterCompileUnit = NULL;
+	mTempBufIdx = 0;
+
+	mCvPageSize = 0;
+	mCvPageBits = 31;
+	mCvDataStream = NULL;
+	mCvHeaderData = NULL;		
+	mCvStrTableData = NULL;	
+	mCvPublicSymbolData = NULL;
+	mCvGlobalSymbolData = NULL;
+	mNewFPOData = NULL;
+	mCvGlobalSymbolInfoStream = 0;
+	mCvPublicSymbolInfoStream = 0;
+	mCvSymbolRecordStream = 0;
+	mCvNewFPOStream = 0;
+	mCvMappedFile = INVALID_HANDLE_VALUE;
+	mCvMappedFileMapping = INVALID_HANDLE_VALUE;
+	mCvMappedViewOfFile = NULL;
+	mCvMappedFileSize = 0;
+	//mParsedProcRecs = false;
+		
+	mGlobalsTargetType = NULL;
+	mPrevScanName = NULL;
+	mProcSymCount = 0;	
+	mCvSrcSrvStream = -1;
+	mIsFastLink = false;
+	mHotThunkCurAddr = 0;
+	mHotThunkDataLeft = 0;
+
+	mTriedSymSrv = false;
+	mDbgSymRequest = NULL;	
+	mWantsAutoLoadDebugInfo = false;		
+	mPDBLoaded = false;
+}
+
+COFF::~COFF()
+{
+	BF_ASSERT(mTempBufIdx == 0);
+	ClosePDB();
+	mDebugger->mDbgSymSrv.ReleaseRequest(mDbgSymRequest);	
+}
+
+const char* COFF::CvCheckTargetMatch(const char* name, bool& wasBeef)
+{	
+	/*if (mGlobalsTargetType->IsGlobalsContainer())
+	{
+		wasBeef = true;
+	}
+	else*/ if (mGlobalsTargetType->mLanguage == DbgLanguage_Beef)
+	{
+		if (strncmp(name, "_bf::", 5) != 0)
+			return NULL;
+		name += 5;
+		wasBeef = true;
+	}
+	else if (mGlobalsTargetType->mTypeCode == DbgType_Root)
+	{
+		if (strncmp(name, "_bf::", 5) == 0)
+		{
+			wasBeef = true;
+			name += 5;
+		}
+	}
+
+	if (mGlobalsTargetType->mName == NULL)
+	{
+		for (const char* cPtr = name; *cPtr != '\0'; cPtr++)
+		{
+			if (*cPtr == ':')
+				return NULL;
+			if (*cPtr == '<')
+				return NULL;
+		}
+
+		return name;
+	}
+
+	const char* memberNamePtr = name;
+	const char* typeName = mGlobalsTargetType->mName;
+
+	while (true)
+	{
+		char cm = *(memberNamePtr++);
+		char ct = *(typeName++);
+		if (ct == 0)
+		{
+			if (cm == ':')
+			{
+				const char* memberName = memberNamePtr + 1;
+				for (const char* cPtr = memberName; *cPtr != '\0'; cPtr++)
+				{
+					if (*cPtr == ':')
+						return NULL;
+					if (*cPtr == '<')
+						return NULL;
+				}
+				return memberName;
+			}
+			return NULL;
+		}
+		if (cm != ct)
+		{
+			if ((cm == ':') && (ct == '.') && (memberNamePtr[0] == ':'))
+			{
+				memberNamePtr++;
+				continue;
+			}
+            return NULL;
+		}
+	}
+}
+
+int COFF::CvGetStringHash(const char* str)
+{	
+	if (str == NULL)
+		return 0;
+
+	int curHash = 0;
+	const char* curHashPtr = str;
+	while (*curHashPtr != 0)
+	{
+		char c = *curHashPtr;		
+		curHash = ((curHash ^ *curHashPtr) << 5) - curHash;
+		curHashPtr++;
+	}
+	return curHash & 0x3FFFFFFF;
+}
+
+// Remove "__ptr64"
+void COFF::CvFixupName(char* name)
+{
+	char* cPtrOut = NULL;
+	for (char* cPtr = name; *cPtr != '\0'; cPtr++)
+	{
+		if ((cPtr[0] == '_') && (cPtr[1] == '_'))
+		{
+			if (strncmp(cPtr + 2, "ptr64", 5) == 0)
+			{
+				if (cPtrOut == NULL)
+					cPtrOut = cPtr;
+				cPtr += 6;
+			}
+		}
+		else if (cPtrOut != NULL)
+		{
+			*(cPtrOut++) = *cPtr;
+		}
+	}
+
+	if (cPtrOut != NULL)	
+		*(cPtrOut++) = '\0';	
+}
+
+void COFF::InitCvTypes()
+{
+	if (mMasterCompileUnit != NULL)
+	{
+		BF_ASSERT(mCompileUnits.size() == 1);
+		return;
+	}
+
+	mDbgFlavor = DbgFlavor_MS;
+	mCvSystemTypes.Resize(0x700);
+
+	DbgType* dbgType;
+	DbgType* ptrType;
+
+#ifdef BF_DBG_32
+	const int ptrMask = 0x0400; // T_32*
+#else
+	const int ptrMask = 0x0600; // T_64*
+#endif
+	mMasterCompileUnit = new DbgCompileUnit(this);	
+	mMasterCompileUnit->mDbgModule = this;	
+	mMasterCompileUnit->mIsMaster = true;
+	mCompileUnits.push_back(mMasterCompileUnit);
+	
+	CREATE_PRIMITIVE(T_NOTTRANS, DbgType_Void, "void", void*);
+	mCvSystemTypes[T_NOTTRANS]->mSize = 0;
+	mCvSystemTypes[T_NOTTRANS]->mAlign = 0;
+	CREATE_PRIMITIVE(T_NOTYPE, DbgType_Void, "void", void*);
+	mCvSystemTypes[T_NOTYPE]->mSize = 0;
+	mCvSystemTypes[T_NOTYPE]->mAlign = 0;
+	CREATE_PRIMITIVE(T_VOID, DbgType_Void, "void", void*);	
+	mCvSystemTypes[T_VOID]->mSize = 0;
+	mCvSystemTypes[T_VOID]->mAlign = 0;
+	mCvSystemTypes[T_PVOID] = ptrType;
+#ifdef BF_DBG_32
+	CREATE_PRIMITIVE(T_HRESULT, DbgType_u32, "HRESULT", addr_target);
+#else
+	CREATE_PRIMITIVE(T_HRESULT, DbgType_u64, "HRESULT", addr_target);
+#endif
+	CREATE_PRIMITIVE(T_CHAR, DbgType_SChar, "char", char);
+	CREATE_PRIMITIVE(T_RCHAR, DbgType_SChar, "char", char); REGISTER_PRIMITIVE();
+	CREATE_PRIMITIVE(T_UCHAR, DbgType_UChar, "char8", uint8); REGISTER_PRIMITIVE();
+	CREATE_PRIMITIVE(T_WCHAR, DbgType_SChar16, "wchar", uint16); REGISTER_PRIMITIVE();
+	CREATE_PRIMITIVE(T_CHAR16, DbgType_UChar16, "char16", uint16);
+	CREATE_PRIMITIVE(T_CHAR32, DbgType_UChar32, "char32", uint32);
+	CREATE_PRIMITIVE(T_INT1, DbgType_i8, "sbyte", int8);
+	CREATE_PRIMITIVE(T_UINT1, DbgType_u8, "byte", uint8);
+	CREATE_PRIMITIVE(T_SHORT, DbgType_i16, "short", int16);
+	CREATE_PRIMITIVE(T_INT2, DbgType_i16, "short", int16);
+	CREATE_PRIMITIVE(T_USHORT, DbgType_u16, "ushort", uint16);
+	CREATE_PRIMITIVE(T_UINT2, DbgType_u16, "ushort", uint16);
+	CREATE_PRIMITIVE(T_LONG, DbgType_i32, "int", int32);
+	CREATE_PRIMITIVE(T_INT4, DbgType_i32, "int", int32);
+	CREATE_PRIMITIVE(T_ULONG, DbgType_i32, "uint", uint32);
+	CREATE_PRIMITIVE(T_UINT4, DbgType_u32, "uint", uint32);
+	CREATE_PRIMITIVE(T_QUAD, DbgType_i64, "int64", int64);
+	CREATE_PRIMITIVE(T_INT8, DbgType_i64, "int64", int64); REGISTER_PRIMITIVE();
+	CREATE_PRIMITIVE(T_UQUAD, DbgType_u64, "uint64", uint64);
+	CREATE_PRIMITIVE(T_UINT8, DbgType_u64, "uint64", uint64); REGISTER_PRIMITIVE();
+	CREATE_PRIMITIVE(T_OCT, DbgType_i128, "int128", uint128);
+	CREATE_PRIMITIVE(T_INT16, DbgType_i128, "int128", uint128);
+	CREATE_PRIMITIVE(T_UOCT, DbgType_u128, "uint128", uint128);
+	CREATE_PRIMITIVE(T_UINT16, DbgType_u128, "uint128", uint128);
+	CREATE_PRIMITIVE(T_BOOL08, DbgType_Bool, "bool", bool);
+	CREATE_PRIMITIVE(T_BOOL32, DbgType_Bool, "bool", int32);
+	CREATE_PRIMITIVE(T_REAL32, DbgType_Single, "float", float);
+	CREATE_PRIMITIVE(T_REAL64, DbgType_Double, "double", double);
+	CREATE_PRIMITIVE(T_REAL80, DbgType_Double, "double80", double); // This isn't correct
+}
+
+addr_target COFF::GetSectionAddr(uint16 section, uint32 offset)
+{
+	if (section == 0)
+		return offset;
+
+	if ((section & 0x8000) != 0)
+	{
+		auto linkedModule = GetLinkedModule();
+		addr_target hiBase = linkedModule->mSecRelEncodingVec[section & 0x7FFF];
+		return hiBase + offset;
+	}
+
+	int rva = mSectionRVAs[section - 1];
+	if (rva == 0)
+		return ADDR_FLAG_ABS + offset;
+
+	return (addr_target)mImageBase + rva + offset;
+}
+
+DbgType* COFF::CvGetType(int typeId)
+{		
+	//TODO: How do we handle types that have the high bit set?
+	if (typeId < 0)
+		return NULL;
+
+	/*if (typeId == 0)
+		return NULL;*/
+	if (typeId < 0x1000)
+	{		
+		TYPE_ENUM_e typeEnum = (TYPE_ENUM_e)typeId;
+		DbgType* type = mCvSystemTypes[typeId];
+		BF_ASSERT(type != NULL);
+		return type;
+	}
+
+	DbgType* type = mCvTypeMap[typeId - mCvMinTag];
+	if (type == NULL)
+		type = CvParseType(typeId);
+
+	/*if ((!allowNull) || (type != NULL))		
+	{
+		BF_ASSERT(type->mCompileUnit->mDbgModule == this);
+	}*/
+
+	return type;
+}
+
+DbgType* COFF::CvGetType(int typeId, CvCompileUnit* compileUnit)
+{
+	if ((typeId & 0x80000000) != 0)
+	{
+		return CvGetType(MapImport(compileUnit, typeId));
+	}
+	return CvGetType(typeId);
+}
+
+int COFF::CvGetTagStart(int tagIdx, bool ipi)
+{
+	if (tagIdx == 0)
+		return NULL;
+	if (ipi)
+		return mCvIPITagStartMap[tagIdx - mCvMinTag];
+	else
+		return mCvTagStartMap[tagIdx - mCvMinTag];				
+}
+
+uint8* COFF::CvGetTagData(int tagIdx, bool ipi, int* outDataSize)
+{
+	if (tagIdx == 0)
+		return NULL;
+
+	auto& reader = ipi ? mCvIPIReader : mCvTypeSectionReader;
+	int offset = ipi ? mCvIPITagStartMap[tagIdx - mCvIPIMinTag] : mCvTagStartMap[tagIdx - mCvMinTag];
+	
+	uint8* data = reader.GetTempPtr(offset, 4);
+	uint16 trLength = *(uint16*)data;
+	data = reader.GetTempPtr(offset + 2, trLength, true);
+
+	if (outDataSize != NULL)
+		*outDataSize = trLength;
+
+	return data;
+}
+
+int64 COFF::CvParseConstant(uint16 constVal, uint8*& data)
+{
+	if (constVal < LF_NUMERIC) // 0x8000
+		return constVal;
+	switch (constVal)
+	{
+	case LF_CHAR:
+		return GET(int8);
+	case LF_SHORT:
+		return GET(int16);
+	case LF_USHORT:
+		return GET(uint16);
+	case LF_LONG:
+		return GET(int32);
+	case LF_ULONG:
+		return GET(uint32);
+	case LF_QUADWORD:
+		return GET(int64);
+	case LF_UQUADWORD:
+		return (int64)GET(uint64);
+	default:
+		BF_FATAL("Not handled");
+	}
+	return 0;
+}
+
+int64 COFF::CvParseConstant(uint8*& data)
+{
+	uint16 val = GET(uint16);	
+	return CvParseConstant(val, data);	
+}
+
+const char* COFF::CvParseString(uint8*& data)
+{	
+	const char* strStart = (const char*)data;
+	int strLen = strlen((const char*)data);
+	if (strLen == 0)
+		return NULL;	
+	data += strLen + 1;
+	return strStart;
+}
+
+const char* COFF::CvParseAndDupString(uint8*& data)
+{
+	int strLen = strlen((const char*)data);
+	if (strLen == 0)
+	{
+		data++;
+		return NULL;
+	}
+
+	BP_ALLOC("CvParseAndDupString", strLen + 1);
+	char* dupStr = (char*)mAlloc.AllocBytes(strLen + 1, "CvParseAndDupString");
+	memcpy(dupStr, data, strLen);
+	data += strLen + 1;
+	return dupStr;
+}
+
+void COFF::CvParseArgList(DbgSubprogram* subprogram, int tagIdx, bool ipi)
+{
+	uint8* data = CvGetTagData(tagIdx, ipi);
+	CvAutoReleaseTempData releaseTempData(this, data);
+
+	int16 trLeafType = GET(int16);	
+
+	BF_ASSERT(trLeafType == LF_ARGLIST);
+
+	int argCount = GET(int32);	
+	for (int argIdx = 0; argIdx < argCount; argIdx++)
+	{
+		CV_typ_t argTypeId = GET(CV_typ_t);
+		DbgType* argType = CvGetType(argTypeId);
+
+		BP_ALLOC_T(DbgVariable);
+		DbgVariable* arg = mAlloc.Alloc<DbgVariable>();		
+		arg->mType = argType;
+		arg->mIsParam = true;
+		subprogram->mParams.PushBack(arg);
+	}
+
+	ReleaseTempBuf(data);
+}
+
+DbgSubprogram* COFF::CvParseMethod(DbgType* parentType, const char* methodName, int tagIdx, bool ipi, DbgSubprogram* subprogram)
+{
+	BP_ZONE("COFF::CvParseMethod");
+
+	uint8* data = CvGetTagData(tagIdx, ipi);
+	CvAutoReleaseTempData releaseTempData(this, data);
+
+	bool fromTypeSection = methodName != NULL;
+
+	if ((methodName != NULL) && (strcmp(methodName, "GetLength") == 0))
+	{
+		NOP;
+	}
+
+	uint8* dataStart = data;
+	int16 trLeafType = GET(int16);
+	
+	if (trLeafType == LF_FUNC_ID)
+	{
+		lfFuncId* funcData = (lfFuncId*)dataStart;				
+		subprogram = CvParseMethod(NULL, (const char*)funcData->name, funcData->type, false, subprogram);
+		return subprogram;
+	}
+
+	if (trLeafType == LF_MFUNC_ID)
+	{
+		lfMFuncId* funcData = (lfMFuncId*)dataStart;
+		auto parentType = CvGetType(funcData->parentType);				
+		//subprogram = CvParseMethod(parentType, (const char*)funcData->name, funcData->type, false, subprogram);
+
+		if ((funcData->name != NULL) && (strcmp((const char*)funcData->name, "CalcNewSize") == 0))
+		{
+			NOP;
+		}
+
+		// We shouldn't pass parentType in there, because that would be the declType and not the actual primary type (ie: definition type)
+		subprogram = CvParseMethod(NULL, (const char*)funcData->name, funcData->type, false, subprogram);
+		return subprogram;
+	}
+
+	//DbgSubprogram* subprogram = mAlloc.Alloc<DbgSubprogram>();	
+	if (subprogram == NULL)
+	{
+		BP_ALLOC_T(DbgSubprogram);
+		subprogram = mAlloc.Alloc<DbgSubprogram>();
+	}
+
+	subprogram->mName = methodName;
+	
+	int argListId = 0;
+	if (trLeafType == LF_MFUNCTION)
+	{
+		static int gMFuncIdx = 0;
+		gMFuncIdx++;
+		
+		lfMFunc* funcData = (lfMFunc*)dataStart;
+		argListId = funcData->arglist;
+		subprogram->mReturnType = CvGetType(funcData->rvtype);
+
+		//TODO:
+		if (parentType == NULL)
+			subprogram->mParentType = CvGetType(funcData->classtype);
+
+		DbgType* thisType = CvGetType(funcData->thistype);
+		if ((thisType != NULL) && (!thisType->IsVoid()))
+		{			
+			BP_ALLOC_T(DbgVariable);
+			DbgVariable* arg = mAlloc.Alloc<DbgVariable>();					
+			arg->mType = thisType;
+			arg->mIsParam = true;
+			arg->mTagIdx = gMFuncIdx;
+			subprogram->mParams.PushBack(arg);
+
+			//TODO: Why did we have this "fromTypeSection" check? It caused non-static methods from S_GPROC32_ID to look like static methods in the autocomplete list
+			//if (fromTypeSection)
+			{
+				arg->mType = thisType;
+				subprogram->mHasThis = true;
+				arg->mName = "this";
+			}
+		}
+	}
+	else if (trLeafType == LF_METHODLIST)
+	{
+		int32 flags = GET(int32);
+		int methodIndex = GET(int32);
+		return CvParseMethod(parentType, methodName, methodIndex, ipi, subprogram);
+	}
+	else if (trLeafType == LF_PROCEDURE)
+	{
+		lfProc* funcData = (lfProc*)dataStart;
+		subprogram->mReturnType = CvGetType(funcData->rvtype);
+		argListId = funcData->arglist;
+	}
+	else if (trLeafType == LF_MFUNC_ID)
+	{
+		//
+		
+	}
+	else
+	{
+		BF_FATAL("Unhandled func type");
+	}
+
+
+	if ((parentType != NULL) && (!mIsHotObjectFile))
+	{		
+		subprogram->mCompileUnit = parentType->mCompileUnit;
+		parentType->mMethodList.PushBack(subprogram);
+	}
+	
+	mSubprograms.push_back(subprogram);
+	CvParseArgList(subprogram, argListId, ipi);
+	return subprogram;
+}
+
+void COFF::CvParseMethodList(DbgType* parentType, const char* methodName, int tagIdx, bool ipi)
+{
+	int dataSize = 0;
+	uint8* data = CvGetTagData(tagIdx, ipi, &dataSize);
+	CvAutoReleaseTempData releaseTempData(this, data);
+
+	uint8* dataEnd = data + dataSize;
+	int16 trLeafType = GET(int16);
+	
+	BF_ASSERT(trLeafType == LF_METHODLIST);
+
+	while (data < dataEnd)
+	{
+		int32 flags = GET(int32);
+		int32 methodIndex = GET(int32);
+		CvParseMethod(parentType, methodName, methodIndex, ipi);
+	}
+}
+
+void COFF::CvParseMembers(DbgType* parentType, int tagIdx, bool ipi)
+{
+	if (tagIdx == NULL)
+		return;
+
+	auto& reader = ipi ? mCvIPIReader : mCvTypeSectionReader;
+	int offset = ipi ? mCvIPITagStartMap[tagIdx - mCvIPIMinTag] : mCvTagStartMap[tagIdx - mCvMinTag];
+
+	uint8* data = reader.GetTempPtr(offset, 4);
+	uint16 trLength = *(uint16*)data;
+	offset += 2;
+	data = reader.GetTempPtr(offset, trLength, true);
+	CvAutoReleaseTempData releaseTempData(this, data);
+	
+	uint8* dataStart = data;	
+	uint8* dataEnd = data + trLength;
+	int16 trLeafType = GET(int16);	
+	bool strMadeCopy;
+
+	auto _ParseString = [&]()
+	{
+		strMadeCopy = false;
+		int nameLen = strlen((const char*)data);
+		int nameOfs = data - dataStart;
+		const char* name = (const char*)reader.GetPermanentPtr(offset + nameOfs, nameLen + 1, &strMadeCopy);
+		data += nameLen + 1;
+		return name;
+	};
+
+	if (trLeafType == 0)
+		return;
+	switch (trLeafType)
+	{
+	case LF_FIELDLIST:	
+		{
+			uint8* sectionStart = data;
+
+			while (data < dataEnd)
+			{
+				uint8* leafDataStart = data;
+				int leafType = (int)GET(uint16);
+				switch (leafType)
+				{
+				case LF_VFUNCTAB:
+					{
+						lfVFuncTab& vfuncTab = *(lfVFuncTab*)leafDataStart;
+						
+						DbgType* vtableType = CvGetType(vfuncTab.type);
+
+						BP_ALLOC_T(DbgVariable);
+						DbgVariable* vtableMember = mAlloc.Alloc<DbgVariable>();
+						vtableMember->mType = vtableType;
+						parentType->mMemberList.PushFront(vtableMember);
+
+						data = (uint8*)(&vfuncTab + 1);
+					}
+					break;
+				case LF_BCLASS:
+					{						
+						lfBClass& baseClassInfo = *(lfBClass*)leafDataStart;						
+
+						BP_ALLOC_T(DbgBaseTypeEntry);
+						DbgBaseTypeEntry* baseTypeEntry = mAlloc.Alloc<DbgBaseTypeEntry>();
+						data = (uint8*)&baseClassInfo.offset;
+						baseTypeEntry->mThisOffset = (int)CvParseConstant(data);
+						if (baseClassInfo.index != 0)
+						{
+							baseTypeEntry->mBaseType = CvGetType(baseClassInfo.index);
+							parentType->mBaseTypes.PushBack(baseTypeEntry);
+							parentType->mAlign = std::max(parentType->mAlign, baseTypeEntry->mBaseType->GetAlign());							
+							
+							if (!parentType->mSizeCalculated)
+							{	
+								if ((parentType->mSize == 0) && (baseTypeEntry->mBaseType->IsBfObject()))
+								{
+									parentType->mExtType = DbgExtType_Interface;
+								}
+
+								parentType->mSize = BF_MAX(parentType->mSize, baseTypeEntry->mBaseType->GetByteCount());
+							}
+						}
+					}
+					break;
+				case LF_VBCLASS:
+				case LF_IVBCLASS:
+					{						
+						lfVBClass& baseClassInfo = *(lfVBClass*)leafDataStart;
+						
+						BP_ALLOC_T(DbgBaseTypeEntry);
+						DbgBaseTypeEntry* baseTypeEntry = mAlloc.Alloc<DbgBaseTypeEntry>();
+						baseTypeEntry->mBaseType = CvGetType(baseClassInfo.index);
+
+						data = (uint8*)&baseClassInfo.vbpoff;
+						baseTypeEntry->mThisOffset = (int)CvParseConstant(data);
+						baseTypeEntry->mVTableOffset = (int)CvParseConstant(data);
+						parentType->mBaseTypes.PushBack(baseTypeEntry);
+					}
+					break;
+				case LF_ENUMERATE:
+					{
+						CV_fldattr_t fieldAttr = GET(CV_fldattr_t);
+						int64 fieldVal = CvParseConstant(data);
+						
+						const char* fieldName = _ParseString();						
+						
+						BP_ALLOC_T(DbgVariable);
+						DbgVariable* member = mAlloc.Alloc<DbgVariable>();
+						member->mCompileUnit = parentType->mCompileUnit;
+						member->mConstValue = fieldVal;
+						member->mName = fieldName;						
+						member->mIsStatic = true;
+						member->mIsConst = true;
+						member->mType = parentType->mTypeParam;
+						FixConstant(member);
+
+						parentType->mMemberList.PushBack(member);
+					}
+					break;
+				case LF_NESTTYPE:
+					{
+						// Resolve nested types at end through 'primary type'
+						//  Nested types also include nested TypeDefs, so the embedded type index may even be a primitive type here
+
+						// Why did we have this check to avoid unnamed nested types?
+						//  it seems we added this and removed it a couple times.
+						//  Disallowing NULL nested types here breaks the "_BUF_SIZE" in String, which is
+						//  an anonymous enum
+						/*int16 pad = GET(int16);
+						int32 nestedTypeId = GET(int32);
+						const char* typeName = CvParseAndDupString(data);
+						if ((typeName != NULL) && (typeName[0] != '<'))
+						{
+							DbgType* nestedType = CvCreateType();
+							nestedType->mTypeParam = CvGetType(nestedTypeId);
+							nestedType->mTypeCode = DbgType_TypeDef;
+							nestedType->mName = typeName;
+							nestedType->mTypeName = typeName;							
+							nestedType->mParent = parentType;
+							parentType->mSubTypeList.PushBack(nestedType);
+						}*/
+
+						int16 pad = GET(int16);
+						int32 nestedTypeId = GET(int32);
+						
+						const char* typeName = _ParseString();
+						
+						DbgType* nestedType = CvCreateType();
+						nestedType->mTypeParam = CvGetType(nestedTypeId);
+						nestedType->mTypeCode = DbgType_TypeDef;
+						if ((typeName != NULL) && (typeName[0] != '<'))
+						{
+							nestedType->mName = typeName;
+							nestedType->mTypeName = typeName;
+						}						
+						nestedType->mParent = parentType;
+						parentType->mSubTypeList.PushBack(nestedType);						
+					}
+					break;
+				case LF_ONEMETHOD:
+					{
+						CV_fldattr_t attr = GET(CV_fldattr_t);
+						CV_typ_t methodTypeId = GET(CV_typ_t);
+						
+						int virtOffset = -1;
+						if ((attr.mprop == CV_MTintro) || (attr.mprop == CV_MTpureintro))
+							virtOffset = GET(int32);
+						const char* methodName = _ParseString();						
+						DbgSubprogram* subProgram = CvParseMethod(parentType, methodName, methodTypeId, ipi);
+						subProgram->mVirtual = (attr.mprop == CV_MTintro) || (attr.mprop == CV_MTpureintro) || (attr.mprop == CV_MTvirtual);
+						subProgram->mVTableLoc = virtOffset;
+					}
+					break;
+				case LF_METHOD:
+					{
+						int count = (int)GET(uint16);
+						int32 methodList = GET(int32);
+						const char* methodName = _ParseString();
+
+						uint8* listData = CvGetTagData(methodList, ipi);
+						CvAutoReleaseTempData releaseTempData(this, listData);
+
+						int16 trLeafType = GET_FROM(listData, int16);
+						BF_ASSERT(trLeafType == LF_METHODLIST);
+
+						for (int methodIdx = 0; methodIdx < count; methodIdx++)
+						{
+							CV_fldattr_t attr = GET_FROM(listData, CV_fldattr_t);														
+							int16 unused = GET_FROM(listData, int16);
+							CV_typ_t methodTypeId = GET_FROM(listData, CV_typ_t);
+							int virtOffset = -1;
+							if ((attr.mprop == CV_MTintro) || (attr.mprop == CV_MTpureintro))
+								virtOffset = GET_FROM(listData, int32);
+
+							DbgSubprogram* subProgram = CvParseMethod(parentType, methodName, methodTypeId, ipi);							
+							subProgram->mVirtual = (attr.mprop == CV_MTintro) || (attr.mprop == CV_MTpureintro) || (attr.mprop == CV_MTvirtual);
+							subProgram->mVTableLoc = virtOffset;
+						}
+					}
+					break;				
+				case LF_MEMBER:
+				case LF_STMEMBER:
+					{
+						bool isStatic = leafType == LF_STMEMBER;
+						bool isConst = false;
+						CV_fldattr_t attr = GET(CV_fldattr_t);
+						CV_typ_t fieldTypeId = GET(CV_typ_t);
+						
+						if (parentType->mTagIdx == 29184)
+						{
+							NOP;
+						}
+
+						int memberOffset = -1;
+						if (isStatic)
+						{
+							//?							
+						}
+						else
+						{
+							memberOffset = (int)CvParseConstant(data);
+						}
+						char* fieldName = (char*)_ParseString();
+
+						if ((fieldName != NULL) && (strcmp(fieldName, "$prim") == 0))
+						{
+							DbgType* fieldType = CvGetType(fieldTypeId);
+							DbgBaseTypeEntry* baseTypeEntry = mAlloc.Alloc<DbgBaseTypeEntry>();							
+							baseTypeEntry->mThisOffset = 0;
+							baseTypeEntry->mBaseType = fieldType;
+							parentType->mBaseTypes.PushFront(baseTypeEntry);
+							break;
+						}
+
+						int64 constVal = 0;
+						if ((parentType->mLanguage == DbgLanguage_Beef) && (isStatic))
+						{							
+							for (char* cPtr = fieldName; true; cPtr++)
+							{
+								char c = *cPtr;
+								if (c == 0)
+									break;
+								if (c == '$')
+								{
+									if (!strMadeCopy)
+									{
+										int ofs = cPtr - fieldName;
+										fieldName = DbgDupString(fieldName, "CvParseMembers.LF_MEMBER");
+										cPtr = fieldName + ofs;
+									}
+
+									isConst = true;
+									if (cPtr[1] == '_')
+										constVal = -atoll(cPtr + 2);
+									else
+										constVal = atoll(cPtr + 1);
+									*cPtr = 0;
+									break;
+								}
+							}
+						}						
+
+						if ((isStatic) && (!isConst) && (mIsHotObjectFile))
+						{
+							// Already has statics filled in
+							break;
+						}						
+
+						BP_ALLOC_T(DbgVariable);
+						DbgVariable* member = mAlloc.Alloc<DbgVariable>();
+						member->mIsStatic = isStatic;												
+
+						DbgType* fieldType = CvGetType(fieldTypeId);
+// 						if (fieldType == NULL)
+// 						{														
+// 							uint8* fieldTypeData = CvGetTagData(fieldTypeId, ipi);
+// 							CvAutoReleaseTempData releaseTempData(this, fieldTypeData);
+// 
+// 							// It's a section data ptr
+// 							int16 memberLeafType = *((int16*)fieldTypeData);
+// 							switch (memberLeafType)
+// 							{
+// 							case LF_BITFIELD:
+// 								{										
+// 									lfBitfield& bitfield = *(lfBitfield*)fieldTypeData;
+// 									fieldType = CvGetType(bitfield.type);
+// 										
+// 									// Bit offset is expressed in MSB form										
+// 									member->mBitOffset = (fieldType->mSize * 8) - bitfield.position - bitfield.length;
+// 									member->mBitSize = bitfield.length;
+// 								}
+// 								break;
+// 							default:
+// 								BF_FATAL("Unhandled");
+// 							}							
+// 						}	
+
+						if (fieldType == NULL)
+							fieldType = CvGetType(fieldTypeId);
+						
+						if ((fieldType->mTypeCode == DbgType_Enum) && (fieldType->GetByteCount() == 0))
+							fieldType = fieldType->GetPrimaryType();
+
+// 						if (fieldType->mTypeCode == DbgType_Bitfield)
+// 						{
+// 							auto bitfieldType = (DbgBitfieldType*)fieldType;							
+// 							member->mBitOffset = bitfieldType->mPosition;
+// 							member->mBitSize = bitfieldType->mLength;
+// 							fieldType = fieldType->mTypeParam;
+// 						}
+
+						if (isConst)
+						{
+							member->mConstValue = constVal;
+							member->mIsConst = true;
+						}
+						else if (isStatic)
+						{
+							// NOP 
+						}
+						else
+							member->mMemberOffset = memberOffset;
+						member->mType = fieldType;
+						member->mCompileUnit = parentType->mCompileUnit;						
+						member->mName = fieldName;											
+
+						// Size should already be set, right?  It gets set on 'dataSize' in the LF_STRUCT/LF_CLASS
+						//parentType->mSize = std::max(memberOffset + fieldType->mSize, parentType->mSize);
+						if ((!isStatic) && (member->mMemberOffset >= 0))
+						{
+							if (!parentType->mIsPacked)
+								parentType->mAlign = std::max(parentType->mAlign, fieldType->GetAlign());
+
+							if (!parentType->mSizeCalculated)
+							{								
+								parentType->mSize = std::max(memberOffset + fieldType->GetByteCount(), parentType->mSize);
+							}
+						}
+
+						//if (parentType->mAlign > 1)
+							//parentType->mSize = (parentType->mSize + (parentType->mAlign - 1)) & ~(parentType->mAlign - 1);
+						//parentType->mSizeCalculated = true;
+
+						parentType->mMemberList.PushBack(member);
+
+						if (isStatic)
+							parentType->mNeedsGlobalsPopulated = true;
+					}
+					break;								
+				case LF_INDEX:
+					{
+						int _pad = (int)GET(uint16);
+						int32 indexType = GET(int32);
+						CvParseMembers(parentType, indexType, ipi);
+					}
+					break;
+				default:
+					BF_FATAL("Unhandled");					
+				}
+
+				PTR_ALIGN(data, sectionStart, 4);
+			}
+		}
+	break;
+	}
+}
+
+int COFF::CvConvRegNum(int regNum, int* outBits)
+{
+	if ((regNum >= CV_AMD64_R8B) && (regNum <= CV_AMD64_R15B))
+	{
+		if (outBits != NULL)
+			*outBits = 8;
+		regNum -= CV_AMD64_R8B - CV_AMD64_R8;
+	}
+	else if ((regNum >= CV_AMD64_R8W) && (regNum <= CV_AMD64_R15W))
+	{
+		if (outBits != NULL)
+			*outBits = 16;
+		regNum -= CV_AMD64_R8W - CV_AMD64_R8;
+	}
+	else if ((regNum >= CV_AMD64_R8D) && (regNum <= CV_AMD64_R15D))
+	{
+		if (outBits != NULL)
+			*outBits = 32;
+		regNum -= CV_AMD64_R8D - CV_AMD64_R8;
+	}
+
+	switch (regNum)
+	{
+#ifdef BF_DBG_64
+	case CV_AMD64_RAX: return X64Reg_RAX;
+	case CV_AMD64_RDX: return X64Reg_RDX;
+	case CV_AMD64_RCX: return X64Reg_RCX;
+	case CV_AMD64_RBX: return X64Reg_RBX;
+	case CV_AMD64_RSI: return X64Reg_RSI;
+	case CV_AMD64_RDI: return X64Reg_RDI;
+	case CV_AMD64_RBP: return X64Reg_RBP;
+	case CV_AMD64_RSP: return X64Reg_RSP;
+	case CV_AMD64_R8: return X64Reg_R8;
+	case CV_AMD64_R9: return X64Reg_R9;
+	case CV_AMD64_R10: return X64Reg_R10;
+	case CV_AMD64_R11: return X64Reg_R11;
+	case CV_AMD64_R12: return X64Reg_R12;
+	case CV_AMD64_R13: return X64Reg_R13;
+	case CV_AMD64_R14: return X64Reg_R14;
+	case CV_AMD64_R15: return X64Reg_R15;
+	case CV_AMD64_RIP: return X64Reg_RIP;
+
+	case CV_REG_AL: if (outBits != NULL) *outBits = 8; return X64Reg_RAX;
+	case CV_REG_AX: if (outBits != NULL) *outBits = 16; return X64Reg_RAX;
+	case CV_REG_EAX: if (outBits != NULL) *outBits = 32; return X64Reg_RAX;
+	case CV_REG_CL: if (outBits != NULL) *outBits = 8; return X64Reg_RCX;
+	case CV_REG_CX: if (outBits != NULL) *outBits = 16; return X64Reg_RCX;
+	case CV_REG_ECX: if (outBits != NULL) *outBits = 32; return X64Reg_RCX;
+	case CV_REG_DL: if (outBits != NULL) *outBits = 8; return X64Reg_RDX;
+	case CV_REG_DX: if (outBits != NULL) *outBits = 16; return X64Reg_RDX;
+	case CV_REG_EDX: if (outBits != NULL) *outBits = 32; return X64Reg_RDX;
+	case CV_REG_BL: if (outBits != NULL) *outBits = 8; return X64Reg_RBX;
+	case CV_REG_BX: if (outBits != NULL) *outBits = 16; return X64Reg_RBX;
+	case CV_REG_EBX: if (outBits != NULL) *outBits = 32; return X64Reg_RBX;
+	case CV_REG_ESP: if (outBits != NULL) *outBits = 32; return X64Reg_RSP;
+	case CV_REG_EBP: if (outBits != NULL) *outBits = 32; return X64Reg_RBP;
+	case CV_AMD64_SIL: if (outBits != NULL) *outBits = 8; return X64Reg_RSI;
+	case CV_REG_SI: if (outBits != NULL) *outBits = 16; return X64Reg_RSI;
+	case CV_REG_ESI: if (outBits != NULL) *outBits = 32; return X64Reg_RSI;
+	case CV_AMD64_DIL: if (outBits != NULL) *outBits = 8; return X64Reg_RDI;
+	case CV_REG_DI: if (outBits != NULL) *outBits = 16; return X64Reg_RDI;
+	case CV_REG_EDI: if (outBits != NULL) *outBits = 32; return X64Reg_RDI;
+	
+	case CV_AMD64_R8B: *outBits = 8; return X64Reg_R8;
+	case CV_AMD64_R8W: *outBits = 16; return X64Reg_R8;
+	case CV_AMD64_R8D: *outBits = 32; return X64Reg_R8;
+	case CV_AMD64_R9B: *outBits = 8; return X64Reg_R9;
+	case CV_AMD64_R9W: *outBits = 16; return X64Reg_R9;
+	case CV_AMD64_R9D: *outBits = 32; return X64Reg_R9;
+	case CV_AMD64_R10B: *outBits = 8; return X64Reg_R10;
+	case CV_AMD64_R10W: *outBits = 16; return X64Reg_R10;
+	case CV_AMD64_R10D: *outBits = 32; return X64Reg_R10;
+	case CV_AMD64_R11B: *outBits = 8; return X64Reg_R11;
+	case CV_AMD64_R11W: *outBits = 16; return X64Reg_R11;
+	case CV_AMD64_R11D: *outBits = 32; return X64Reg_R11;
+	case CV_AMD64_R12B: *outBits = 8; return X64Reg_R12;
+	case CV_AMD64_R12W: *outBits = 16; return X64Reg_R12;
+	case CV_AMD64_R12D: *outBits = 32; return X64Reg_R12;
+	case CV_AMD64_R13B: *outBits = 8; return X64Reg_R13;
+	case CV_AMD64_R13W: *outBits = 16; return X64Reg_R13;
+	case CV_AMD64_R13D: *outBits = 32; return X64Reg_R13;
+	case CV_AMD64_R14B: *outBits = 8; return X64Reg_R14;
+	case CV_AMD64_R14W: *outBits = 16; return X64Reg_R14;
+	case CV_AMD64_R14D: *outBits = 32; return X64Reg_R14;
+	case CV_AMD64_R15B: *outBits = 8; return X64Reg_R15;
+	case CV_AMD64_R15W: *outBits = 16; return X64Reg_R15;
+	case CV_AMD64_R15D: *outBits = 32; return X64Reg_R15;
+
+	case CV_AMD64_XMM0_0: return X64Reg_XMM00;
+	case CV_AMD64_XMM0_1: return X64Reg_XMM01;
+	case CV_AMD64_XMM0_2: return X64Reg_XMM02;
+	case CV_AMD64_XMM0_3: return X64Reg_XMM03;
+	case CV_AMD64_XMM1_0: return X64Reg_XMM10;
+	case CV_AMD64_XMM1_1: return X64Reg_XMM11;
+	case CV_AMD64_XMM1_2: return X64Reg_XMM12;
+	case CV_AMD64_XMM1_3: return X64Reg_XMM13;
+	case CV_AMD64_XMM2_0: return X64Reg_XMM20;
+	case CV_AMD64_XMM2_1: return X64Reg_XMM21;
+	case CV_AMD64_XMM2_2: return X64Reg_XMM22;
+	case CV_AMD64_XMM2_3: return X64Reg_XMM23;
+	case CV_AMD64_XMM3_0: return X64Reg_XMM30;
+	case CV_AMD64_XMM3_1: return X64Reg_XMM31;
+	case CV_AMD64_XMM3_2: return X64Reg_XMM32;
+	case CV_AMD64_XMM3_3: return X64Reg_XMM33;
+	case CV_AMD64_XMM4_0: return X64Reg_XMM40;
+	case CV_AMD64_XMM4_1: return X64Reg_XMM41;
+	case CV_AMD64_XMM4_2: return X64Reg_XMM42;
+	case CV_AMD64_XMM4_3: return X64Reg_XMM43;
+	case CV_AMD64_XMM5_0: return X64Reg_XMM50;
+	case CV_AMD64_XMM5_1: return X64Reg_XMM51;
+	case CV_AMD64_XMM5_2: return X64Reg_XMM52;
+	case CV_AMD64_XMM5_3: return X64Reg_XMM53;
+	case CV_AMD64_XMM6_0: return X64Reg_XMM60;
+	case CV_AMD64_XMM6_1: return X64Reg_XMM61;
+	case CV_AMD64_XMM6_2: return X64Reg_XMM62;
+	case CV_AMD64_XMM6_3: return X64Reg_XMM63;
+	case CV_AMD64_XMM7_0: return X64Reg_XMM70;
+	case CV_AMD64_XMM7_1: return X64Reg_XMM71;
+	case CV_AMD64_XMM7_2: return X64Reg_XMM72;
+	case CV_AMD64_XMM7_3: return X64Reg_XMM73;
+	case CV_AMD64_XMM8_0: return X64Reg_XMM80;
+	case CV_AMD64_XMM8_1: return X64Reg_XMM81;
+	case CV_AMD64_XMM8_2: return X64Reg_XMM82;
+	case CV_AMD64_XMM8_3: return X64Reg_XMM83;
+	case CV_AMD64_XMM9_0: return X64Reg_XMM90;
+	case CV_AMD64_XMM9_1: return X64Reg_XMM91;
+	case CV_AMD64_XMM9_2: return X64Reg_XMM92;
+	case CV_AMD64_XMM9_3: return X64Reg_XMM93;
+	case CV_AMD64_XMM10_0: return X64Reg_XMM10_0;
+	case CV_AMD64_XMM10_1: return X64Reg_XMM10_1;
+	case CV_AMD64_XMM10_2: return X64Reg_XMM10_2;
+	case CV_AMD64_XMM10_3: return X64Reg_XMM10_3;
+	case CV_AMD64_XMM11_0: return X64Reg_XMM11_0;
+	case CV_AMD64_XMM11_1: return X64Reg_XMM11_1;
+	case CV_AMD64_XMM11_2: return X64Reg_XMM11_2;
+	case CV_AMD64_XMM11_3: return X64Reg_XMM11_3;
+	case CV_AMD64_XMM12_0: return X64Reg_XMM12_0;
+	case CV_AMD64_XMM12_1: return X64Reg_XMM12_1;
+	case CV_AMD64_XMM12_2: return X64Reg_XMM12_2;
+	case CV_AMD64_XMM12_3: return X64Reg_XMM12_3;
+	case CV_AMD64_XMM13_0: return X64Reg_XMM13_0;
+	case CV_AMD64_XMM13_1: return X64Reg_XMM13_1;
+	case CV_AMD64_XMM13_2: return X64Reg_XMM13_2;
+	case CV_AMD64_XMM13_3: return X64Reg_XMM13_3;
+	case CV_AMD64_XMM14_0: return X64Reg_XMM14_0;
+	case CV_AMD64_XMM14_1: return X64Reg_XMM14_1;
+	case CV_AMD64_XMM14_2: return X64Reg_XMM14_2;
+	case CV_AMD64_XMM14_3: return X64Reg_XMM14_3;
+	case CV_AMD64_XMM15_0: return X64Reg_XMM15_0;
+	case CV_AMD64_XMM15_1: return X64Reg_XMM15_1;
+	case CV_AMD64_XMM15_2: return X64Reg_XMM15_2;
+	case CV_AMD64_XMM15_3: return X64Reg_XMM15_3;
+#else
+	case CV_REG_AL: return X86Reg_EAX;
+	case CV_REG_CL: return X86Reg_ECX;
+	case CV_REG_DL: return X86Reg_EDX;
+	case CV_REG_BL: return X86Reg_EBX;
+	case CV_REG_AH: return X86Reg_EAX;
+	case CV_REG_AX: return X86Reg_EAX;
+	case CV_REG_CX: return X86Reg_ECX;
+	case CV_REG_DX: return X86Reg_EDX;
+	case CV_REG_BX: return X86Reg_EBX;
+	case CV_REG_SP: return X86Reg_ESP;
+	case CV_REG_BP: return X86Reg_EBP;
+	case CV_REG_SI: return X86Reg_ESI;
+	case CV_REG_DI: return X86Reg_EDI;
+	case CV_REG_EAX: return X86Reg_EAX;
+	case CV_REG_ECX: return X86Reg_ECX;
+	case CV_REG_EDX: return X86Reg_EDX;
+	case CV_REG_EBX: return X86Reg_EBX;
+	case CV_REG_ESP: return X86Reg_ESP;
+	case CV_REG_EBP: return X86Reg_EBP;
+	case CV_REG_ESI: return X86Reg_ESI;
+	case CV_REG_EDI: return X86Reg_EDI;
+	case CV_REG_IP: return X86Reg_EIP;
+	// 	case CV_REG_XMM0: return X86Reg_XMM00;
+	// 	case CV_REG_XMM1: return X86Reg_XMM01;
+	// 	case CV_REG_XMM2: return X86Reg_XMM02;
+	// 	case CV_REG_XMM3: return X86Reg_XMM03;
+	// 	case CV_REG_XMM4: return X86Reg_XMM04;
+	// 	case CV_REG_XMM5: return X86Reg_XMM05;
+	// 	case CV_REG_XMM6: return X86Reg_XMM06;
+	// 	case CV_REG_XMM7: return X86Reg_XMM07;
+#endif	
+	}
+
+	return 0; // Nope
+
+	BF_FATAL("Invalid register");
+	return 0;
+}
+
+DbgType* COFF::CvCreateType()
+{
+	DbgModule* linkedModule = GetLinkedModule();
+	BP_ALLOC_T(DbgType);
+	DbgType* dbgType = mAlloc.Alloc<DbgType>();
+	dbgType->mCompileUnit = mMasterCompileUnit;
+	dbgType->mTypeIdx = (int)linkedModule->mTypes.size();
+	linkedModule->mTypes.push_back(dbgType);	
+
+	return dbgType;
+}
+
+DbgType* COFF::CvParseType(int tagIdx, bool ipi)
+{
+	auto& reader = ipi ? mCvIPIReader : mCvTypeSectionReader;
+	int offset = ipi ? mCvIPITagStartMap[tagIdx - mCvIPIMinTag] : mCvTagStartMap[tagIdx - mCvMinTag];
+
+	uint8* data = reader.GetTempPtr(offset, 4);
+	uint16 trLength = *(uint16*)data;
+	offset += 2;
+	data = reader.GetTempPtr(offset, trLength, true);
+	CvAutoReleaseTempData releaseTempData(this, data);
+
+	uint8* dataStart = data;
+	uint8* dataEnd = data + trLength;
+	int16 trLeafType = GET(int16);
+	bool strMadeCopy;
+
+	auto _ParseString = [&]()
+	{
+		strMadeCopy = false;
+		int nameLen = strlen((const char*)data);
+		int nameOfs = data - dataStart;
+		const char* name = (const char*)reader.GetPermanentPtr(offset + nameOfs, nameLen + 1, &strMadeCopy);
+		data += nameLen + 1;
+		return name;
+	};
+
+	DbgType* dbgType = NULL;
+
+	switch (trLeafType)
+	{	
+	case LF_ENUM:
+		{
+			int elemCount = (int)GET(uint16);
+			int prop = (int)GET(uint16);
+			int underlyingType = GET(int32);
+			int typeIndex = GET(int32);
+			const char* name = _ParseString();
+						
+			dbgType = CvCreateType();
+			dbgType->mCompileUnit = mMasterCompileUnit;
+			dbgType->mName = name;
+			dbgType->mTypeName = name;
+			//SplitName(dbgType->mName, dbgType->mTypeName, dbgType->mTemplateParams);			
+			dbgType->mTypeCode = DbgType_Enum;
+			dbgType->mTypeParam = CvGetType(underlyingType);			
+			dbgType->mIsIncomplete = true;
+
+			if (dbgType->mTypeParam->GetByteCount() == 0)
+				dbgType->mIsDeclaration = true;
+
+			dbgType->mSize = dbgType->mTypeParam->mSize;
+			dbgType->mAlign = dbgType->mTypeParam->mAlign;
+
+			/*if (dbgType->mTypeParam->GetByteCount() == 0)
+			{
+				// Appears to be a bug where byte-sized enums come out as void (sometimes?)
+				dbgType->mTypeParam = mBfPrimitiveTypes[DbgType_u8];
+			}*/
+
+			//dbgType->mIsDeclaration = typeIndex == 0;
+
+			//CvParseMembers(dbgType, typeIndex, sectionData);
+		}
+		break;
+	case LF_VTSHAPE:
+		{
+			lfVTShape& vtShape = *(lfVTShape*)dataStart;
+
+			dbgType = CvCreateType();
+			dbgType->mTypeCode = DbgType_VTable;
+			dbgType->mSize = vtShape.count * sizeof(addr_target);
+			dbgType->mSizeCalculated = true;
+		}
+		break;
+	case LF_BITFIELD:
+		{
+			//DbgType
+			lfBitfield& bitfield = *(lfBitfield*)dataStart;
+			//dbgType = CvCreateType();
+
+			DbgBitfieldType* bitfieldType = mAlloc.Alloc<DbgBitfieldType>();
+			dbgType = bitfieldType;
+			dbgType->mTypeParam = CvGetType(bitfield.type);
+			dbgType->mTypeCode = DbgType_Bitfield;
+			//bitfieldType->mPosition = (dbgType->mTypeParam->mSize * 8) - bitfield.position - bitfield.length;
+			bitfieldType->mPosition = bitfield.position;
+			bitfieldType->mLength = bitfield.length;			
+			bitfieldType->mSize = dbgType->mTypeParam->mSize;
+			bitfieldType->mAlign = dbgType->mTypeParam->mAlign;
+			dbgType->mSizeCalculated = true;
+			dbgType->mPriority = DbgTypePriority_Unique;
+		}
+		break;
+	case LF_STRUCTURE:
+	case LF_CLASS:		
+		{
+			lfClass& classInfo = *(lfClass*)dataStart;
+			data = (uint8*)&classInfo.data;
+			int dataSize = (int)CvParseConstant(data);
+						
+			const char* name = _ParseString();
+			
+// 			if ((strstr(name, "`") != NULL) || (strstr(name, "::__l") != NULL))
+// 			{
+// 				OutputDebugStrF("Local type: %s\n", name);
+// 			}
+
+			// Remove "enum " from type names
+			for (int i = 0; true; i++)
+			{
+				char c = name[i];
+				if (c == 0)
+					break;
+				if ((c == ' ') && (i >= 5))
+				{
+					if ((name[i - 4] == 'e') &&
+						(name[i - 3] == 'n') &&
+						(name[i - 2] == 'u') &&
+						(name[i - 1] == 'm'))
+					{
+						char prevC = name[i - 5];
+						if ((!isalnum(prevC)) && (prevC != '_'))
+						{
+							if (!strMadeCopy)
+								name = DbgDupString(name, "CvParseType.LF_CLASS");
+
+							memmove((char*)name + i - 4, name + i + 1, strlen(name + i + 1) + 1);
+							i -= 5;
+							continue;
+						}
+					}
+				}
+			}
+
+			dbgType = CvCreateType();
+			dbgType->mCompileUnit = mMasterCompileUnit;
+			dbgType->mIsDeclaration = classInfo.property.fwdref;
+			dbgType->mName = name;
+			dbgType->mTypeName = name;
+			//SplitName(dbgType->mName, dbgType->mTypeName, dbgType->mTemplateParams);
+			if (trLeafType == LF_CLASS)
+				dbgType->mTypeCode = DbgType_Class;
+			else
+				dbgType->mTypeCode = DbgType_Struct;
+
+			DbgType* baseType = NULL;
+			if (classInfo.derived != 0)
+			{
+				baseType = CvGetType(classInfo.derived);
+				BP_ALLOC_T(DbgBaseTypeEntry);
+				DbgBaseTypeEntry* baseTypeEntry = mAlloc.Alloc<DbgBaseTypeEntry>();
+				baseTypeEntry->mBaseType = baseType;
+				dbgType->mBaseTypes.PushBack(baseTypeEntry);
+			}
+
+			if (classInfo.property.packed)
+			{
+				dbgType->mAlign = 1;
+				dbgType->mIsPacked = true;
+			}			
+
+			if (!dbgType->mIsDeclaration)
+			{	
+				dbgType->mSizeCalculated = true;
+				dbgType->mSize = dataSize;
+
+				if (strncmp(name, "_bf:", 4) == 0)
+				{
+					// Beef types have different strides from size
+					dbgType->mSizeCalculated = false;
+				}				
+			}
+			
+			if (classInfo.vshape != 0)			
+			{
+				CvGetType(classInfo.vshape);
+				dbgType->mHasVTable = true;			
+			}
+
+			dbgType->mIsIncomplete = true;
+			//CvParseMembers(dbgType, classInfo.field, sectionData);
+		}
+		break;
+	case LF_UNION:
+		{			
+			lfUnion& classInfo = *(lfUnion*)dataStart;				
+			data = (uint8*)&classInfo.data;
+			int dataSize = (int)CvParseConstant(data);
+			const char* name = _ParseString();
+
+			dbgType = CvCreateType();
+			dbgType->mCompileUnit = mMasterCompileUnit;
+			dbgType->mIsDeclaration = classInfo.property.fwdref;
+			dbgType->mName = name;
+			dbgType->mTypeName = name;
+			//SplitName(dbgType->mName, dbgType->mTypeName, dbgType->mTemplateParams);
+			dbgType->mTypeCode = DbgType_Union;				
+			dbgType->mSize = dataSize;				
+			dbgType->mAlign = 1;
+			dbgType->mSizeCalculated = !dbgType->mIsDeclaration;
+
+			dbgType->mIsIncomplete = true;
+			//CvParseMembers(dbgType, classInfo.field, sectionData);
+		}
+		break;
+
+	case LF_MODIFIER:
+		{				
+			lfModifier& modifier = *(lfModifier*)dataStart;
+			DbgType* outerType = CvGetType(modifier.type);
+			dbgType = outerType;
+
+			if (modifier.attr.MOD_const)
+			{
+				DbgType* innerType = dbgType;
+				dbgType = CvCreateType();					
+				dbgType->mTypeParam = innerType;
+				dbgType->mTypeCode = DbgType_Const;
+				dbgType->mLanguage = innerType->mLanguage;
+			}
+
+			if (modifier.attr.MOD_volatile)
+			{
+				DbgType* innerType = dbgType;
+				dbgType = CvCreateType();
+				dbgType->mTypeParam = innerType;
+				dbgType->mTypeCode = DbgType_Volatile;
+				dbgType->mLanguage = innerType->mLanguage;
+			}
+
+			if (modifier.attr.MOD_unaligned)
+			{
+				DbgType* innerType = dbgType;
+				dbgType = CvCreateType();
+				dbgType->mTypeParam = innerType;
+				dbgType->mTypeCode = DbgType_Unaligned;
+				dbgType->mLanguage = innerType->mLanguage;
+			}			
+		}
+		break;
+	case LF_POINTER:
+		{
+			lfPointer* pointerInfo = (lfPointer*)dataStart;
+
+			dbgType = CvCreateType();				
+			dbgType->mTypeParam = CvGetType(pointerInfo->utype);
+			if (pointerInfo->attr.ptrmode == CV_PTR_MODE_RVREF)
+				dbgType->mTypeCode = DbgType_RValueReference;
+			else if (pointerInfo->attr.ptrmode == CV_PTR_MODE_LVREF)
+				dbgType->mTypeCode = DbgType_Ref;
+			else
+			{
+				dbgType->mTypeCode = DbgType_Ptr;
+				if ((dbgType->mTypeParam != NULL) && (dbgType->mTypeParam->mPtrType == NULL))
+					dbgType->mTypeParam->mPtrType = dbgType;
+			}
+			//dbgType->mSize = pointerInfo->attr.size;				
+			dbgType->mSize = sizeof(addr_target);
+			dbgType->mAlign = dbgType->mSize;
+			dbgType->mSizeCalculated = true;
+			dbgType->mLanguage = dbgType->mTypeParam->mLanguage;
+			
+			/*if (prop.isconst)
+			{
+			DbgType* innerType = dbgType;
+			dbgType = CvCreateType();					
+			dbgType->mTypeParam = innerType;
+			dbgType->mTypeCode = DbgType_Const;
+			dbgType->mSize = innerType->mSize;
+			}*/
+
+			//TODO: Handle const, volatile, ref, restrict, etc				
+		}
+		break;
+	case LF_DIMARRAY:
+		{
+			
+		}
+		break;
+	case LF_ARRAY:
+		{
+			lfArray* array = (lfArray*)dataStart;
+
+			DbgType* indexType = CvGetType(array->idxtype);
+
+			dbgType = CvCreateType();
+			dbgType->mTypeParam = CvGetType(array->elemtype);
+			dbgType->mTypeCode = DbgType_SizedArray;			
+			dbgType->mLanguage = dbgType->mTypeParam->mLanguage;
+			data = (uint8*)&array->data;
+
+			int size = (int)CvParseConstant(data);
+			const char* name = _ParseString();
+			dbgType->mName = name;
+			dbgType->mSize = size;
+			// Beef arrays do not necessarily have aligned sizes
+			dbgType->mSizeCalculated = false;
+			dbgType->mLanguage = dbgType->mTypeParam->mLanguage;
+		}
+		break;
+	case LF_PROCEDURE:
+		{
+			dbgType = CvCreateType();
+
+			//TODO: Calling convetion, etc
+
+			lfProc* proc = (lfProc*)dataStart;
+
+			dbgType->mTypeCode = DbgType_Subroutine;
+			dbgType->mTypeParam = CvGetType(proc->rvtype);
+			BP_ALLOC_T(DbgBlock);
+			dbgType->mBlockParam = mAlloc.Alloc<DbgBlock>();
+
+			uint8* argData = CvGetTagData(proc->arglist, ipi);
+			CvAutoReleaseTempData releaseTempData(this, argData);
+
+			int16 argLeafType = GET_FROM(argData, int16);				
+			BF_ASSERT(argLeafType == LF_ARGLIST);
+			int argCount = GET_FROM(argData, int32);
+			CV_typ_t* argTypes = (CV_typ_t*)argData;
+			for (int paramIdx = 0; paramIdx < proc->parmcount; paramIdx++)
+			{
+				BP_ALLOC_T(DbgVariable);
+				DbgVariable* arg = mAlloc.Alloc<DbgVariable>();		
+				arg->mIsParam = true;
+				arg->mType = CvGetType(argTypes[paramIdx]);
+				arg->mName = "$arg";
+				dbgType->mBlockParam->mVariables.PushBack(arg);
+			}
+		}
+		break;
+	case LF_MFUNCTION:
+		{
+			dbgType = CvCreateType();
+
+			//TODO: Calling convetion, etc
+
+			lfMFunc* proc = (lfMFunc*)dataStart;
+
+			dbgType->mTypeCode = DbgType_Subroutine;
+			dbgType->mTypeParam = CvGetType(proc->rvtype);
+			BP_ALLOC_T(DbgBlock);
+			dbgType->mBlockParam = mAlloc.Alloc<DbgBlock>();
+
+			uint8* argData = CvGetTagData(proc->arglist, ipi);
+			CvAutoReleaseTempData releaseTempData(this, argData);
+
+			int16 argLeafType = GET_FROM(argData, int16);				
+			BF_ASSERT(argLeafType == LF_ARGLIST);
+			int argCount = GET_FROM(argData, int32);
+			CV_typ_t* argTypes = (CV_typ_t*)argData;
+			for (int paramIdx = 0; paramIdx < proc->parmcount; paramIdx++)
+			{
+				BP_ALLOC_T(DbgVariable);
+				DbgVariable* arg = mAlloc.Alloc<DbgVariable>();		
+				arg->mIsParam = true;
+				arg->mType = CvGetType(argTypes[paramIdx]);
+				arg->mName = "$arg";
+				dbgType->mBlockParam->mVariables.PushBack(arg);
+			}
+		}
+		break;
+	}
+
+	if (dbgType != NULL)
+	{
+		if (tagIdx == 14709)
+		{
+			NOP;
+		}
+		dbgType->mTagIdx = tagIdx;
+		int wantIdx = tagIdx - mCvMinTag;
+		mCvTypeMap[wantIdx] = dbgType;
+	}
+
+	return dbgType;
+}
+
+void COFF::ParseTypeData(CvStreamReader& reader, int dataOffset)
+{
+	BP_ZONE("COFF::ParseTypeData");
+
+	//uint8* sectionEnd = sectionData + sectionSize;
+	//uint8* data = sectionData;
+
+	if (mCvMinTag == -1)
+		mCvMinTag = 0x1000;
+
+	int offset = dataOffset;
+
+	bool isTagMapEmpty = mCvTagStartMap.empty();
+	for (int tagIdx = mCvMinTag; true; tagIdx++)
+	{
+		if (tagIdx == mCvMaxTag)
+			break;
+		if (offset >= reader.mSize)
+			break;
+		
+		//OutputDebugStrF("%X %X\n", tagIdx, (int)(data - sectionData));
+
+		BF_ASSERT(((offset) & 3) == 0);
+
+		//PTR_ALIGN(data, sectionData, 4);
+
+		uint8* data = reader.GetTempPtr(offset, 4);
+		uint16 trLength = *(uint16*)data;		
+		uint16 trLeafType = *(uint16*)(data + 2);		
+
+// 		uint16 trLength = GET(uint16);
+// 		uint8* dataStart = data;
+// 		uint16 trLeafType = GET(uint16);
+// 		uint8* dataEnd = dataStart + trLength;
+
+		if (isTagMapEmpty)
+		{
+			mCvTagStartMap.push_back(offset);
+			mCvTypeMap.push_back(NULL);
+		}
+		else
+			mCvTagStartMap[tagIdx - mCvMinTag] = offset;
+
+		offset += trLength + 2;
+
+		DbgType* dbgType = NULL;
+
+		if (trLeafType == 0)
+			continue;
+
+		if ((trLeafType == LF_ENUM) || (trLeafType == LF_CLASS) || (trLeafType == LF_STRUCTURE) || (trLeafType == LF_UNION))
+		{
+			CvParseType(tagIdx);
+		}
+	}
+}
+
+void COFF::ParseTypeData(int sectionNum, CvStreamReader& reader, int& sectionSize, int& dataOfs, int& hashStream, int& hashAdjOffset, int& hashAdjSize, int& minVal, int& maxVal)
+{
+	BP_ZONE("COFF::ParseTypeData");
+
+	sectionSize = 0;
+// 	sectionData = CvReadStream(sectionNum, &sectionSize);
+// 	if (sectionData == NULL)
+// 		return;
+// 	uint8* data = sectionData;	
+
+	CvReadStream(sectionNum, reader);
+	uint8* data = reader.GetTempPtr(0, 0);
+	uint8* sectionData = data;
+
+	int32 ver = GET(int32);
+	int32 headerSize = GET(int32);
+	minVal = GET(int32);
+	maxVal = GET(int32);
+	int32 followSize = GET(int32);
+
+	hashStream = GET(int16);
+	int16 hashStreamPadding = GET(int16); // -1
+	int32 hashKeySize = GET(int32); // 4
+	int32 hashBucketsSize = GET(int32); // 0x3ffff
+	int32 hashValsOffset = GET(int32); // 0
+	int32 hashValsSize = GET(int32);
+	int32 hashTypeIndexOffset = GET(int32);
+	int32 hashTypeIndexSize = GET(int32);
+	hashAdjOffset = GET(int32);
+	hashAdjSize = GET(int32);
+
+	dataOfs = 14 * 4;
+
+	uint8* typeDataHead = data;
+
+	bool validate = false;
+
+	// Validate hash info - not necessary, just for debugging
+	if (validate)
+	{
+		BF_FATAL("Fix validate stuff to work with new CvReader");
+
+		int hashStreamSize = 0;
+		uint8* hashDataHead = CvReadStream(hashStream, &hashStreamSize);
+
+		int tagId = minVal;
+
+		//////// Validate Type indices
+		int typeIndexCount = hashTypeIndexSize / 8;
+		// We expect a TypeIndexOffset for every 8k of data, plus the zero at the start		
+		int expectedTypeIndices = (sectionSize - (int)(data - sectionData)) / 8192 + 1;
+		// Assert it's in some acceptable range...
+
+		BF_ASSERT((typeIndexCount > expectedTypeIndices / 2) && (typeIndexCount < expectedTypeIndices * 2));
+		for (int entryIdx = 0; entryIdx < typeIndexCount; entryIdx++)
+		{
+			data = hashDataHead + hashTypeIndexOffset + entryIdx * 8;
+			GET_INTO(int, typeIdx);
+			GET_INTO(int, ofs);
+
+			uint8* dataEnd;
+			int endTagId;
+			if (entryIdx < typeIndexCount - 1)
+			{
+				endTagId = GET(int);
+				int endOfs = GET(int);
+				dataEnd = typeDataHead + endOfs;
+			}
+			else
+			{
+				endTagId = maxVal;
+				dataEnd = sectionData + sectionSize;
+			}
+
+			data = typeDataHead + ofs;
+			while (data < dataEnd)
+			{
+				int tagSize = GET(uint16);
+				data += tagSize;
+				tagId++;
+			}
+			BF_ASSERT(data == dataEnd);
+			BF_ASSERT(tagId == endTagId);
+		}
+
+		BF_ASSERT(tagId == maxVal);
+
+		////// Validate hashes
+		int hashCount = hashValsSize / 4;
+		BF_ASSERT(hashCount == maxVal - minVal);
+		tagId = minVal;
+		int32* hashVals = (int32*)(hashDataHead + hashValsOffset);
+		data = typeDataHead;
+		Array<int> tagStarts;
+		tagStarts.Reserve(maxVal - minVal);
+		for (int hashIdx = 0; hashIdx < hashCount; hashIdx++)
+		{
+			int32 expectHashVal = hashVals[hashIdx];
+
+			PTR_ALIGN(data, sectionData, 4);
+			tagStarts.push_back((int)(data - sectionData));
+			int32 hashVal = BlHash::GetTypeHash(data) % hashBucketsSize;
+			BF_ASSERT(hashVal == expectHashVal);
+
+			tagId++;
+		}
+
+		//////// Validate hash adjusters
+		if (hashAdjSize > 0)
+		{
+			data = hashDataHead + hashAdjOffset;
+			uint8* dataEnd = data + hashAdjSize;
+
+			GET_INTO(int32, adjustCount);
+			GET_INTO(int32, adjustCapacity);
+
+			GET_INTO(int32, usedLen);
+			uint32* usedBitsArr = (uint32*)data;
+			data += usedLen * sizeof(int32);
+			GET_INTO(int32, deletedLen);
+			uint32* deletedBitsArr = (uint32*)data;
+			data += deletedLen * sizeof(int32);
+
+			int curAdjIdx = 0;
+			for (int usedIdx = 0; usedIdx < usedLen; usedIdx++)
+			{
+				int usedBits = usedBitsArr[usedIdx];
+				for (int i = 0; i < 32; i++)
+				{
+					if ((usedBits & (1 << i)) != 0)
+					{
+						GET_INTO(int32, adjVal);
+						GET_INTO(CV_typ_t, typeId);
+
+						uint8* typeData = sectionData + tagStarts[typeId - minVal];
+						int32 hashVal = BlHash::GetTypeHash(typeData) % hashBucketsSize;
+
+						const char* strVal = mStringTable.mStrTable + adjVal;
+						int32 strHashVal = BlHash::HashStr_PdbV1(strVal) % hashBucketsSize;
+
+						BF_ASSERT(hashVal == strHashVal);
+
+						curAdjIdx++;
+					}
+				}
+			}
+
+			BF_ASSERT(curAdjIdx == adjustCount);
+		}
+
+		data = typeDataHead;
+	}
+}
+
+void COFF::ParseTypeData()
+{
+	if (!mPDBLoaded)
+		return;
+	if (mParsedTypeData)
+		return;
+	mParsedTypeData = true;
+
+	auto linkedModule = GetLinkedModule();
+	int startingTypeIdx = (int)linkedModule->mTypes.size();
+
+	//uint8* sectionData;
+	int sectionSize = 0;
+	int hashAdjOffset = 0;
+	int32 hashStream = -1;
+	int32 hashAdjSize = 0;
+	int32 dataOffset = 0;	
+	
+	ParseTypeData(2, mCvTypeSectionReader, sectionSize, dataOffset, hashStream, hashAdjOffset, hashAdjSize, mCvMinTag, mCvMaxTag);
+	//mCvTypeSectionData = sectionData;
+		
+	mCvTypeMap.Clear();
+	mCvTagStartMap.Clear();
+	mCvTypeMap.Resize(mCvMaxTag - mCvMinTag);
+	mCvTagStartMap.Resize(mCvMaxTag - mCvMinTag);
+
+	//DbgDataMap dataMap(minVal, maxVal);
+
+	//uint8* data = sectionData + dataOffset;
+	ParseTypeData(mCvTypeSectionReader, dataOffset);
+
+	if (hashAdjSize > 0)
+	{
+		int sectionSize = 0;
+		uint8* data = CvReadStream(hashStream, &sectionSize);
+		uint8* sectionData = data;
+
+		data = sectionData + hashAdjOffset;
+
+		GET_INTO(int32, adjustCount);
+		GET_INTO(int32, unk0);
+		GET_INTO(int32, unkCount);
+		for (int i = 0; i < unkCount; i++)
+		{
+			GET_INTO(int32, unk2);
+		}
+		GET_INTO(int32, unkCount2);
+		for (int i = 0; i < unkCount2; i++)
+		{
+			GET_INTO(int32, unk3);
+		}
+
+		// Types listed in the adjustment table are always primary types, 
+		//  they should override any "old types" with the same name
+		for (int adjIdx = 0; adjIdx < adjustCount; adjIdx++)
+		{
+			GET_INTO(int32, adjVal);
+			GET_INTO(CV_typ_t, typeId);
+			DbgType* dbgType = CvGetType(typeId);
+			if (dbgType != NULL)
+			{				
+				dbgType->mPriority = DbgTypePriority_Primary_Explicit;
+			}
+		}
+
+		delete [] sectionData;		
+	}
+
+	FixTypes(startingTypeIdx);
+	MapTypes(startingTypeIdx);
+
+	BF_ASSERT(mTempBufIdx == 0);
+}
+
+void COFF::FixConstant(DbgVariable* constVar)
+{
+	if (constVar->mType->mTypeCode == DbgType_u8)
+		constVar->mConstValue &= 0xFF;
+	else if (constVar->mType->mTypeCode == DbgType_u16)
+		constVar->mConstValue &= 0xFFFF;
+	else if (constVar->mType->mTypeCode == DbgType_u32)
+		constVar->mConstValue &= 0xFFFFFFFF;
+}
+
+void COFF::MapRanges(DbgVariable* variable, CV_LVAR_ADDR_RANGE* range, CV_LVAR_ADDR_GAP* gaps)
+{
+	auto rangeStart = GetSectionAddr(range->isectStart, range->offStart);
+	
+	if (variable->mRangeStart == 0)
+	{
+		variable->mRangeStart = rangeStart;		
+		variable->mRangeLen = (rangeStart + range->cbRange) - variable->mRangeStart;
+	}
+	else
+	{		
+		addr_target maxEnd = BF_MAX(variable->mRangeStart + variable->mRangeLen, rangeStart + range->cbRange);
+		variable->mRangeStart = BF_MIN(variable->mRangeStart, rangeStart);
+		variable->mRangeLen = maxEnd - variable->mRangeStart;
+	}
+}
+
+void COFF::MakeThis(DbgSubprogram* curSubprogram, DbgVariable*& curParam)
+{
+	if ((curParam != NULL) || (curSubprogram->mParams.mHead != NULL))
+		return;
+
+	BP_ALLOC_T(DbgVariable);
+	curParam = mAlloc.Alloc<DbgVariable>();
+	curParam->mIsParam = true;
+	curParam->mName = "this";
+	curSubprogram->mParams.mHead = curParam;
+}
+
+static int gSymCount = 0;
+
+void COFF::ParseCompileUnit_Symbols(DbgCompileUnit* compileUnit, uint8* sectionData, uint8* data, uint8* symDataEnd, CvInlineInfoVec& inlineDataVec, bool wantDeferInternals, DbgSubprogram* useSubprogram)
+{
+	bool isOptimized = false;
+
+	uint8* dataHead = data;
+
+	CvCompileUnit* cvCompileUnit = (CvCompileUnit*)compileUnit;
+
+	uint8* symDataStart = data;
+	DbgSubprogram* curSubprogram = NULL;	
+	DbgVariable* curRegRelVariable = NULL;
+	DbgVariable* curParam = NULL;
+	DbgVariable* localVar = NULL;
+	bool inLocalVarRanged = false;
+	SizedArray<DbgBlock*, 16> blockStack;
+	blockStack.push_back(compileUnit->mGlobalBlock);
+	int deferBlockDepth = 0;
+	int deferInlineDepth = 0;
+
+	uint8* newLocationDataStart = NULL;
+	uint8* locationDataStart = NULL;
+	uint8* locationDataEnd = NULL;
+	int locationDataCount = 0;
+
+	struct _DeferredVariableLocation
+	{
+		DbgVariable* mVariable;
+		uint8* mRangedStart;
+		int mRangedLength;
+
+		_DeferredVariableLocation()
+		{
+			mVariable = NULL;
+			mRangedStart = NULL;
+			mRangedLength = 0;			
+		}
+	};
+	SizedArray<_DeferredVariableLocation, 16> deferredVariableLocations;	
+	int unrangedIdx = -1;
+
+	auto _NextUnrangedLocalVar = [&](const char* name, DbgType* varType)
+	{
+		inLocalVarRanged = false;
+
+		localVar = NULL;
+				
+		unrangedIdx++;
+		while (unrangedIdx < deferredVariableLocations.size())
+		{
+			localVar = deferredVariableLocations[unrangedIdx].mVariable;
+			if (strcmp(localVar->mName, name) == 0)
+				break;
+			localVar = NULL;
+			unrangedIdx++;
+		}		
+
+		bool isParam = false;
+		if (localVar == NULL)
+		{
+			if (curParam != NULL)
+			{
+				isParam = true;
+				if (curParam->mType != varType)
+				{
+					// Type was different, probably from a 'ref' being added when we are passing composites
+					curParam->mName = name;
+					curParam = curParam->mNext;
+				}
+				else
+				{
+					localVar = curParam;
+					curParam = curParam->mNext;
+				}
+			}
+		}
+
+		if (localVar == NULL)
+		{
+			BP_ALLOC_T(DbgVariable);
+			localVar = mAlloc.Alloc<DbgVariable>();
+			if (name != NULL)
+				blockStack.back()->mVariables.PushBack(localVar);
+			//return;
+		}
+		
+		localVar->mName = name;
+		if (isParam)
+			localVar->mIsParam = true;
+		if (strcmp(name, "this") == 0)
+		{
+			MakeThis(curSubprogram, localVar);
+			BF_ASSERT(varType->mTypeCode == DbgType_Ptr);
+			curSubprogram->mParentType = varType->mTypeParam;
+			curSubprogram->mHasThis = true;
+		}
+	};
+
+	auto _FinishLocationData = [&]()
+	{
+		if (locationDataStart == NULL)
+			return;
+
+		if (inLocalVarRanged)
+		{
+			auto& deferredVariableLocation = deferredVariableLocations.back();
+			BF_ASSERT(deferredVariableLocation.mRangedLength == 0);
+			deferredVariableLocation.mRangedStart = locationDataStart;
+			deferredVariableLocation.mRangedLength = (int)(locationDataEnd - locationDataStart);
+		}
+		else
+		{
+			if (unrangedIdx >= deferredVariableLocations.size())
+			{
+				// There was no ranged data, commit just the unranged entry
+				BF_ASSERT(locationDataCount == localVar->mLocationLen);
+				BP_ALLOC("DeferredVarLoc0", locationDataEnd - locationDataStart);
+				localVar->mLocationData = mAlloc.AllocBytes(locationDataEnd - locationDataStart, "DeferredVarLoc0");
+				memcpy((uint8*)localVar->mLocationData, locationDataStart, locationDataEnd - locationDataStart);
+			}
+			else
+			{
+				// We have both ranged an unranged data. Merge them!
+				auto& deferredVariableLocation = deferredVariableLocations[unrangedIdx];
+				auto deferredVar = deferredVariableLocation.mVariable;
+				BF_ASSERT(deferredVar == localVar);
+
+				if (deferredVariableLocation.mRangedLength == 0)
+					BF_ASSERT(locationDataCount == localVar->mLocationLen);
+				else
+					BF_ASSERT(locationDataCount < localVar->mLocationLen);
+				BP_ALLOC("DeferredVarLoc1", deferredVariableLocation.mRangedLength + (locationDataEnd - locationDataStart));
+				localVar->mLocationData = mAlloc.AllocBytes(deferredVariableLocation.mRangedLength + (locationDataEnd - locationDataStart), "DeferredVarLoc1");
+				memcpy((uint8*)localVar->mLocationData, deferredVariableLocation.mRangedStart, deferredVariableLocation.mRangedLength);
+				memcpy((uint8*)localVar->mLocationData + deferredVariableLocation.mRangedLength, locationDataStart, locationDataEnd - locationDataStart);
+
+				deferredVariableLocation.mRangedLength = -1; // Mark as 'handled'
+			}
+		}
+		
+		locationDataStart = NULL;
+		locationDataEnd = NULL;
+		locationDataCount = 0;
+	};
+
+	auto _FlushDeferredVariableLocations = [&]()
+	{
+		for (auto& deferredVariableLocation : deferredVariableLocations)
+		{
+			if (deferredVariableLocation.mRangedLength == -1)
+				continue;
+			auto deferredVar = deferredVariableLocation.mVariable;
+			BP_ALLOC("DeferredVarLoc2", deferredVariableLocation.mRangedLength);
+			deferredVar->mLocationData = mAlloc.AllocBytes(deferredVariableLocation.mRangedLength, "DeferredVarLoc2");
+			memcpy((uint8*)deferredVar->mLocationData, deferredVariableLocation.mRangedStart, deferredVariableLocation.mRangedLength);
+		}
+		deferredVariableLocations.clear();
+		unrangedIdx = -1;
+	};
+
+	bool inlineDebugDump = false;
+		
+	if (useSubprogram != NULL)
+	{
+		curSubprogram = useSubprogram;
+		blockStack.push_back(&curSubprogram->mBlock);
+	
+		curParam = curSubprogram->mParams.mHead;
+		curRegRelVariable = curParam;
+	}
+
+	while (data < symDataEnd)
+	{
+		bool deferInternals = (wantDeferInternals) || (deferInlineDepth > 0);
+
+		gSymCount++;
+
+		uint8* dataStart = data;
+		GET_INTO(uint16, symLen);
+		uint8* dataEnd = data + symLen;
+		GET_INTO(uint16, symType);
+
+		if (!mIsHotObjectFile)
+			BF_ASSERT(symLen % 4 == 2);
+
+		bool newLocalVarHasLocData = false;
+		DbgVariable* prevLocalVar = localVar;
+
+		switch (symType)
+		{
+		case S_LOCAL:
+		case S_BPREL32:
+		case S_REGISTER:
+		case S_REGREL32:
+		case S_GPROC32:
+		case S_LPROC32:
+		case S_GPROC32_ID:
+		case S_LPROC32_ID:
+			// Starting a new var or method
+			if ((!deferInternals) && (locationDataStart != NULL))
+			{
+				_FinishLocationData();
+			}
+			break;
+		}
+		
+		/*if (handled)
+		{
+			data = dataEnd;
+			continue;
+		}*/
+
+		if (inlineDebugDump)
+			BfLogCv("SYMTYPE: %X\n", symType);
+
+		switch (symType)
+		{
+		case S_UDT:
+			{
+				UDTSYM& udtSym = *(UDTSYM*)dataStart;
+
+				DbgType* typeDefType = CvCreateType();
+				typeDefType->mTypeCode = DbgType_TypeDef;
+				typeDefType->mTypeParam = CvGetType(udtSym.typind);				
+				typeDefType->mName = DbgDupString((const char*)udtSym.name, "DbgDupString.S_UDT");				
+				if (strncmp(typeDefType->mName, "_bf::", 5) == 0)
+				{
+					typeDefType->mLanguage = DbgLanguage_Beef;
+					typeDefType->mName += 5;
+				}
+				else
+				{
+					typeDefType->mLanguage = DbgLanguage_C;
+				}
+				typeDefType->mTypeName = typeDefType->mName;
+			}
+			break;
+		case S_OBJNAME:
+			{
+				GET_INTO(int32, objSig);
+				const char* objName = CvParseAndDupString(data);				
+			}
+			break;
+		case S_CONSTANT:
+			{
+				CONSTSYM& constSym = *(CONSTSYM*)dataStart;
+
+				BP_ALLOC_T(DbgVariable);
+				DbgVariable* constVar = mAlloc.Alloc<DbgVariable>();
+				constVar->mName = DbgDupString((const char*)constSym.name, "DbgDupString.S_CONSTANT");
+				constVar->mType = CvGetType(constSym.typind);
+				constVar->mIsConst = true;
+				constVar->mIsStatic = true;
+				constVar->mConstValue = constSym.value;
+
+				data = constSym.name + strlen((const char*)constSym.name) + 1;
+				constVar->mConstValue = CvParseConstant(constSym.value, data);
+				FixConstant(constVar);
+				
+				if (constVar->mName != NULL)
+					blockStack.back()->mVariables.PushBack(constVar);
+			}
+			break;
+		case S_EXPORT:
+			{
+				GET_INTO(int16, ord);
+				struct ExpFlags
+				{
+					unsigned short  fConstant : 1;      // CONSTANT
+					unsigned short  fData : 1;          // DATA
+					unsigned short  fPrivate : 1;       // PRIVATE
+					unsigned short  fNoName : 1;        // NONAME
+					unsigned short  fOrdinal : 1;       // Ordinal was explicitly assigned
+					unsigned short  fForwarder : 1;     // This is a forwarder
+					unsigned short  reserved : 10;      // Reserved. Must be zero.
+				};
+				GET_INTO(ExpFlags, flags);
+				const char* symName = CvParseAndDupString(data);				
+			}
+			break;
+		case S_GDATA32:
+		case S_LDATA32:
+			// In PDB reads we get this from the symbol stream
+			if ((mIsHotObjectFile) || (curSubprogram != NULL))
+			{
+				auto linkedModule = GetLinkedModule();
+				DATASYM32& dataSym = *(DATASYM32*)dataStart;
+				
+				char* name = (char*)dataSym.name;				
+				char* targetName = NULL;
+				DbgType* targetType = mMasterCompileUnit->mGlobalType;
+				bool overrideBeef = false;
+				char* lastDblColon = (char*)GetLastDoubleColon(name);
+				if (lastDblColon != NULL)
+				{
+					targetName = name;
+					name = lastDblColon + 2;
+					*lastDblColon = 0;
+					
+					if (strcmp(targetName, "_bf") == 0)
+					{
+						overrideBeef = true;
+					}
+					else
+					{
+						targetType = CvGetTypeOrNamespace(targetName);
+					}
+				}
+								
+				DbgType* dbgType = CvGetType(dataSym.typind);
+
+				BP_ALLOC_T(DbgVariable);
+				DbgVariable* variable = mAlloc.Alloc<DbgVariable>();
+				variable->mType = dbgType;				
+				variable->mLocationData = dataStart;
+				variable->mLocationLen = 1;
+				variable->mIsStatic = true;
+				variable->mCompileUnit = mMasterCompileUnit;
+				variable->mName = name;
+				if (targetType == mMasterCompileUnit->mGlobalType)
+					variable->mLinkName = name;
+				variable->mIsExtern = symType == S_GDATA32;
+
+				if (curSubprogram != NULL)
+				{
+					if (!mIsHotObjectFile)
+					{
+						// Copy this, we free the source data
+						variable->mName = DbgDupString(name, "DbgDupString.S_GDATA32");
+						BP_ALLOC_T(DATASYM32)
+						auto newPtr = mAlloc.Alloc<DATASYM32>();
+						memcpy(newPtr, variable->mLocationData, sizeof(DATASYM32));
+						variable->mLocationData = (uint8*)newPtr;
+					}					
+					if (variable->mName != NULL)
+						blockStack.back()->mVariables.PushBack(variable);
+					break;
+				}
+
+				//variable->mCompileUnit = m;				
+				// Push front so we will find before the original static declaration (that has no memory associated with it)
+				targetType->mMemberList.PushFront(variable);
+				
+				if ((variable->mIsExtern) && (variable->mLinkName != NULL))
+					mStaticVariables.push_back(variable);				
+			}			
+			break;		
+		case S_GTHREAD32:
+		case S_LTHREAD32:
+			{
+				if ((mIsHotObjectFile) || (curSubprogram != NULL))				
+				{
+					auto linkedModule = GetLinkedModule();
+					THREADSYM32& dataSym = *(THREADSYM32*)dataStart;
+
+					char* name = (char*)dataSym.name;
+					char* targetName = NULL;
+					DbgType* targetType = mMasterCompileUnit->mGlobalType;
+					bool overrideBeef = false;
+					char* lastDblColon = (char*)GetLastDoubleColon(name);
+					if (lastDblColon != NULL)
+					{
+						targetName = name;
+						name = lastDblColon + 2;
+						*lastDblColon = 0;
+
+						if (strcmp(targetName, "_bf") == 0)
+						{
+							overrideBeef = true;
+						}
+						else
+						{
+							targetType = CvGetTypeOrNamespace(targetName);
+						}
+					}
+
+					DbgType* dbgType = CvGetType(dataSym.typind);
+
+					BP_ALLOC_T(DbgVariable);
+					DbgVariable* variable = mAlloc.Alloc<DbgVariable>();
+					variable->mType = dbgType;
+					variable->mLocationData = dataStart;
+					variable->mLocationLen = 1;
+					variable->mIsStatic = true;
+					variable->mCompileUnit = mMasterCompileUnit;
+					variable->mName = name;					
+					if (targetType == mMasterCompileUnit->mGlobalType)
+						variable->mLinkName = name;
+					variable->mIsExtern = symType == S_GTHREAD32;
+
+					if (curSubprogram != NULL)
+					{
+						if (!mIsHotObjectFile)
+						{
+							// Copy this, we free the source data
+							variable->mName = DbgDupString(name, "DbgDupString.S_GTHREAD32");
+							BP_ALLOC_T(DATASYM32)
+								auto newPtr = mAlloc.Alloc<DATASYM32>();
+							memcpy(newPtr, variable->mLocationData, sizeof(DATASYM32));
+							variable->mLocationData = (uint8*)newPtr;
+						}						
+						if (variable->mName != NULL)
+							blockStack.back()->mVariables.PushBack(variable);
+						break;
+					}
+
+					//variable->mCompileUnit = m;				
+					// Push front so we will find before the original static declaration (that has no memory associated with it)
+					targetType->mMemberList.PushFront(variable);
+
+					if ((variable->mIsExtern) && (variable->mLinkName != NULL))
+						mStaticVariables.push_back(variable);
+				}				
+			}
+			break;
+		case S_GPROC32:
+		case S_LPROC32:
+		case S_GPROC32_ID:
+		case S_LPROC32_ID:
+			{
+				BF_ASSERT(curSubprogram == NULL);
+
+				PROCSYM32* procSym = (PROCSYM32*)dataStart;				
+
+				DbgType* parentType = NULL;
+
+				auto addr = GetSectionAddr(procSym->seg, procSym->off);
+				
+				DbgSubprogram* subprogram;
+				if (procSym->typind == 0)
+				{
+					BP_ALLOC_T(DbgSubprogram);
+					subprogram = mAlloc.Alloc<DbgSubprogram>();
+				}
+				else
+				{					
+					bool ipi = false;
+					if ((!mIsHotObjectFile) && 
+						((symType == S_GPROC32_ID) || (symType == S_LPROC32_ID)))
+					{
+						if (!mCvIPIReader.IsSetup())
+							CvParseIPI();
+						ipi = true;
+					}					
+					subprogram = CvParseMethod(parentType, NULL, procSym->typind, ipi);
+				}
+				subprogram->mTagIdx = (int)(dataEnd - sectionData); // Position for method data
+				subprogram->mIsOptimized = isOptimized;
+				subprogram->mCompileUnit = compileUnit;				
+				const char* name = DbgDupString((const char*)procSym->name, "DbgDupString.S_GPROC32");
+				
+				if (procSym->flags.CV_PFLAG_OPTDBGINFO)
+				{
+					subprogram->mIsOptimized = true;
+				}
+
+				if ((name[0] == '_') && (name[1] == '_'))
+				{
+					// This matches things like "__chkstk" or other system (supposedly) functions
+					subprogram->mIsStepFilteredDefault = true;
+				}
+
+				if (strncmp(name, "_bf::", 5) == 0)
+				{
+					compileUnit->mLanguage = DbgLanguage_Beef;
+				}
+
+				localVar = NULL;
+				bool hasColon = false;
+				for (const char* cPtr = name; *cPtr != 0; cPtr++)				
+					hasColon |= *cPtr == ':';				
+				
+				subprogram->mPrologueSize = procSym->DbgStart;
+				subprogram->mBlock.mLowPC = addr;
+				subprogram->mBlock.mHighPC = subprogram->mBlock.mLowPC + (int32)procSym->len;
+				BF_ASSERT(procSym->len >= 0);
+
+				MapSubprogram(subprogram);
+				
+				curSubprogram = subprogram;
+				curParam = subprogram->mParams.mHead;
+				curRegRelVariable = curParam;
+				blockStack.push_back(&subprogram->mBlock);
+				//OutputDebugStrF("Func: %s\n", subprogram->mName);
+							
+				if (hasColon)
+				{
+					subprogram->mName = name;
+					subprogram->mHasQualifiedName = true;
+					compileUnit->mOrphanMethods.PushBack(curSubprogram);
+				}
+				else
+				{
+					subprogram->mName = name;
+					compileUnit->mGlobalType->mMethodList.PushBack(curSubprogram);
+				}
+			
+				BF_ASSERT(unrangedIdx == -1);
+			}
+			break;
+		case S_THUNK32:
+			{
+				THUNKSYM32& thunkSym = *(THUNKSYM32*)dataStart;
+
+				DbgType* parentType = NULL;
+
+				DbgSubprogram* subprogram;				
+				BP_ALLOC_T(DbgSubprogram);
+				subprogram = mAlloc.Alloc<DbgSubprogram>();				
+				subprogram->mCompileUnit = compileUnit;
+				subprogram->mHasQualifiedName = true;
+				subprogram->mName = DbgDupString((const char*)thunkSym.name, "DbgDupString.S_THUNK32");
+				subprogram->mTagIdx = (int)(dataEnd - sectionData); // Position for method data
+
+				subprogram->mBlock.mLowPC = GetSectionAddr(thunkSym.seg, thunkSym.off);
+				subprogram->mBlock.mHighPC = subprogram->mBlock.mLowPC + thunkSym.len;
+				BF_ASSERT(thunkSym.len >= 0);
+
+				MapSubprogram(subprogram);
+				
+				curSubprogram = subprogram;
+				curParam = subprogram->mParams.mHead;
+				blockStack.push_back(&subprogram->mBlock);
+
+				BF_ASSERT(unrangedIdx == -1);
+
+				//OutputDebugStrF("Func: %s\n", subprogram->mName);
+			}
+			break;
+		case S_BLOCK32:
+			{
+				if (deferInternals)
+				{
+					deferBlockDepth++;
+					break;
+				}
+				
+				BP_ALLOC_T(DbgBlock);
+				DbgBlock* block = mAlloc.Alloc<DbgBlock>();
+				blockStack.back()->mSubBlocks.PushBack(block);
+				blockStack.push_back(block);
+
+				BLOCKSYM32* blockSym = (BLOCKSYM32*)dataStart;
+
+				block->mLowPC = GetSectionAddr(blockSym->seg, blockSym->off);
+				block->mHighPC = block->mLowPC + blockSym->len;
+			}
+			break;
+		case S_FRAMEPROC:
+			{
+				FRAMEPROCSYM* frameProc = (FRAMEPROCSYM*)dataStart;				
+				if (curSubprogram != NULL)
+				{
+// 					if ((curSubprogram->mName != NULL) && (strcmp(curSubprogram->mName, "_bf::IDETest::HotTester::TestFuncs") == 0))
+// 					{
+// 						NOP;
+// 					}
+
+					curSubprogram->mFrameBaseLen = frameProc->cbFrame + frameProc->cbSaveRegs;
+					curSubprogram->mLocalBaseReg = (DbgSubprogram::LocalBaseRegKind)(uint8)frameProc->flags.encodedLocalBasePointer;
+				}
+			}
+			break;
+		case S_BPREL32:
+			{
+				if (deferInternals)
+					break;
+				BPRELSYM32* bpRel32 = (BPRELSYM32*)dataStart;
+
+				const char* name = DbgDupString((const char*)bpRel32->name, "DbgDupString.S_BPREL32");
+				DbgType* varType = CvGetType(bpRel32->typind);
+
+				_NextUnrangedLocalVar(name, varType);
+
+				localVar->mName = name;
+				localVar->mCompileUnit = compileUnit;				
+				localVar->mType = varType;
+				// This is location data now, not just a S_LOCAL opener
+				//prevLocalVar = localVar;
+				newLocalVarHasLocData = true;
+			}
+			break;
+		case S_REGISTER:
+			{
+				if (deferInternals)
+					break;
+				REGSYM* regSym = (REGSYM*)dataStart;				
+				const char* name = DbgDupString((const char*)regSym->name);
+				DbgType* varType = CvGetType(regSym->typind);
+
+				_NextUnrangedLocalVar(name, varType);
+
+				localVar->mName = name;
+				localVar->mCompileUnit = compileUnit;				
+				localVar->mType = varType;
+				// This is location data now, not just a S_LOCAL opener
+				//prevLocalVar = localVar;
+				newLocalVarHasLocData = true;
+			}
+			break;
+		case S_REGREL32:
+			{
+				if (deferInternals)
+					break;
+				REGREL32* regRel32 = (REGREL32*)dataStart;
+				const char* name = DbgDupString((const char*)regRel32->name);
+				DbgType* varType = CvGetType(regRel32->typind);
+
+				_NextUnrangedLocalVar(name, varType);
+
+				localVar->mName = name;
+				localVar->mCompileUnit = compileUnit;				
+				if ((localVar->mType != NULL) && (!localVar->mType->IsPointer()) && (varType->IsPointer()))
+					localVar->mSigNoPointer = true;
+				localVar->mType = varType;
+				// This is location data now, not just a S_LOCAL opener
+				//prevLocalVar = localVar;
+				newLocalVarHasLocData = true;
+			}
+			break;
+		case S_LOCAL:			
+			{
+				if (deferInternals)
+					break;
+
+				inLocalVarRanged = true;
+
+				LOCALSYM& localSym = *(LOCALSYM*)dataStart;
+				char* name = DbgDupString((const char*)localSym.name);
+				
+				bool isConst = false;
+				int64 constVal = 0;
+				if ((compileUnit->mLanguage == DbgLanguage_Beef) && (name[0] != '$'))
+				{
+					for (char* cPtr = name + 1; true; cPtr++)
+					{
+						char c = *cPtr;
+						if (c == 0)
+							break;
+						if (c == '$')
+						{
+							if (cPtr[1] == '_')
+							{
+								isConst = true;
+								constVal = -atoll(cPtr + 2);								
+								*cPtr = 0;
+							}
+							else if ((cPtr[1] >= '0') && (cPtr[1] <= '9'))
+							{
+								isConst = true;
+								constVal = atoll(cPtr + 1);
+								*cPtr = 0;
+							}
+						}						
+					}
+				}
+
+				if ((name != NULL) && (name[0] == '#'))
+				{
+					if (strcmp(name + 1, "StepOver") == 0)
+					{
+						curSubprogram->mIsStepFilteredDefault = true;
+					}					
+
+					localVar = NULL;
+					break;
+				}				
+
+				DbgType* varType = CvGetType(localSym.typind, cvCompileUnit); 
+
+				if (name != NULL)
+				{
+					if ((localSym.flags.fIsOptimizedOut) && (name[0] != '$'))
+					{
+						if (varType->mSize > 0)
+							curSubprogram->mIsOptimized = true;
+					}
+
+					if ((strcmp(name, "this") == 0) && (varType != NULL))
+					{
+						//BF_ASSERT(varType->mTypeCode == DbgType_Ptr);
+						MakeThis(curSubprogram, curParam);
+						curSubprogram->mParentType = varType->mTypeParam;
+						curSubprogram->mHasThis = true;
+					}
+				}
+
+				bool handledLocalVar = false;
+				if (curParam != NULL)
+				{					
+					if ((name != NULL) && (name[0] == '$'))
+					{
+						int strLen = strlen(name);
+						
+						// Splat head
+						const char* dollarPos = strchr(name + 1, '$');
+						const char* nameStr = name + 1;
+						int nameLen = dollarPos - name - 1;
+
+						if ((dollarPos != NULL) &&
+							((localVar == NULL) || (strncmp(localVar->mName, name, nameLen + 1) != 0)))
+						{
+							BP_ALLOC("ParamName", nameLen + 1);
+							char* dupStr = (char*)mAlloc.AllocBytes(nameLen + 1, "ParamName");
+							memcpy(dupStr, nameStr, nameLen);
+							curParam->mName = dupStr;
+							curParam->mIsConst = true;
+							curParam = curParam->mNext;
+
+							if (strcmp(dupStr, "this") == 0)
+								curSubprogram->mHasThis = true;
+						}
+					}
+					else if ((curParam->mType != varType) && (varType->mTypeCode != DbgType_Void))
+					{
+						// Type was different, probably from a 'ref' being added when we are passing composites
+						curParam->mName = name;
+						curParam = curParam->mNext;						
+					}
+					else
+					{
+						localVar = curParam;
+						curParam = curParam->mNext;
+						handledLocalVar = true;
+					}
+				}
+
+				if (!handledLocalVar)
+				{
+					BP_ALLOC_T(DbgVariable);
+					localVar = mAlloc.Alloc<DbgVariable>();					
+					if (name != NULL)
+						blockStack.back()->mVariables.PushBack(localVar);
+				}
+				localVar->mName = name;
+
+				localVar->mCompileUnit = compileUnit;				
+				localVar->mType = varType;
+				localVar->mIsConst = isConst;
+				localVar->mConstValue = constVal;
+
+				_DeferredVariableLocation deferredLocation;
+				deferredLocation.mVariable = localVar;
+				deferredVariableLocations.Add(deferredLocation);
+			}
+			break;
+		case S_DEFRANGE_REGISTER:
+			{
+				if (deferInternals)
+					break;
+				DEFRANGESYMREGISTER& defRangeReg = *(DEFRANGESYMREGISTER*)dataStart;
+				if (localVar != NULL)
+					MapRanges(localVar, &defRangeReg.range, defRangeReg.gaps);				
+			}
+			break;			
+		case S_DEFRANGE_FRAMEPOINTER_REL:
+			{
+				if (deferInternals)
+					break;
+				DEFRANGESYMFRAMEPOINTERREL& defRangeFPRel = *(DEFRANGESYMFRAMEPOINTERREL*)dataStart;				
+				MapRanges(localVar, &defRangeFPRel.range, defRangeFPRel.gaps);				
+			}
+			break;
+		case S_DEFRANGE_SUBFIELD_REGISTER:
+			{
+				if (deferInternals)
+					break;
+				DEFRANGESYMSUBFIELDREGISTER& defRangeSubFieldReg = *(DEFRANGESYMSUBFIELDREGISTER*)dataStart;				
+			}
+			break;
+		case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:
+			{
+				if (deferInternals)
+					break;
+				DEFRANGESYMFRAMEPOINTERREL_FULL_SCOPE& defRangeFPRel = *(DEFRANGESYMFRAMEPOINTERREL_FULL_SCOPE*)dataStart;
+			}
+			break;
+		case S_DEFRANGE_REGISTER_REL:
+			{
+				if (deferInternals)
+					break;
+				DEFRANGESYMREGISTERREL& defRangeRegRel = *(DEFRANGESYMREGISTERREL*)dataStart;
+				if (localVar != NULL)
+					MapRanges(localVar, &defRangeRegRel.range, defRangeRegRel.gaps);								
+			}
+			break;
+		case S_ENDARG:
+			if (deferInternals)
+				break;
+			BF_ASSERT(curParam == NULL);
+			break;
+		case S_END:
+		case S_PROC_ID_END:
+			if (deferBlockDepth > 0)			
+				--deferBlockDepth;			
+			else
+				blockStack.pop_back();
+			BF_ASSERT(blockStack.size() > 0);
+			if (blockStack.size() == 1)
+			{
+				_FinishLocationData();
+				_FlushDeferredVariableLocations();
+
+				// Done with forced subprogram?
+				if (useSubprogram != NULL)
+				{
+					return;
+				}
+				else if (deferInternals)
+				{
+					if (curSubprogram->mTagIdx != -1)
+					{
+						int endOffset = (int)(dataEnd - sectionData);
+						curSubprogram->mDeferredInternalsSize = endOffset - curSubprogram->mTagIdx;
+					}
+				}
+
+				inlineDebugDump = false;
+				curSubprogram = NULL;
+				curParam = NULL;	
+				
+			}
+			break;
+		case S_COMPILE2:
+			{
+				COMPILESYM* compileSym = (COMPILESYM*)dataStart;				
+			}
+			break;
+		case S_COMPILE3:
+			{
+				COMPILESYM3* compileSym = (COMPILESYM3*)dataStart;				
+			}
+			break;
+		case S_ENVBLOCK:
+			{
+				GET_INTO(uint8, flags);
+				while (true)
+				{
+					const char* envKey = CvParseAndDupString(data);
+					if (envKey == NULL)
+						break;
+					const char* envValue = CvParseAndDupString(data);
+				}
+			}
+			break;
+		case S_BUILDINFO:
+			{
+				CV_ItemId buildInfoId = GET(CV_ItemId);				
+			}
+			break;
+		case S_TRAMPOLINE:
+			break;
+		case S_COFFGROUP:
+			break;
+		case S_SECTION:
+			break;
+		case S_FRAMECOOKIE:
+			{
+				FRAMECOOKIE& frameCookie = *(FRAMECOOKIE*)dataStart;				
+			}
+			break;
+		case S_LABEL32:
+			{
+				LABELSYM32& labelSym = *(LABELSYM32*)dataStart;				
+			}
+			break;
+		case S_CALLSITEINFO:
+			{
+				CALLSITEINFO& callSiteInfo = *(CALLSITEINFO*)dataStart;				
+			}
+			break;
+		case S_HEAPALLOCSITE:
+			{
+				HEAPALLOCSITE& heapAllocSite = *(HEAPALLOCSITE*)dataStart;				
+			}
+			break;
+		case S_FILESTATIC:
+			{
+				FILESTATICSYM& fileStaticSym = *(FILESTATICSYM*)dataStart;				
+			}
+			break;
+		case S_CALLEES:
+			{
+				FUNCTIONLIST& calleeList = *(FUNCTIONLIST*)dataStart;				
+			}
+			break;
+		case S_CALLERS:
+			{
+				FUNCTIONLIST& calleeList = *(FUNCTIONLIST*)dataStart;				
+			}
+			break;
+		case S_POGODATA:
+			{
+				POGOINFO& pogoInfo = *(POGOINFO*)dataStart;				
+			}
+			break;
+		
+		case S_INLINESITE:
+		case S_INLINESITE2:
+			{						
+				if (useSubprogram != NULL)
+				{
+					deferInlineDepth++;
+					break; // Already handled this
+				}
+
+				uint32 inlinee;
+				uint8* binaryAnnotations;
+								
+				if (symType == S_INLINESITE)
+				{
+					INLINESITESYM& inlineSite = *(INLINESITESYM*)dataStart;
+					inlinee = inlineSite.inlinee;
+					binaryAnnotations = (uint8*)&inlineSite.binaryAnnotations;
+				}
+				else // S_INLINESITE2
+				{
+					INLINESITESYM2& inlineSite = *(INLINESITESYM2*)dataStart;
+					inlinee = inlineSite.inlinee;
+					binaryAnnotations = (uint8*)&inlineSite.binaryAnnotations;
+				}
+				
+				DbgSubprogram* inlineParent = curSubprogram;
+				DbgSubprogram* subprogram = NULL;
+				if (mIsHotObjectFile)
+				{
+					subprogram = CvParseMethod(NULL, NULL, inlinee, false);
+					subprogram->mCompileUnit = compileUnit;					
+					curSubprogram = subprogram;
+				}
+				else if ((inlinee & 0x80000000) != 0)
+				{
+					BP_ALLOC_T(DbgSubprogram);
+					subprogram = mAlloc.Alloc<DbgSubprogram>(); // ??
+					subprogram->mCompileUnit = compileUnit;
+					
+					if (!mCvIPIReader.IsSetup())
+						CvParseIPI();
+
+					curSubprogram = subprogram;
+				}
+				else
+				{
+					BP_ALLOC_T(DbgSubprogram);
+					subprogram = mAlloc.Alloc<DbgSubprogram>();
+
+					subprogram->mCompileUnit = compileUnit;					
+					curSubprogram = subprogram;
+
+					FixupInlinee(curSubprogram, inlinee);
+				}
+
+				BF_ASSERT(subprogram == curSubprogram);
+
+				curSubprogram->mTagIdx = (int)(dataEnd - sectionData); // Position for method data
+				BP_ALLOC_T(DbgInlineeInfo);
+				curSubprogram->mInlineeInfo = mAlloc.Alloc<DbgInlineeInfo>();
+				curSubprogram->mInlineeInfo->mInlineParent = inlineParent;
+				if (inlineParent->mInlineeInfo != NULL)
+					curSubprogram->mInlineeInfo->mInlineDepth = inlineParent->mInlineeInfo->mInlineDepth + 1;
+				else
+					curSubprogram->mInlineeInfo->mInlineDepth = 1;
+				curSubprogram->mInlineeInfo->mRootInliner = inlineParent->GetRootInlineParent();
+				curSubprogram->mInlineeInfo->mInlineeId = 0;
+				curSubprogram->mFrameBaseData = inlineParent->mFrameBaseData;
+				curSubprogram->mFrameBaseLen = inlineParent->mFrameBaseLen;
+				curSubprogram->mLocalBaseReg = inlineParent->mLocalBaseReg;
+
+				if (curSubprogram->mName == NULL)
+				{
+					/*curSubprogram->mName = "<Inline>";
+
+					String name = StrFormat("<Inline>@%@", curSubprogram);
+					curSubprogram->mName = DbgDupString(name.c_str());*/
+					
+					String name = StrFormat("<Inline>@%@", curSubprogram);
+					curSubprogram->mName = DbgDupString(name.c_str());
+
+					curSubprogram->mInlineeInfo->mInlineeId = inlinee;
+				}
+
+				if (inlineDebugDump)
+				{
+					int depth = curSubprogram->GetInlineDepth();					
+					BfLogCv("S_INLINESITE Ofs:%d Depth:%d Inlinee:%X Subprogram:%@ %s\n  Parent:%@ %s\n", (dataStart - symDataStart), depth, inlinee, 
+						curSubprogram, curSubprogram->mName, curSubprogram->mInlineeInfo->mInlineParent, curSubprogram->mInlineeInfo->mInlineParent->mName);
+				}
+
+				CvInlineInfo inlineInfo;				
+				inlineInfo.mNext = NULL;
+				inlineInfo.mTail = NULL;
+				inlineInfo.mInlinee = inlinee;
+				inlineInfo.mSubprogram = NULL;
+				inlineInfo.mSubprogram = curSubprogram;
+				inlineInfo.mData = binaryAnnotations;
+				inlineInfo.mDataLen = dataEnd - inlineInfo.mData;
+				inlineInfo.mDebugDump = inlineDebugDump;
+				inlineDataVec.push_back(inlineInfo);
+				blockStack.push_back(&curSubprogram->mBlock);
+			}
+			break;
+		case S_INLINESITE_END:
+			{
+				if (inlineDebugDump)
+					BfLogCv("S_INLINESITE_END\n");
+
+				if (deferInlineDepth > 0)
+				{
+					deferInlineDepth--;
+				}
+				else
+				{
+					if (deferInternals)
+					{
+						int endOffset = (int)(dataEnd - sectionData);
+						curSubprogram->mDeferredInternalsSize = endOffset - curSubprogram->mTagIdx;
+					}
+
+					curSubprogram = curSubprogram->mInlineeInfo->mInlineParent;					
+					blockStack.pop_back();
+				}
+			}
+			break;
+		case S_SSEARCH:
+			{
+				SEARCHSYM* searchSym = (SEARCHSYM*)dataStart;				
+			}
+			break;
+		case S_SEPCODE:		
+			{
+				BP_ALLOC_T(DbgSubprogram);
+				curSubprogram = mAlloc.Alloc<DbgSubprogram>();
+				curSubprogram->mCompileUnit = compileUnit;
+				blockStack.push_back(&curSubprogram->mBlock);
+
+				SEPCODESYM* sepCodeSym = (SEPCODESYM*)dataStart;
+
+				auto addr = GetSectionAddr(sepCodeSym->sect, sepCodeSym->off);
+				auto parentAddr = GetSectionAddr(sepCodeSym->sectParent, sepCodeSym->offParent);
+
+				curSubprogram->mBlock.mLowPC = addr;
+				curSubprogram->mBlock.mHighPC = addr + sepCodeSym->length;
+
+				String name = StrFormat("SEPCODE@%p", parentAddr);
+				curSubprogram->mName = DbgDupString(name.c_str());
+				curSubprogram->mTagIdx = (int)(dataEnd - sectionData); // Position for method data
+
+				MapSubprogram(curSubprogram);
+			}
+			break;
+		case S_COMPILE:
+			break;
+		case S_ANNOTATION:
+			break;
+		case S_UNAMESPACE:
+			break;
+		case /*S_FASTLINK*/0x1167:			
+			break;
+		case /*S_INLINEES*/0x1168:			
+			break;
+		case 0x1176:			
+			break;
+		default:
+			BF_FATAL("Unhandled");
+			break;
+		}
+
+		bool hasNewLocalVar = (localVar != prevLocalVar) && (localVar != NULL);
+		if (newLocalVarHasLocData)
+		{			
+			prevLocalVar = localVar;
+		}
+
+		if (deferInlineDepth == 0)
+		{
+			switch (symType)
+			{
+			case S_BPREL32:
+			case S_REGISTER:
+			case S_REGREL32:
+			case S_DEFRANGE_REGISTER:
+			case S_DEFRANGE_FRAMEPOINTER_REL:
+			case S_DEFRANGE_SUBFIELD_REGISTER:
+			case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:
+			case S_DEFRANGE_REGISTER_REL:
+				{
+					if (prevLocalVar != NULL)
+					{
+						/*if (localVar->mLocationData == NULL)					
+						localVar->mLocationData = dataStart;
+						localVar->mLocationLen++;*/					
+						if (locationDataStart == NULL)
+							locationDataStart = dataStart;
+						locationDataEnd = dataEnd;
+						locationDataCount++;
+						localVar->mLocationLen++;
+					}
+				}
+				break;
+			}
+		}
+
+		if (hasNewLocalVar)
+		{
+			if (localVar->mName != NULL)
+			{
+				// This $alias$ hack is unfortunate, but LLVM gets confused when we attempt to tie multiple debug variables
+				//  to the same memory location, which can happen during mixin injection.  The result is that the mixin gets
+				//  some premature instructions attributed to it from the variable declaration.  This fixes that.
+				if (strncmp(localVar->mName, "$alias$", 7) == 0)
+				{
+					localVar->mName += 7;
+					char* dollarPos = (char*)strchr(localVar->mName, '$');
+					if (dollarPos != 0)
+					{
+						*dollarPos = 0;
+						const char* findName = dollarPos + 1;
+
+						bool found = false;
+						for (int blockIdx = (int)blockStack.size() - 1; blockIdx >= 0; blockIdx--)
+						{
+							DbgBlock* block = blockStack[blockIdx];												
+							for (auto checkVar : block->mVariables)
+							{
+								if (strcmp(checkVar->mName, findName) == 0)
+								{
+									localVar->mConstValue = checkVar->mConstValue;
+									localVar->mType = checkVar->mType;
+									localVar->mLocationData = checkVar->mLocationData;
+									localVar->mLocationLen = checkVar->mLocationLen;
+
+									found = true;
+									break;
+								}
+							}
+
+							if (found)
+								break;
+						}
+					}
+				}
+							
+				if (compileUnit->mLanguage != DbgLanguage_Beef)
+				{
+					for (char* cPtr = (char*)localVar->mName; true; cPtr++)
+					{
+						char c = *cPtr;
+						if (c == 0)
+							break;
+						if ((c == '<') || (c == '>'))
+							*cPtr = '$';						
+					}
+				}
+			}
+		}
+
+		/*if (prevLocalVar != NULL)
+		{
+			BF_ASSERT(locationDataCount == prevLocalVar->mLocationLen);
+		}*/
+		
+
+		data = dataEnd;
+		//PTR_ALIGN(data, sectionData, 4);		
+	}
+
+	if (localVar != NULL)
+	{
+		if (locationDataStart != NULL)
+		{
+			_FinishLocationData();
+		}
+	}
+
+	_FlushDeferredVariableLocations();
+}
+
+CvCompileUnit* COFF::ParseCompileUnit(CvModuleInfo* moduleInfo, CvCompileUnit* compileUnit, uint8* sectionData, int sectionSize)
+{
+	BP_ZONE("COFF::ParseCompileUnit");
+
+	CvInlineInfoVec inlineDataVec;
+	Dictionary<uint32, CvInlineInfo*> inlineDataDict;
+
+	if (moduleInfo != NULL)
+	{
+		BfLogCv("ParseCompileUnit %s\n", moduleInfo->mModuleName);
+	}
+	else
+	{
+		BfLogCv("ParseCompileUnit NULL\n");
+	}
+
+	int allocSizeStart = mAlloc.GetAllocSize();
+
+	if (compileUnit == NULL)
+	{
+		compileUnit = new CvCompileUnit(this);
+		mCompileUnits.push_back(compileUnit);
+	}
+	compileUnit->mDbgModule = this;
+	if (moduleInfo != NULL)
+	{
+		compileUnit->mModuleIdx = moduleInfo->mIdx;
+        compileUnit->mName = moduleInfo->mModuleName;
+		moduleInfo->mCompileUnit = compileUnit;
+	}
+	else
+	{
+		compileUnit->mModuleIdx = NULL;
+		compileUnit->mName = mFilePath.c_str();
+	}	
+		
+	uint8* data = sectionData;
+	uint8* dataEnd = NULL;
+
+	GET_INTO(uint32, infoType);
+	BF_ASSERT(infoType == CV_SIGNATURE_C13);
+
+	int taggedSize = sectionSize;
+
+	uint8* debugSubSectionsStart = data;
+	if (moduleInfo != NULL)
+	{		
+		taggedSize = moduleInfo->mLinesBytes;		
+		debugSubSectionsStart = data + moduleInfo->mSymbolBytes - sizeof(uint32);
+	}
+	else
+	{
+		taggedSize = sectionSize - sizeof(uint32);
+	}	
+	
+	if (mStringTable.mStrTable == NULL)
+	{
+		data = debugSubSectionsStart;
+		dataEnd = data + taggedSize;
+		while (data < dataEnd)
+		{
+			PTR_ALIGN(data, sectionData, 4);
+			GET_INTO(int32, lineInfoType);
+			GET_INTO(int32, lineInfoLength);
+			uint8* dataStart = data;
+			uint8* dataEnd = data + lineInfoLength;
+			if (lineInfoType == DEBUG_S_STRINGTABLE)
+			{
+				if (mStringTable.mStrTable == NULL)
+					mStringTable.mStrTable = (const char*)data;
+			}			
+			data = dataEnd;
+		}
+	}
+
+	//
+	{
+		data = debugSubSectionsStart;
+		dataEnd = data + taggedSize;
+		while (data < dataEnd)
+		{
+			PTR_ALIGN(data, sectionData, 4);
+			GET_INTO(int32, lineInfoType);
+			GET_INTO(int32, lineInfoLength);
+			uint8* dataStart = data;
+			uint8* dataEnd = data + lineInfoLength;
+			if (lineInfoType == DEBUG_S_CROSSSCOPEIMPORTS)
+			{
+				while (data < dataEnd)
+				{
+					compileUnit->mImports.Add(CvCrossScopeImport());
+					auto& crossScopeImport = compileUnit->mImports.back();
+					crossScopeImport.mScopeCompileUnit = NULL;
+
+					GET_INTO(uint32, externalScope);
+
+					const char* fileName = mStringTable.mStrTable + externalScope;
+					BfLogCv("DEBUG_S_CROSSSCOPEIMPORTS Scope:%s  ", fileName);
+					crossScopeImport.mScopeName = fileName;
+
+					//
+					/*for (int checkIdx = 0; checkIdx < (int)mCvModuleInfo.size(); checkIdx++)					
+					{
+						auto checkModuleInfo = mCvModuleInfo[checkIdx];
+						if ((checkModuleInfo != NULL) && (checkModuleInfo->mModuleName != NULL) && (stricmp(checkModuleInfo->mModuleName, fileName) == 0))
+						{
+							ParseCompileUnit(checkIdx);
+						}
+					}*/
+
+					GET_INTO(int32, numRefs);
+
+					for (int i = 0; i < numRefs; i++)
+					{
+						GET_INTO(uint32, refId);
+						BfLogCv(" %X", refId);
+
+						crossScopeImport.mImports.Add(refId);
+					}
+
+					BfLogCv("\n");
+				}
+			}
+			else if (lineInfoType == DEBUG_S_CROSSSCOPEEXPORTS)
+			{
+				BfLogCv("DEBUG_S_CROSSSCOPEEXPORTS");
+				while (data < dataEnd)
+				{
+					GET_INTO(int32, localId);
+					GET_INTO(int32, globalId);
+					BfLogCv(" %X=%X", globalId, localId);
+
+					CvCrossScopeExportEntry entry;
+					entry.mLocalId = localId;
+					entry.mGlobalId = globalId;
+					compileUnit->mExports.Add(entry);
+				}
+				BfLogCv("\n");
+			}
+			else if (lineInfoType == DEBUG_S_FRAMEDATA)
+			{
+				uint8* dataPtr = data;
+				addr_target baseAddr = 0;				
+				int relAddr = GET_FROM(dataPtr, int32);
+				ParseFrameDescriptors(dataPtr, dataEnd - dataPtr, GetLinkedModule()->mImageBase + relAddr);
+			}
+			data = dataEnd;
+		}
+	}
+
+	if (moduleInfo != NULL)
+	{
+		data = sectionData + 4;
+		dataEnd = data + moduleInfo->mSymbolBytes - sizeof(uint32);
+		bool wantsDeferInternals = true;
+		ParseCompileUnit_Symbols(compileUnit, sectionData, data, dataEnd, inlineDataVec, wantsDeferInternals, NULL);
+		//ParseCompileUnit_Symbols(compileUnit, sectionData, data, dataEnd, inlineDataVec, false, NULL);
+		data = dataEnd;
+	}	
+
+	// Scan debug subsections to find file checksum table, and to load symbol data for hotloads
+	Dictionary<int, int> checksumFileRefs;
+	{
+		BP_ZONE("ParseCompileUnit_SrcFiles");
+
+		data = debugSubSectionsStart;
+		dataEnd = data + taggedSize;
+		while (true)
+		{
+			PTR_ALIGN(data, sectionData, 4);
+			if (data >= dataEnd)
+				break;
+			GET_INTO(int32, lineInfoType);
+			GET_INTO(int32, lineInfoLength);
+			uint8* dataStart = data;
+			uint8* dataEnd = data + lineInfoLength;
+
+			if (lineInfoType < 0)
+			{
+				// Ignore
+			}
+			else if (lineInfoType == DEBUG_S_SYMBOLS)
+			{
+				ParseCompileUnit_Symbols(compileUnit, sectionData, data, dataEnd, inlineDataVec, false, NULL);
+			}			
+			else if (lineInfoType == DEBUG_S_FILECHKSMS)
+			{
+				BF_ASSERT(checksumFileRefs.size() == 0);
+
+				while (data < dataEnd)
+				{
+					int dataOfs = (int)(data - dataStart);
+
+					GET_INTO(uint, fileTableOfs);
+					
+					const char* fileName = mStringTable.mStrTable + fileTableOfs;
+					DbgSrcFile* srcFile = NULL;
+					if ((fileName[0] == '/') || (fileName[0] == '\\') ||
+						((fileName[0] != 0) && (fileName[1] == ':')))					
+					{
+						srcFile = AddSrcFile(compileUnit, fileName);
+					}
+					else
+					{
+						String fullDir = GetFileDir(mFilePath);
+						fullDir.Append("\\");
+						fullDir.Append(fileName);
+						srcFile = AddSrcFile(compileUnit, fullDir);
+					}
+					if (srcFile->IsBeef())
+						compileUnit->mLanguage = DbgLanguage_Beef;
+
+					GET_INTO(uint8, hashLen);
+					GET_INTO(uint8, hashType);
+					if ((hashType == 1) && (hashLen == 16))
+					{
+						srcFile->mHashKind = DbgHashKind_MD5;
+						memcpy(srcFile->mHash, data, 16);
+					}
+					else if ((hashType == 3) && (hashLen == 32))
+					{
+						srcFile->mHashKind = DbgHashKind_SHA256;
+						memcpy(srcFile->mHash, data, 32);
+					}
+					
+					data += hashLen;
+					checksumFileRefs.TryAdd(dataOfs, (int)compileUnit->mSrcFileRefs.size() - 1);
+					PTR_ALIGN(data, sectionData, 4);
+				}
+			}			
+			else
+			{
+				BF_ASSERT((lineInfoType >= DEBUG_S_SYMBOLS) && (lineInfoType <= DEBUG_S_COFF_SYMBOL_RVA));
+			}
+
+			data = dataEnd;
+		}
+	}
+
+	if (!inlineDataVec.IsEmpty())
+	{
+		for (auto& inlineData : inlineDataVec)
+		{
+			uint32* keyPtr;
+			CvInlineInfo** valuePtr;
+			if (inlineDataDict.TryAdd(inlineData.mInlinee, &keyPtr, &valuePtr))
+			{
+				inlineData.mTail = &inlineData;
+				*valuePtr = &inlineData;
+			}
+			else
+			{
+				(*valuePtr)->mTail->mNext = &inlineData;
+				(*valuePtr)->mTail = &inlineData;
+			}
+		}
+	}
+	int inlineDataIdx = 0;
+	
+	DbgLineDataBuilder lineBuilder(this);
+
+	//
+	{
+		BP_ZONE("ParseCompileUnit_LineInfo");		
+
+		//int totalLineCount = 0;
+		//int targetLineCount = 0;
+
+		int inlineIdx = 0;
+
+// 		struct _InlinerData
+// 		{
+// 			bool mWantSummaryDump;
+// 			Array<DbgInlinee> mInlinees;
+// 			Array<DbgInlineLineData> mInlineLineData;
+// 
+// 			_InlinerData()
+// 			{
+// 				mWantSummaryDump = false;
+// 			}
+// 		};
+// 
+// 		Dictionary<DbgSubprogram*, _InlinerData> deferredInlinerDatas;
+
+		// Line info					
+		data = debugSubSectionsStart;
+		dataEnd = data + taggedSize;
+		while (data < dataEnd)
+		{
+			PTR_ALIGN(data, sectionData, 4);
+			GET_INTO(int32, lineInfoType);
+			GET_INTO(int32, lineInfoLength);
+			uint8* dataStart = data;
+			uint8* dataEnd = data + lineInfoLength;
+
+			if (lineInfoType == DEBUG_S_FILECHKSMS)
+			{
+				// Already handled
+			}
+			else if (lineInfoType == DEBUG_S_LINES)
+			{
+				CV_DebugSLinesHeader_t& lineSec = GET(CV_DebugSLinesHeader_t);
+
+				Array<DbgLineData> lineDataVec;
+				
+				addr_target contribStartAddr = GetSectionAddr(lineSec.segCon, lineSec.offCon);
+
+				while (data < dataEnd)
+				{
+					lineDataVec.Clear();
+					
+					CV_DebugSLinesFileBlockHeader_t& linesFileHeader = GET(CV_DebugSLinesFileBlockHeader_t);
+					DbgSrcFileReference* srcFileRef = &compileUnit->mSrcFileRefs[checksumFileRefs[linesFileHeader.offFile]];
+					bool isBeef = srcFileRef->mSrcFile->IsBeef();
+
+					int expectSize = (int)sizeof(CV_DebugSLinesFileBlockHeader_t) + (int)(linesFileHeader.nLines * sizeof(CV_Line_t));
+					if ((lineSec.flags & CV_LINES_HAVE_COLUMNS) != 0)
+						expectSize += (int)(linesFileHeader.nLines * sizeof(int16) * 2);
+					BF_ASSERT(expectSize == linesFileHeader.cbBlock);
+
+					lineDataVec.Resize(linesFileHeader.nLines);
+					for (int lineIdx = 0; lineIdx < linesFileHeader.nLines; lineIdx++)
+					{
+						CV_Line_t& srcLineData = GET(CV_Line_t);
+
+						DbgLineData& lineData = lineDataVec[lineIdx];
+						lineData.mRelAddress = (uint32)((contribStartAddr + srcLineData.offset) - mImageBase);						
+
+						if (srcLineData.linenumStart == 0xf00f00) // Never step into
+						{
+							if (lineIdx > 0)
+								lineData.mLine = lineDataVec[lineIdx - 1].mLine;
+							lineData.mColumn = -2; // Never step into marker
+						}
+						else if (srcLineData.linenumStart == 0xfeefee) // Always step into
+						{
+							if (lineIdx > 0)
+								lineData.mLine = lineDataVec[lineIdx - 1].mLine;
+							lineData.mColumn = -1; // Always step into marker
+						}
+						else
+							lineData.mLine = srcLineData.linenumStart - 1;
+						
+						// In Beef we always set the column, so a section without CV_LINES_HAVE_COLUMNS indicates a block of invalid
+						//  positions that we want to skip over
+						if (isBeef)
+							lineData.mColumn = -1;
+					}
+
+					if ((lineSec.flags & CV_LINES_HAVE_COLUMNS) != 0)
+					{
+						for (int lineIdx = 0; lineIdx < linesFileHeader.nLines; lineIdx++)
+						{
+							CV_Column_t& srcColumnData = GET(CV_Column_t);
+
+							DbgLineData& lineData = lineDataVec[lineIdx];
+							lineData.mColumn = (int)srcColumnData.offColumnStart - 1;
+						}
+					}
+
+					DbgLineData* lastLineData = NULL;
+					for (int lineIdx = 0; lineIdx < linesFileHeader.nLines; lineIdx++)
+					{
+						DbgLineData& lineData = lineDataVec[lineIdx];						
+						lastLineData = lineBuilder.Add(compileUnit, lineData, srcFileRef->mSrcFile, NULL);
+					}					
+				}
+			}
+			else if (lineInfoType == DEBUG_S_INLINEELINES)
+			{					
+				int linesType = GET(int);
+				while (data < dataEnd)
+				{					
+					int inlinee = 0;
+					int srcFileIdx = -1;
+					int startLine;
+
+					DbgSrcFileReference* startSrcFileRef = NULL;
+					if (linesType == 0)
+					{
+						CodeViewInfo::InlineeSourceLine& lineInfo = GET(CodeViewInfo::InlineeSourceLine);
+						srcFileIdx = checksumFileRefs[lineInfo.fileId];
+						startSrcFileRef = &compileUnit->mSrcFileRefs[srcFileIdx];
+						startLine = lineInfo.sourceLineNum;
+						inlinee = lineInfo.inlinee;						
+					}
+					else if (linesType == 1)
+					{
+						CodeViewInfo::InlineeSourceLineEx& lineInfo = *(CodeViewInfo::InlineeSourceLineEx*)data;
+						srcFileIdx = checksumFileRefs[lineInfo.fileId];
+						startSrcFileRef = &compileUnit->mSrcFileRefs[srcFileIdx];
+						startLine = lineInfo.sourceLineNum;
+						inlinee = lineInfo.inlinee;
+
+						data += sizeof(CodeViewInfo::InlineeSourceLineEx);
+						data += (int)sizeof(CV_off32_t) * lineInfo.countOfExtraFiles;
+					}
+					else
+						BF_FATAL("Invalid DEBUG_S_INLINEELINES lines type");
+					
+					CvInlineInfo* inlineData = NULL;
+					inlineDataDict.TryGetValue(inlinee, &inlineData);
+					
+					while (inlineData != NULL)
+					{		
+						bool inlineDebugDump = inlineData->mDebugDump;
+
+						if (inlineData->mInlinee == -1)
+						{
+							if (inlineDebugDump)
+								BfLogCv("Duplicate data: %X\n", inlinee);
+							break;
+						}
+
+						// Mark as done
+						inlineData->mInlinee = -1;
+
+						int chunkNum = 0;						
+						int curLine = startLine;						
+						int curValidLine = curLine;						
+						bool flushOnLineOffset = false;
+						addr_target lastLineAddr = 0;
+																		
+
+						DbgSrcFileReference* srcFileRef = startSrcFileRef;
+						DbgSubprogram* curSubprogram = inlineData->mSubprogram;
+						
+						DbgSubprogram* inlineParent = inlineData->mSubprogram->GetRootInlineParent();
+						
+						addr_target curAddr = inlineParent->mBlock.mLowPC;
+						lastLineAddr = 0;
+
+						if (inlineDebugDump)
+						{
+							//inlinerData->mWantSummaryDump = true;
+							BfLogCv("------------------------------------------------\nINLINE DATA:%X Idx:%d CurAddr:%@ Line:%d\n SubProgram:%@ %s\n File:%s\n", inlinee, inlineIdx, curAddr, curLine,  
+								curSubprogram, curSubprogram->mName, srcFileRef->mSrcFile->mFilePath.c_str());
+						}
+
+						uint8* annData = inlineData->mData;
+						uint8* annDataEnd = inlineData->mData + inlineData->mDataLen;												
+
+						DbgLineData* curLineData = NULL;
+
+						auto _AddLine = [&]()
+						{
+							if (chunkNum != 0)
+							{
+								curLineData = NULL;
+								return;
+							}
+
+							DbgLineData lineData;														
+							lineData.mLine = curValidLine - 1;							
+							lineData.mRelAddress = (uint32)(curAddr - mImageBase);
+							lineData.mColumn = 0;
+							if (curLine <= 0) // Negative lines mean "invalid position" for inlining
+								lineData.mColumn = -1;							
+							lineData.mContribSize = 0;
+							
+							if ((curSubprogram->mBlock.mLowPC == 0) && (curLineData != NULL))
+								curSubprogram->mBlock.mLowPC = mImageBase + curLineData->mRelAddress;							
+
+							if (inlineDebugDump)
+								BfLogCv(" Adding Line:%d Addr:%@\n", lineData.mLine + 1, lineData.mRelAddress + mImageBase);
+
+							curLineData = lineBuilder.Add(compileUnit, lineData, srcFileRef->mSrcFile, curSubprogram);
+
+						};
+
+						int codeIdx = 0;
+						while (annData < annDataEnd)
+						{							
+							auto annVal = CodeViewInfo::CVUncompressData(annData);
+	
+							switch (annVal)
+							{
+							case CodeViewInfo::BA_OP_Invalid:               // link time pdb contains PADDINGs
+								break;
+							case CodeViewInfo::BA_OP_CodeOffset:            // param : start offset 
+								{
+									int32 offset = (int32)CodeViewInfo::CVUncompressData(annData);
+									curAddr = inlineParent->mBlock.mLowPC + offset;
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_CodeOffset(%d) CurAddr:%@ Line:%d\n", offset, curAddr, curLine);
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeCodeOffsetBase:  // param : nth separated code chunk (main code chunk == 0)
+								{
+									chunkNum = (int32)CodeViewInfo::CVUncompressData(annData);								
+
+									if (inlineDebugDump)
+										BfLogCv("xxxxxxxxx BA_OP_ChangeCodeOffsetBase(%d) CurAddr:%@ Line:%d\n", chunkNum, curAddr, curLine);									
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeCodeOffset:      // param : delta of offset
+								{
+									int32 offset = (int32)CodeViewInfo::CVUncompressData(annData);
+								
+									curAddr += offset;								
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeCodeOffset(%d) CurAddr:%@ Line:%d\n", offset, curAddr, curLine);
+
+									if ((curLineData != NULL) && (curLineData->mContribSize == 0))
+									{
+										curLineData->mRelAddress = (uint32)(curAddr - mImageBase);
+										if (inlineDebugDump)
+											BfLogCv(" Setting addr on previous entry\n");
+									}
+									else
+										_AddLine();
+								
+									flushOnLineOffset = true;
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeCodeLength:      // param : length of code, default next start
+								{
+									int newCodeLen = (int32)CodeViewInfo::CVUncompressData(annData);
+									curAddr += newCodeLen;
+
+									if (curLineData != NULL)
+										curLineData->mContribSize = newCodeLen;
+
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeCodeLength(%d) Addr:%@ EndAddr:%@\n", newCodeLen, curLineData->mRelAddress + mImageBase, curLineData->mRelAddress + mImageBase + curLineData->mContribSize);	
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeFile:            // param : fileId 
+								{
+									uint32 newFileId = CodeViewInfo::CVUncompressData(annData);
+									srcFileRef = &compileUnit->mSrcFileRefs[checksumFileRefs[newFileId]];
+
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeFile(%s) CurAddr:%@ Line:%d\n", srcFileRef->mSrcFile->mFilePath.c_str(), curAddr, curLine);
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeLineOffset:      // param : line offset (signed)
+								{
+									int32 lineOfs = (int32)CodeViewInfo::DecodeSignedInt32(CodeViewInfo::CVUncompressData(annData));
+									curLine += lineOfs;
+									if (curLine > 0)
+										curValidLine = curLine;				
+
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeLineOffset(%d) CurAddr:%@ Line:%d\n", lineOfs, curAddr, curLine);
+
+									_AddLine();
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeLineEndDelta:    // param : how many lines, default 1
+								{
+									int numLines = (int32)CodeViewInfo::CVUncompressData(annData);
+
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeLineEndDelta(%d) CurAddr:%@ Line:%d\n", numLines, curAddr, curLine);
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeRangeKind:       // param : either 1 (default, for statement) or 0 (for expression)															 
+								{
+									int32 readKind = (int32)CodeViewInfo::CVUncompressData(annData);
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeRangeKind(%d) CurAddr:%@ Line:%d\n", readKind, curAddr, curLine);
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeColumnStart:     // param : start column number, 0 means no column info
+								{
+									int column = (int32)CodeViewInfo::CVUncompressData(annData);
+									if (curLineData != NULL)
+										curLineData->mColumn = column;
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeColumnStart(%d) CurAddr:%@ Line:%d\n", column, curAddr, curLine);
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeColumnEndDelta:  // param : end column number delta (signed)
+								{
+									int columnEndDelta = (int32)CodeViewInfo::DecodeSignedInt32(CodeViewInfo::CVUncompressData(annData));
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeColumnEndDelta(%d) CurAddr:%@ Line:%d\n", columnEndDelta, curAddr, curLine);
+								}
+								break;
+								// Combo opcodes for smaller encoding size.
+							case CodeViewInfo::BA_OP_ChangeCodeOffsetAndLineOffset:  // param : ((sourceDelta << 4) | CodeDelta)
+								{
+									int offsetData = (int32)CodeViewInfo::CVUncompressData(annData);
+									int codeDelta = offsetData & 0xF;
+									int sourceDelta = CodeViewInfo::DecodeSignedInt32(offsetData >> 4);
+								
+									curAddr += codeDelta;
+									curLine += sourceDelta;
+									if (curLine > 0)
+										curValidLine = curLine;								
+
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeCodeOffsetAndLineOffset(%d, %d) CurAddr:%@ Line:%d\n", codeDelta, sourceDelta,  curAddr, curLine);
+
+									_AddLine();
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeCodeLengthAndCodeOffset:  // param : codeLength, codeOffset
+								{
+									curValidLine = curLine;
+									int codeLen = (int32)CodeViewInfo::CVUncompressData(annData);
+									int codeOffset = (int32)CodeViewInfo::CVUncompressData(annData);
+
+									curAddr += codeOffset;
+								
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeCodeLengthAndCodeOffset(%d, %d) CurAddr:%@ Line:%d\n", codeLen, codeOffset, curAddr, curLine);
+
+									_AddLine();
+
+									if (curLineData != NULL)
+									{
+										if (inlineDebugDump)
+											BfLogCv(" ContribSize:%d\n", codeLen);
+										curLineData->mContribSize = codeLen;
+									}
+								}
+								break;
+							case CodeViewInfo::BA_OP_ChangeColumnEnd:       // param : end column number
+								{
+									int columnEnd = (int32)CodeViewInfo::CVUncompressData(annData);
+									if (inlineDebugDump)
+										BfLogCv(" BA_OP_ChangeColumnEnd(%d) CurAddr:%@ Line:%d\n", columnEnd, curAddr, curLine);
+								}
+								break;
+							}
+
+							codeIdx++;
+						}
+
+						if (curLineData != NULL)
+						{
+							if (curSubprogram->mBlock.mLowPC == 0)
+								curSubprogram->mBlock.mLowPC = mImageBase + curLineData->mRelAddress;
+							curSubprogram->mBlock.mHighPC = mImageBase + curLineData->mRelAddress + curLineData->mContribSize;
+						}
+
+						inlineData = inlineData->mNext;
+					}
+				}
+			}
+
+			data = dataEnd;
+		}
+
+// 		for (auto& deferredInlinerDataKV : deferredInlinerDatas)
+// 		{
+// 			auto inlinerParent = deferredInlinerDataKV.mKey;
+// 			auto deferredInlinerData = &deferredInlinerDataKV.mValue;
+// 						
+// 			inlinerParent->mInlinerData = mAlloc.Alloc<DbgInlinerData>();
+// 			inlinerParent->mInlinerData->mInlinees.CopyFrom(deferredInlinerData->mInlinees.mVals, deferredInlinerData->mInlinees.mSize, mAlloc);
+// 			inlinerParent->mInlinerData->mInlineLineData.CopyFrom(deferredInlinerData->mInlineLineData.mVals, deferredInlinerData->mInlineLineData.mSize, mAlloc);
+// 			//deferredInlinerData->
+// 
+// 			if (deferredInlinerData->mWantSummaryDump)
+// 			{
+// 				BfLogCv("------------------------------\nSUMMARY FOR: %s\n", inlinerParent->mName);
+// 
+// 				for (auto& inlineLine : inlinerParent->mInlinerData->mInlineLineData)
+// 				{					
+// 					BfLogCv("Addr:%@ EndAddr:%@ Line:%d Column:%d Inlinee:%d\n", inlineLine.mAddress, inlineLine.mAddress + inlineLine.mContribSize, 
+// 						inlineLine.mLine + 1, inlineLine.mColumn + 1, inlineLine.mInlineIdx);
+// 				}
+// 			}
+// 		}
+	}
+
+	lineBuilder.Commit();
+
+
+	//OutputDebugStrF("Module loaded, AllocSize added: %d\n", (mAlloc.GetAllocSize() - allocSizeStart) / 1024);	
+	return compileUnit;
+}
+
+CvCompileUnit* COFF::ParseCompileUnit(int compileUnitId)
+{
+	CvModuleInfo* moduleInfo = mCvModuleInfo[compileUnitId];
+	if (moduleInfo->mCompileUnit != NULL)
+		return moduleInfo->mCompileUnit;
+
+	BP_ZONE("ParseCompileUnit");
+	
+	ParseTypeData();
+
+	if (moduleInfo->mStream == -1)
+		return NULL;
+
+	int sectionSize = 0;
+	uint8* sectionData = CvReadStream(moduleInfo->mStream, &sectionSize);
+	ParseCompileUnit(moduleInfo, NULL, sectionData, sectionSize);
+	delete sectionData;
+	return moduleInfo->mCompileUnit;
+}
+
+DbgType* COFF::CvGetTypeOrNamespace(char* name, DbgLanguage language)
+{	
+	if (language == DbgLanguage_Unknown)
+	{
+		if (strncmp(name, "_bf::", 5) == 0)
+		{
+			language = DbgLanguage_Beef;
+			name += 5;
+		}
+		else if ((name[0] == 'G') && (name[1] == '$'))
+		{
+			language = DbgLanguage_Beef;
+		}
+		else
+		{			
+			language = DbgLanguage_C;
+
+			// Check for a primitive array type like 'double[]'
+			for (int i = 0; i < 10; i++)
+			{
+				char c = name[i];
+				if (c == 0)
+					break;
+				if (c == '[')
+					language = DbgLanguage_Beef;
+			}
+		}
+	}
+
+	auto linkedModule = GetLinkedModule();
+
+	auto dbgTypeEntry = linkedModule->mTypeMap.Find(name, language);
+	if (dbgTypeEntry != NULL)
+	{
+		auto dbgType = dbgTypeEntry->mValue;
+		if (dbgType->mHotNewType != NULL)
+			return dbgType->mHotNewType;
+		return dbgType;
+	}
+	
+	// It's possible that we get a reference to a template name that isn't actually in our type database
+	//  These may indicate VS compiler bugs or anonymous namespaces
+	bool isValidName = true;
+	for (const char* cPtr = name; *cPtr != '\0'; cPtr++)
+		if ((*cPtr == '<') || (*cPtr == '`') || (*cPtr == '$'))
+			isValidName = false;
+	if (!isValidName)
+		return NULL;
+
+	//OutputDebugStrF("CvGetTypeOrNamespace Creating: %s\n", name);
+
+	char* lastDblColon = (char*)GetLastDoubleColon(name);
+	
+	DbgType* dbgType = CvCreateType();
+
+	DbgType* parentType = mMasterCompileUnit->mGlobalType;
+	if (lastDblColon != NULL)
+	{		
+		*lastDblColon = 0;
+		parentType = CvGetTypeOrNamespace(name, language);
+		dbgType->mTypeName = DbgDupString(lastDblColon + 2, "DbgDupString.TypeOrNamespace0");
+		*lastDblColon = ':';
+		dbgType->mName = DbgDupString(name, "DbgDupString.TypeOrNamespace1");
+	}
+	else
+	{
+		dbgType->mTypeName = DbgDupString(name, "DbgDupString.TypeOrNamespace2");
+		dbgType->mName = dbgType->mTypeName;		
+	}	
+	
+	parentType->mSubTypeList.PushBack(dbgType);
+	dbgType->mTypeCode = DbgType_Namespace;
+	dbgType->mLanguage = language;
+	linkedModule->mTypeMap.Insert(dbgType);
+
+	return dbgType;
+}
+
+void COFF::MapCompileUnitMethods(DbgCompileUnit* compileUnit)
+{
+	bool addHotTypes = (mIsHotObjectFile) && (mHotPrimaryTypes.size() == 0);
+
+	DbgSubprogram* prevDbgMethod = NULL;
+	DbgSubprogram* dbgMethod = compileUnit->mOrphanMethods.mHead;
+	while (dbgMethod != NULL)
+	{		
+		auto nextDbgMethod = dbgMethod->mNext;		
+		bool movedMethod = false;
+		if (dbgMethod->mHasQualifiedName)
+		{
+			char* name = (char*)dbgMethod->mName;
+			char* lastDblColon = (char*)GetLastDoubleColon(name);
+			
+			if (lastDblColon != NULL)
+			{
+				dbgMethod->mName = lastDblColon + 2;
+				dbgMethod->mHasQualifiedName = false;
+				const char* typeName = name;
+				*lastDblColon = 0;
+
+				DbgType* parentType = CvGetTypeOrNamespace(name);
+				if (parentType != NULL)
+				{
+					if (addHotTypes)
+					{
+						mHotPrimaryTypes.Add(parentType);
+					}
+					
+					compileUnit->mOrphanMethods.Remove(dbgMethod, prevDbgMethod);
+					parentType->mMethodList.PushBack(dbgMethod);
+					dbgMethod->mParentType = parentType;
+					movedMethod = true;
+				}
+			}
+		}
+
+		if (!movedMethod)
+			prevDbgMethod = dbgMethod;
+		dbgMethod = nextDbgMethod;
+	}
+}
+
+void COFF::MapCompileUnitMethods(int compileUnitId)
+{
+	CvModuleInfo* moduleInfo = mCvModuleInfo[compileUnitId];
+	if (moduleInfo->mHasMappedMethods)
+		return;
+	ParseCompileUnit(compileUnitId);
+
+	auto compileUnit = moduleInfo->mCompileUnit;
+	//for (auto dbgMethod : compileUnit->mGlobalType.mMethodList)
+
+	MapCompileUnitMethods(compileUnit);
+
+	moduleInfo->mHasMappedMethods = true;
+}
+
+void COFF::PopulateType(DbgType* dbgType)
+{
+	uint8* data = CvGetTagData(dbgType->mTagIdx, false);
+	CvAutoReleaseTempData releaseTempData(this, data);
+
+	uint8* dataStart = data;
+	uint16 trLeafType = GET(uint16);	
+
+	switch (trLeafType)
+	{
+	case LF_ENUM:
+		{
+			lfEnum& enumInfo = *(lfEnum*)dataStart;
+			CvParseMembers(dbgType, enumInfo.field, false);
+		}
+		break;
+	case LF_STRUCTURE:
+	case LF_CLASS:
+		{
+			lfClass& classInfo = *(lfClass*)dataStart;
+			CvParseMembers(dbgType, classInfo.field, false);
+		}
+		break;
+	case LF_UNION:
+		{
+			lfUnion& classInfo = *(lfUnion*)dataStart;	
+			CvParseMembers(dbgType, classInfo.field, false);
+		}
+		break;
+	default:
+		BF_FATAL("Invalid type");
+	}
+}
+
+void COFF::PopulateTypeGlobals(DbgType* dbgType)
+{	
+	//gDbgPerfManager->StartRecording();
+
+	{
+		BP_ZONE_F("COFF::PopulateTypeGlobals %s", (dbgType->mName != NULL) ? dbgType->mName : "?");
+
+		ParseTypeData();
+		dbgType->mNeedsGlobalsPopulated = false;
+		dbgType->mHasGlobalsPopulated = true;
+		mGlobalsTargetType = dbgType;
+		ParseSymbolStream(CvSymStreamType_Globals_Targeted);
+		mGlobalsTargetType = NULL;
+	}
+
+	//gDbgPerfManager->StopRecording(true);
+}
+
+void COFF::PopulateSubprogram(DbgSubprogram* dbgSubprogram)
+{
+	if (dbgSubprogram->mDeferredInternalsSize == 0)
+		return;
+
+	BP_ZONE("COFF::PopulateSubprogram");
+
+	auto compileUnit = (CvCompileUnit*)dbgSubprogram->mCompileUnit;
+	CvModuleInfo* moduleInfo = mCvModuleInfo[compileUnit->mModuleIdx];		
+	
+	int sectionSize = 0;
+	uint8* sectionData = CvReadStreamSegment(moduleInfo->mStream, dbgSubprogram->mTagIdx, dbgSubprogram->mDeferredInternalsSize);
+	CvInlineInfoVec inlineDataVec;
+	ParseCompileUnit_Symbols(compileUnit, NULL, sectionData, sectionData + dbgSubprogram->mDeferredInternalsSize, inlineDataVec, false, dbgSubprogram);
+	delete sectionData;	
+
+	dbgSubprogram->mDeferredInternalsSize = 0;
+}
+
+void COFF::FixupInlinee(DbgSubprogram* dbgSubprogram, uint32 ipiTag)
+{
+	if (!mCvIPIReader.IsSetup())
+		CvParseIPI();
+
+	//int idx = (ipiTag & 0x7FFFFFFF) - mCvIPIMinTag;
+	//uint8* dataStart = mCvIPIData + mCvIPITagStartMap[idx];
+
+	uint8* dataStart = CvGetTagData(ipiTag & 0x7FFFFFFF, true);
+	CvAutoReleaseTempData releaseTempData(this, dataStart);
+
+	lfEasy& funcLeaf = *(lfEasy*)dataStart;
+	switch (funcLeaf.leaf)
+	{
+	case LF_FUNC_ID:
+		{
+			lfFuncId* funcData = (lfFuncId*)dataStart;
+			CvParseMethod(NULL, NULL, funcData->type, false, dbgSubprogram);
+			dbgSubprogram->mName = (const char*)funcData->name;
+
+			bool doScope = true;
+
+			if ((funcData->scopeId != 0) && (doScope))
+			{
+				uint8* data = CvGetTagData(funcData->scopeId, true);
+				CvAutoReleaseTempData releaseTempData(this, data);
+
+				lfEasy& leaf = *(lfEasy*)data;
+				switch (leaf.leaf)
+				{
+				case LF_STRING_ID:
+					{
+						lfStringId& str = *(lfStringId*)data;
+						const char* parentStr = (const char*)str.name;
+
+						int allocLen = strlen(parentStr) + 2 + strlen(dbgSubprogram->mName) + 1;
+						BP_ALLOC("String", allocLen);
+						char* dupStr = (char*)mAlloc.AllocBytes(allocLen, "String");
+
+						strcpy(dupStr, parentStr);
+						strcat(dupStr, "::");
+						strcat(dupStr, dbgSubprogram->mName);
+						dbgSubprogram->mName = dupStr;
+					}
+					break;
+				case LF_UDT_MOD_SRC_LINE:
+					{
+						/*auto udtModSrcLine = *(lfUdtModSrcLine*)data;
+						auto parentType = CvGetType(udtModSrcLine.type);
+						curSubprogram->mParentType = parentType;*/
+					}
+					break;
+				}
+			}
+			break;
+		}
+	case LF_MFUNC_ID:
+		{
+			lfMFuncId* funcData = (lfMFuncId*)dataStart;
+			CvParseMethod(NULL, NULL, funcData->type, false, dbgSubprogram);
+			dbgSubprogram->mName = (const char*)funcData->name;
+
+			dbgSubprogram->mParentType = CvGetType(funcData->parentType);
+		}
+		break;
+	}
+}
+
+int COFF::MapImport(CvCompileUnit* compileUnit, int id)
+{
+	BF_ASSERT((id & 0x80000000) != 0);
+
+	int scopeIdx = (id & 0x7FFF0000) >> 20;
+	int itemId = (id & 0x0000FFFF);
+
+	if (mModuleNameSet.IsEmpty())
+	{
+		for (auto moduleInfo : mCvModuleInfo)
+		{
+			String name = moduleInfo->mModuleName;
+			name = ToUpper(name);
+			
+			CvModuleInfoNameEntry entry;
+			entry.mModuleInfo = moduleInfo;
+			mModuleNameSet.Add(entry);
+		}
+	}
+
+	if (scopeIdx < (int)compileUnit->mImports.size())
+	{
+		auto& importSection = compileUnit->mImports[scopeIdx];
+		if (itemId < (int)importSection.mImports.size())
+		{
+			auto importId = importSection.mImports[itemId];
+
+			if (importSection.mScopeCompileUnit == NULL)
+			{
+				CvModuleInfo* moduleInfo = NULL;
+				size_t nameHash = CvModuleInfoNameEntry::GetHashCode(importSection.mScopeName);
+
+				for (auto& nameEntry : mModuleNameSet.SelectHashes(nameHash))
+				{
+					String checkModuleName = nameEntry.mModuleInfo->mModuleName;
+					checkModuleName.Replace("\\", "/");
+					checkModuleName = ToUpper(checkModuleName);
+
+					String checkScopeName = importSection.mScopeName;
+					checkScopeName.Replace("\\", "/");
+					checkScopeName = ToUpper(checkScopeName);
+
+					bool matches = false;
+					if (checkModuleName == checkScopeName)
+						matches = true;
+					else if (checkScopeName.EndsWith("/" + checkModuleName))
+						matches = true;
+
+					if (matches)
+					{
+						ParseCompileUnit(nameEntry.mModuleInfo->mIdx);
+
+						auto externCompileUnit = nameEntry.mModuleInfo->mCompileUnit;
+						if (externCompileUnit->mExportMap.IsEmpty())
+						{
+							for (auto& exportEntry : externCompileUnit->mExports)
+								externCompileUnit->mExportMap[exportEntry.mLocalId] = exportEntry.mGlobalId;
+						}
+
+						if (externCompileUnit->mExportMap.ContainsKey(importId))
+						{
+							importSection.mScopeCompileUnit = nameEntry.mModuleInfo->mCompileUnit;
+							break;
+						}
+					}
+				}
+			}
+
+			if (importSection.mScopeCompileUnit != NULL)
+			{
+				uint32 exportId;
+				if (importSection.mScopeCompileUnit->mExportMap.TryGetValue(importId, &exportId))
+				{
+					if ((exportId & 0x80000000) != 0)
+					{
+						// Does this mean a recursive lookup?
+						return exportId & 0x7FFFFFFF;
+					}
+					else
+					{
+						return exportId;
+					}
+				}				
+			}
+		}
+	}
+
+	return 0;
+}
+
+void COFF::FixupInlinee(DbgSubprogram* dbgSubprogram)
+{
+	BF_ASSERT(dbgSubprogram->mInlineeInfo != NULL);
+	BF_ASSERT((dbgSubprogram->mInlineeInfo->mInlineeId & 0x80000000) != 0);
+	
+	int scopeIdx = (dbgSubprogram->mInlineeInfo->mInlineeId & 0x7FFF0000) >> 20;
+	int itemId = (dbgSubprogram->mInlineeInfo->mInlineeId & 0x0000FFFF);
+
+	if (mModuleNameMap.IsEmpty())
+	{
+		for (auto moduleInfo : mCvModuleInfo)
+		{
+			mModuleNameMap[CaseInsensitiveString(moduleInfo->mModuleName)] = moduleInfo;
+		}
+	}
+
+	auto compileUnit = (CvCompileUnit*)dbgSubprogram->mCompileUnit;
+
+	if (scopeIdx < (int)compileUnit->mImports.size())
+	{
+		auto& importSection = compileUnit->mImports[scopeIdx];
+		if (itemId < (int)importSection.mImports.size())
+		{
+			auto importId = importSection.mImports[itemId];
+
+			if (importSection.mScopeCompileUnit == NULL)
+			{
+				CvModuleInfo* moduleInfo = NULL;
+				mModuleNameMap.TryGetValue(CaseInsensitiveString(importSection.mScopeName), &moduleInfo);
+				if (moduleInfo != NULL)
+				{
+					ParseCompileUnit(moduleInfo->mIdx);
+					importSection.mScopeCompileUnit = moduleInfo->mCompileUnit;
+				}
+
+				if (importSection.mScopeCompileUnit != NULL)
+				{
+					for (auto& exportEntry : importSection.mScopeCompileUnit->mExports)
+					{
+						if (exportEntry.mLocalId == importId)
+						{
+							if (exportEntry.mGlobalId < mCvIPITagStartMap.size())
+							{
+								FixupInlinee(dbgSubprogram, exportEntry.mGlobalId);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	dbgSubprogram->mInlineeInfo->mInlineeId = 0;
+}
+
+void COFF::PopulateStaticVariableMap()
+{	
+	if (mPopulatedStaticVariables)
+		return;
+
+	BP_ZONE("COFF::PopulateStaticVariableMap");
+
+	if (mMasterCompileUnit != NULL)
+	{
+		PopulateTypeGlobals(mMasterCompileUnit->mGlobalType);
+		for (auto variable : mMasterCompileUnit->mGlobalType->mMemberList)
+		{		
+			if ((variable->mIsExtern) && (variable->mLinkName != NULL))
+				mStaticVariables.push_back(variable);
+		}
+	}
+
+	DbgModule::PopulateStaticVariableMap();
+}
+
+void COFF::ScanCompileUnit(int compileUnitId)
+{
+	BP_ZONE("COFF::ScanCompileUnit");
+
+	CvModuleInfo* moduleInfo = mCvModuleInfo[compileUnitId];
+	
+	if (moduleInfo->mStream < 0)
+		return;
+
+	BF_ASSERT(moduleInfo->mSymbolBytes % 4 == 0);
+	uint8* sectionData = CvReadStreamSegment(moduleInfo->mStream, moduleInfo->mSymbolBytes, moduleInfo->mLinesBytes);	
+	uint8* data = sectionData;
+	uint8* dataEnd = sectionData + moduleInfo->mLinesBytes;	
+
+	while (data < dataEnd)
+	{		
+		GET_INTO(int32, lineInfoType);
+		GET_INTO(int32, lineInfoLength);		
+		uint8* dataEnd = data + lineInfoLength;
+
+		if (lineInfoType == DEBUG_S_FILECHKSMS)
+		{			
+			while (data < dataEnd)
+			{				
+				GET_INTO(uint, fileTableOfs);
+
+				DbgSrcFile* srcFile;
+
+				DbgSrcFile** srcFilePtr = NULL;
+				if (!mCVSrcFileRefCache.TryAdd(fileTableOfs, NULL, &srcFilePtr))
+				{
+					srcFile = *srcFilePtr;
+				}
+				else
+				{
+					const char* fileName = mStringTable.mStrTable + fileTableOfs;
+					srcFile = AddSrcFile(NULL, fileName);
+					mSrcFileDeferredRefs.Add(srcFile);
+					*srcFilePtr = srcFile;
+					//mCVSrcFileRefCache[fileTableOfs] = srcFile;
+				}
+
+				DbgDeferredSrcFileReference dbgDeferredSrcFileReference;
+				dbgDeferredSrcFileReference.mDbgModule = this;
+				dbgDeferredSrcFileReference.mCompileUnitId = compileUnitId;
+				srcFile->mDeferredRefs.push_back(dbgDeferredSrcFileReference);
+				srcFile->mHadLineData = true;
+
+				GET_INTO(uint8, hashLen);
+				GET_INTO(uint8, hashType);
+				data += hashLen;
+
+				PTR_ALIGN(data, sectionData, 4);
+			}
+
+			
+			break; // Stop once we handle the file checksums
+		}
+		
+		data = dataEnd;
+	}
+
+	delete [] sectionData;
+}
+
+void COFF::FixTypes(int startingIdx)
+{
+	BP_ZONE("COFF::FixTypes");
+
+	//std::unordered_map<String, DbgType*> namespaceMap;
+
+	auto linkedModule = GetLinkedModule();
+
+	String wholeNamespace;
+	for (int typeIdx = startingIdx; typeIdx < (int)linkedModule->mTypes.size(); typeIdx++)
+	{
+		DbgType* dbgType = linkedModule->mTypes[typeIdx];
+		
+		DbgType* prevNamespaceType = NULL;
+		if (dbgType->mName == NULL)
+		{
+			// Internal typedef
+			continue;
+		}
+
+		if (dbgType->mLanguage == DbgLanguage_Unknown)
+		{
+			if (strncmp(dbgType->mName, "_bf::", 5) == 0)
+			{
+				dbgType->mLanguage = DbgLanguage_Beef;
+				dbgType->mName += 5;
+				dbgType->mTypeName += 5;
+			}
+			else if ((dbgType->mName[0] == 'G') && (dbgType->mName[1] == '$'))
+			{
+				dbgType->mLanguage = DbgLanguage_Beef;
+			}
+			else
+			{
+				dbgType->mLanguage = DbgLanguage_C;
+
+				// Check for a primitive array type like 'double[]'
+				for (int i = 0; i < 10; i++)
+				{
+					char c = dbgType->mName[i];
+					if (c == 0)
+						break;
+					if (c == '[')
+						dbgType->mLanguage = DbgLanguage_Beef;
+				}
+			}
+		}
+
+		if (dbgType->mIsDeclaration)
+			continue;
+
+		if (mIsHotObjectFile)
+		{
+			auto entry = linkedModule->mTypeMap.Find(dbgType->mName, dbgType->mLanguage);
+			if (entry != NULL)
+			{
+				// Just do hot replacing unless this type is new
+				continue;
+			}
+		}
+
+		// This never happens anymore - nested types are always handled as "internal typedefs"
+		//TODO: Check the 'isnested' flag on the leaf instead of counting on parent to be specified?		
+		bool hadParent = dbgType->mParent != NULL;
+
+		int chevronDepth = 0;
+
+		if ((dbgType->mTypeCode == DbgType_Class) || (dbgType->mTypeCode == DbgType_Struct) || (dbgType->mTypeCode == DbgType_Union) || 
+			(dbgType->mTypeCode == DbgType_Enum) || (dbgType->mTypeCode == DbgType_TypeDef))
+		{			
+			int startIdx = -1;
+			const char* name = dbgType->mTypeName;
+			
+			for (int i = 0; true; i++)
+			{
+				char c = name[i];
+				if (c == '<')
+					chevronDepth++;
+				else if (c == '>')
+					chevronDepth--;
+								
+				if ((chevronDepth == 0) && ((c == ':') || (c == '.')))
+				{
+					if ((!hadParent) && (i - startIdx > 1))
+					{						
+						//String wholeNamespace = String(name, name + i);
+						wholeNamespace.clear();
+						wholeNamespace.Insert(0, name, i);
+						
+						auto entry = linkedModule->mTypeMap.Find(wholeNamespace.c_str(), dbgType->mLanguage);
+						if (entry == NULL)
+						{
+							DbgType* namespaceType = CvCreateType();
+							namespaceType->mTypeCode = DbgType_Namespace;
+							namespaceType->mName = DbgDupString(wholeNamespace.c_str(), "DbgDupString.FixTypes");
+							namespaceType->mTypeName = namespaceType->mName + startIdx + 1;
+							namespaceType->mPriority = DbgTypePriority_Primary_Implicit;
+							namespaceType->mLanguage = dbgType->mLanguage;
+							linkedModule->mTypeMap.Insert(namespaceType);
+
+							if (prevNamespaceType != NULL)
+							{
+								namespaceType->mParent = prevNamespaceType;
+								prevNamespaceType->mSubTypeList.PushBack(namespaceType);
+							}
+
+							prevNamespaceType = namespaceType;
+						}
+						else
+						{
+							prevNamespaceType = entry->mValue;
+						}
+					}
+
+					startIdx = i;
+				}
+				else if ((c == 0) /*|| (c == '<')*/ || (c == '('))
+					break;
+			}				
+
+			if (prevNamespaceType != NULL)
+			{
+				dbgType->mParent = prevNamespaceType;
+				prevNamespaceType->mSubTypeList.PushBack(dbgType);
+			}
+			dbgType->mTypeName = dbgType->mTypeName + startIdx + 1; // Just take last part of name
+		}
+
+		if (dbgType->mParent == NULL)
+			dbgType->mCompileUnit->mGlobalType->mSubTypeList.PushBack(dbgType);
+	}
+}
+
+void COFF::CvReadStream(int streamIdx, CvStreamReader& streamReader)
+{
+	BF_ASSERT(streamReader.mCOFF == NULL);
+	streamReader.mCOFF = this;
+	streamReader.mPageBits = mCvPageBits;
+
+	int streamSize = mCvStreamSizes[streamIdx];
+	int streamPageCount = (streamSize + mCvPageSize - 1) / mCvPageSize;
+	streamReader.mStreamPtrs.Resize(streamPageCount);
+	streamReader.mSize = streamSize;
+
+	int streamPtrIdx = mCvStreamPtrStartIdxs[streamIdx];
+	for (int streamPageIdx = 0; streamPageIdx < streamPageCount; streamPageIdx++)
+	{
+		streamReader.mStreamPtrs[streamPageIdx] = (uint8*)mCvMappedViewOfFile + mCvStreamPtrs[streamPtrIdx] * mCvPageSize;
+		streamPtrIdx++;
+	}
+}
+
+void COFF::CvInitStreamRaw(CvStreamReader & streamReader, uint8 * data, int size)
+{
+	BF_ASSERT(streamReader.mCOFF == NULL);
+	streamReader.mCOFF = this;
+	streamReader.mPageBits = 31;
+	streamReader.mStreamPtrs.Add(data);
+	streamReader.mSize = size;
+}
+
+uint8* COFF::CvReadStream(int streamIdx, int* outSize)
+{
+	BP_ZONE("ReadCvSection");
+
+	if (streamIdx >= mCvStreamSizes.size())
+		return NULL;
+
+	int streamSize = mCvStreamSizes[streamIdx];
+	if (outSize != NULL)
+		*outSize = streamSize;
+	if (streamSize <= 0)
+		return NULL;
+	int streamPageCount = (streamSize + mCvPageSize - 1) / mCvPageSize;	
+
+	uint8* sectionData = new uint8[streamSize];
+	bool deferDeleteSectionData = false;
+
+	int streamPtrIdx = mCvStreamPtrStartIdxs[streamIdx];
+	for (int streamPageIdx = 0; streamPageIdx < streamPageCount; streamPageIdx++)
+	{
+		mCvDataStream->SetPos(mCvStreamPtrs[streamPtrIdx] * mCvPageSize);
+		mCvDataStream->Read(sectionData + streamPageIdx * mCvPageSize, std::min(streamSize - (streamPageIdx * mCvPageSize), mCvPageSize));
+		streamPtrIdx++;
+	}
+
+	return sectionData;
+}
+
+uint8* COFF::CvReadStreamSegment(int streamIdx, int offset, int size)
+{
+	BP_ZONE("ReadCvSection");
+
+	//int streamSize = mCvStreamSizes[streamIdx];
+	//int streamPageCount = (streamSize + mCvPageSize - 1) / mCvPageSize;
+	
+	uint8* sectionData = new uint8[size];
+	//delete [] sectionData;
+
+	bool deferDeleteSectionData = false;
+
+	uint8* data = sectionData;
+
+	int curOffset = offset;
+	int sizeLeft = size;
+
+	int streamPtrIdx = mCvStreamPtrStartIdxs[streamIdx];	
+	streamPtrIdx += offset / mCvPageSize;
+	curOffset = offset - (offset / mCvPageSize) * mCvPageSize;
+
+	//for (int streamPageIdx = 0; streamPageIdx < streamPageCount; streamPageIdx++)
+	while (sizeLeft > 0)
+	{
+		mCvDataStream->SetPos(mCvStreamPtrs[streamPtrIdx] * mCvPageSize + curOffset);
+		int readSize = std::min(mCvPageSize - curOffset, sizeLeft);
+		mCvDataStream->Read(data, readSize);
+		data += readSize;
+		sizeLeft -= readSize;
+		curOffset = 0;
+		streamPtrIdx++;
+	}
+
+	return sectionData;
+}
+
+void COFF::ReleaseTempBuf(uint8* buf)
+{	
+	if ((mTempBufIdx > 0) && (mTempBufs.mVals[mTempBufIdx - 1].mVals == buf))
+		mTempBufIdx--;	
+}
+
+bool COFF::CvParseHeader(uint8 wantGuid[16], int32 wantAge)
+{
+	int streamSize = 0;
+	uint8* data = CvReadStream(1, &streamSize);
+	mCvHeaderData = data;
+	
+	int32 pdbVersion = GET(int32);
+	int32 timestamp = GET(int32);
+	int32 pdbAge = GET(int32);	
+	for (int i = 0; i < 16; i++)
+		mPDBGuid[i] = GET(int8);
+	
+	if ((wantAge != -1) &&
+		(/*(pdbAge != wantAge) ||*/ (memcmp(mPDBGuid, wantGuid, 16) != 0)))
+	{
+		if (mDebugger != NULL)
+		{
+			String msg = "PDB GUID did not match requested version\n";
+
+			msg += StrFormat(" Module GUID: ");
+			for (int i = 0; i < 16; i++)
+				msg += StrFormat("%02X", (uint8)wantGuid[i]);
+			msg += "\n";
+
+			msg += StrFormat(" PDB GUID   : ");
+			for (int i = 0; i < 16; i++)
+				msg += StrFormat("%02X", (uint8)mPDBGuid[i]);			
+			Fail(msg);
+		}
+		return false;
+	}	
+
+	if (mParseKind == ParseKind_Header)
+		return true;
+
+	int nameTableIdx = -1;
+
+	GET_INTO(int32, strTabLen);
+	const char* strTab = (const char*)data;
+	data += strTabLen;
+
+	GET_INTO(int32, numStrItems);
+	GET_INTO(int32, strItemMax);
+
+	GET_INTO(int32, usedLen);
+	data += usedLen * sizeof(int32);
+	GET_INTO(int32, deletedLen);
+	data += deletedLen * sizeof(int32);
+
+	for (int tableIdx = 0; tableIdx < numStrItems; tableIdx++)
+	{
+		GET_INTO(int32, strOfs);
+		GET_INTO(int32, streamNum);
+
+		const char* tableName = strTab + strOfs;
+		if (strcmp(tableName, "/names") == 0)
+			mStringTable.mStream = streamNum;
+		if (strcmp(tableName, "srcsrv") == 0)
+			mCvSrcSrvStream = streamNum;
+
+		/*if (tableIdx == nameTableIdx)
+		{
+		nameStringTable.mStream = streamNum;
+		nameStringTable.mStreamOffset = strOfs;
+		}*/
+	}
+
+	return true;
+}
+
+bool COFF::CvParseDBI(int wantAge)
+{
+	BP_ZONE("CvParseDBI");
+		
+	uint8* data = CvReadStream(3);	
+	uint8* sectionData = data;
+	defer
+	{
+		delete sectionData;
+	};
+
+	// Header
+	GET_INTO(int32, signature);
+	GET_INTO(uint32, version);
+	GET_INTO(uint32, age);
+	mDebugAge = (int32)age;
+
+	if ((wantAge != -1) && (wantAge != age))
+	{
+		if (mDebugger != NULL)
+		{
+			String msg = "PDB age did not match requested age\n";
+			msg += StrFormat(" Module Age: %d  PDB Age: %d", wantAge, age);
+			Fail(msg);
+		}
+		return false;
+	}
+
+	if (mParseKind == ParseKind_Header)
+		return true;
+
+	mCvGlobalSymbolInfoStream = GET(int16); // hash1_file, snGSSyms
+	GET_INTO(uint16, pdb_dll_version);
+	mCvPublicSymbolInfoStream = GET(int16); // hash2_file, snPSSyms
+	GET_INTO(uint16, pdb_dll_build_major);
+	mCvSymbolRecordStream = GET(int16); // gsym_file, snSymRecs
+	GET_INTO(uint16, pdb_dll_build_minor);
+	GET_INTO(uint32, gp_modi_size); //module_size
+	GET_INTO(uint32, section_contribution_size); //offset_size
+	GET_INTO(uint32, section_map_size); //hash_size
+	GET_INTO(uint32, file_info_size); //srcmodule_size
+	GET_INTO(uint32, ts_map_size); //pdb_import_size
+	GET_INTO(uint32, mfc_index); //resvd0
+	GET_INTO(uint32, dbg_header_size); // stream_index_size
+	GET_INTO(uint32, ec_info_size); //unknown_size
+	GET_INTO(uint16, flags); //resvd3
+	GET_INTO(uint16, machine);
+	GET_INTO(uint32, reserved); //resvd4
+
+	uint8* headerEnd = data;
+
+	// Skip to debug header
+	data += gp_modi_size;
+	data += section_contribution_size;
+	data += section_map_size;
+	data += file_info_size;
+	data += ts_map_size;
+	data += ec_info_size;
+
+	// Debug header
+	GET_INTO(int16, fpo);
+	GET_INTO(int16, exception);
+	GET_INTO(int16, fixup);
+	GET_INTO(int16, omap_to_src);
+	GET_INTO(int16, omap_from_src);
+	GET_INTO(int16, section_header); // 0x0a, all others are -1 (segments)
+	GET_INTO(int16, token_rid_map);
+	GET_INTO(int16, x_data);
+	GET_INTO(int16, p_data);
+	mCvNewFPOStream = GET(int16);
+	GET_INTO(int16, section_header_origin);
+
+	if (section_header != -1)
+		ParseSectionHeader(section_header);
+
+	// Module info
+	data = headerEnd;
+	uint8* dataEnd = data + gp_modi_size;
+
+	while (data < dataEnd)
+	{
+		BP_ALLOC_T(CvModuleInfo);
+		CvModuleInfo* moduleInfo = mAlloc.Alloc<CvModuleInfo>();
+		memcpy(moduleInfo, data, sizeof(CvModuleInfoBase));
+		data += sizeof(CvModuleInfoBase);
+
+		moduleInfo->mModuleName = CvParseAndDupString(data);//DataGetString(data);
+		moduleInfo->mObjectName = CvParseAndDupString(data);//DataGetString(data);
+		moduleInfo->mIdx = (int)mCvModuleInfo.size();
+
+		//BfLogCv("Module %d: %s  Obj: %s\n", mCvModuleInfo.size(), moduleInfo->mModuleName, moduleInfo->mObjectName);
+
+		mCvModuleInfo.push_back(moduleInfo);
+
+		/*if (moduleInfo->mStream != -1)
+		{
+			if (moduleInfo->mStream >= mDeferredModuleInfo.size())
+				mDeferredModuleInfo.resize(moduleInfo->mStream + 1);
+			mDeferredModuleInfo[moduleInfo->mStream].push_back(moduleInfo);
+		}*/
+
+		PTR_ALIGN(data, sectionData, 4);
+	}
+
+	// Section contrib
+	{
+		BP_ZONE("CvParseDBI_Contrib");
+
+		dataEnd = data + section_contribution_size;
+		int32 sig = GET(int32);
+		BF_ASSERT((sig == 0xF12EBA2D) || (sig == 0xf13151e4));
+
+		bool isV2 = sig == 0xf13151e4;
+		if (isV2)
+		{
+			Fail("ERROR: FastLink PDBs are not supported. Consider adding full debug info (/DEBUG:FULL).");
+			mIsFastLink = true;
+		}
+
+		while (data < dataEnd)
+		{
+			CvSectionContrib& contrib = GET(CvSectionContrib);
+
+			if (isV2)
+			{
+				uint32_t isectCoff = GET(uint32_t);
+			}
+
+			for (int contribOffset = 0; true; contribOffset += DBG_MAX_LOOKBACK)
+			{
+				int curSize = contrib.mSize - contribOffset;
+				if (curSize <= 0)
+					break;
+
+				BP_ALLOC_T(DbgCompileUnitContrib);
+				auto contribEntry = mAlloc.Alloc<DbgCompileUnitContrib>();
+				contribEntry->mAddress = GetSectionAddr(contrib.mSection, contrib.mOffset) + contribOffset;
+				contribEntry->mLength = curSize;
+				contribEntry->mDbgModule = this;
+				contribEntry->mCompileUnitId = contrib.mModule;
+				mDebugTarget->mContribMap.Insert(contribEntry);
+			}			
+		}
+	}
+
+	// Dbi section map
+	dataEnd = data + section_map_size;
+	GET_INTO(int16, numSections);
+	GET_INTO(int16, numSectionsCopy);
+	while (data < dataEnd)
+	{
+		GET_INTO(uint8, flags);
+		GET_INTO(uint8, section_type);
+		// This field hasn't been deciphered but it is always 0x00000000 or 0xFFFFFFFF
+		// and modifying it doesn't seem to invalidate the Cv.
+		GET_INTO(int32, unknownData);
+		GET_INTO(uint16, section_number);
+		// Same thing as for unknown_data_1.
+		GET_INTO(int32, unknownData2);
+		// Value added to the address offset when calculating the RVA.
+		GET_INTO(uint32, rva_offset);
+		GET_INTO(uint32, section_length);		
+	}
+
+	// Dbi File info
+	dataEnd = data + file_info_size;
+	GET_INTO(uint16, fileInfoNumModules);
+	GET_INTO(uint16, bad_fileInfoNumSourceFiles);
+
+	int fileInfoNumSourceFiles = 0;
+
+	uint16* modIndices = (uint16*)data;	
+	data += fileInfoNumModules * sizeof(uint16);
+	uint16* modFileCounts = (uint16*)data;
+	data += fileInfoNumModules * sizeof(uint16);
+
+	for (int moduleIdx = 0; moduleIdx < fileInfoNumModules; moduleIdx++)	
+		fileInfoNumSourceFiles += modFileCounts[moduleIdx];
+
+	int32* fileNameOffsets = (int32*)data;
+	data += fileInfoNumSourceFiles * sizeof(int32);
+
+	char* nameBuffer = (char*)data;
+	char* namePtr = nameBuffer;
+
+	int curFileOfs = 0;
+	for (int moduleIdx = 0; moduleIdx < fileInfoNumModules; moduleIdx++)
+	{
+		//TODO: LLD-LINK does not emit this properly
+		//BF_ASSERT((modIndices[moduleIdx] == curFileOfs) || (moduleIdx >= 32));
+
+		for (int fileIdx = 0; fileIdx < modFileCounts[moduleIdx]; fileIdx++)
+		{
+			char* fileName = namePtr + *fileNameOffsets;			
+			curFileOfs++;
+			fileNameOffsets++;
+		}		
+		//int blockStart = fileBlockTable[i];
+		//int blockLength = fileBlockTable[fileInfoNumModules + i];
+
+		//int offset = offsetTable[blockStart]; through blockLength...		
+	}
+
+	// File name table
+	/*uint8* dataStart = data;
+	while (data < dataEnd)
+	{
+		int offset = (int)(data - dataStart);
+		const char* fileName = DataGetString(data);							
+		//DbgSrcFile* srcFile = AddSrcFile(mMasterCompileUnit, fileName);
+		//fileTable.insert(std::make_pair(offset, srcFile));
+	}*/
+	data = dataEnd;
+
+	BF_ASSERT(ts_map_size == 0);
+
+	// EC Info
+	dataEnd = data + ec_info_size;
+	GET_INTO(uint32, strTabSig);
+	GET_INTO(uint32, strTabVer);
+
+	BF_ASSERT(strTabSig == 0xEFFEEFFE);
+	GET_INTO(int32, strTabSize);
+
+	uint8* strTabData = data;
+	data += strTabSize;
+
+	GET_INTO(int32, strTabEntryCount);
+	for (int entryIdx = 0; entryIdx < strTabEntryCount; entryIdx++)
+	{
+		GET_INTO(int32, strOffset);
+		const char* str = (const char*)strTabData + strOffset;		
+	}		
+
+	return true;
+}
+
+void COFF::ParseSectionHeader(int sectionIdx)
+{
+	bool fakeRVAS = mSectionRVAs.empty();
+
+	int sectionSize = 0;
+	uint8* sectionData = CvReadStream(sectionIdx, &sectionSize);
+	uint8* data = sectionData;
+	
+	uint8* dataEnd = data + sectionSize;
+	while (data < dataEnd)
+	{
+		auto& sectionHeader = GET(PESectionHeader);
+		if (fakeRVAS)
+		{
+			mSectionRVAs.push_back(sectionHeader.mVirtualAddress);
+		}
+	}
+
+	if (fakeRVAS)
+		mSectionRVAs.push_back(0);
+
+	delete sectionData;
+}
+
+void COFF::CvParseIPI()
+{
+	BF_ASSERT(!mCvIPIReader.IsSetup());
+
+	//uint8* sectionData;
+	int sectionSize = 0;
+	int hashAdjOffset = 0;
+	int32 hashStream = -1;
+	int32 hashAdjSize = 0;
+	int32 dataOffset = 0;	
+	ParseTypeData(4, mCvIPIReader, sectionSize, dataOffset, hashStream, hashAdjOffset, hashAdjSize, mCvIPIMinTag, mCvIPIMaxTag);
+	//mCvIPIData = sectionData;
+	
+	int recordCount = mCvIPIMaxTag - mCvIPIMinTag;
+	mCvIPITagStartMap.Resize(recordCount);
+
+	//uint8* data = sectionData + dataOffset;
+	int offset = dataOffset;
+	for (int idx = 0; idx < recordCount; idx++)
+	{		
+		BF_ASSERT(((offset) & 3) == 0);
+		uint8* data = mCvIPIReader.GetTempPtr(offset, 4);		
+		uint16 trLength = GET(uint16);
+		int offsetStart = offset;
+		offset += 2;
+		data = mCvIPIReader.GetTempPtr(offset, trLength);
+		uint8* dataStart = data;		
+		uint16 trLeafType = GET(uint16);
+		//uint8* dataEnd = dataStart + trLength;
+		offset += trLength;
+
+		/*
+		*/
+
+		lfEasy& funcLeaf = *(lfEasy*)dataStart;
+		switch (funcLeaf.leaf)
+		{
+		case LF_FUNC_ID:
+			{
+				lfFuncId* funcData = (lfFuncId*)dataStart;				
+				//subprogram->mName = (const char*)funcData->name;
+
+				bool doScope = true;
+
+				/*if (strcmp(curSubprogram->mName, "DispatchToMethod") == 0)
+				{
+				doScope = true;						
+				}*/
+
+				if ((funcData->scopeId != 0) && (doScope))
+				{					
+					uint8* data = CvGetTagData(funcData->scopeId, true);
+					CvAutoReleaseTempData releaseTempData(this, data);
+
+					lfEasy& leaf = *(lfEasy*)data;
+					switch (leaf.leaf)
+					{
+					case LF_STRING_ID:
+						{
+							lfStringId& str = *(lfStringId*)data;
+							const char* parentStr = (const char*)str.name;
+
+						}
+						break;
+					case LF_UDT_MOD_SRC_LINE:
+						{
+							/*auto udtModSrcLine = *(lfUdtModSrcLine*)data;
+							auto parentType = CvGetType(udtModSrcLine.type);
+							curSubprogram->mParentType = parentType;*/
+						}
+						break;
+					}
+				}
+				break;
+			}
+		case LF_MFUNC_ID:
+			{
+				lfMFuncId* funcData = (lfMFuncId*)dataStart;
+				auto parentType = CvGetType(funcData->parentType);
+
+			}
+			break;
+		}			
+
+		mCvIPITagStartMap[idx] = offsetStart;
+	}
+}
+
+const char* COFF::CvParseSymbol(int offset, CvSymStreamType symStreamType, addr_target& outAddr)
+{
+	const char* retName = NULL;
+	
+	int offsetStart = offset;
+	uint8* data = mCvSymbolRecordReader.GetTempPtr(offset, 4);	
+	uint16 symLen = *(uint16*)data;
+	bool madeCopy = false;
+	data = mCvSymbolRecordReader.GetTempPtr(offset, symLen + 2, false, &madeCopy);
+	uint8* dataStart = data;	
+	uint16 symType = *(uint16*)(data + 2);
+
+	BF_ASSERT(symLen % 4 == 2);
+	BF_ASSERT((intptr)data % 4 == 0);
+
+	char* scanName = NULL;
+
+	switch (symType)
+	{
+	case S_UDT:
+		{
+			UDTSYM& udt = *(UDTSYM*)dataStart;
+			const char* name = (const char*)udt.name;
+
+#ifdef _DEBUG
+			ParseTypeData();
+			auto type = CvGetType(udt.typind);			
+#endif			
+			retName = name;
+		}
+		break;
+	case S_PUB32:
+		{
+			PUBSYM32& pubSym = *(PUBSYM32*)dataStart;
+			
+			if (symStreamType != CvSymStreamType_Symbols)
+				break;			
+
+			BP_ALLOC_T(DbgSymbol);
+			DbgSymbol* dbgSymbol = mAlloc.Alloc<DbgSymbol>();
+
+			const char* name = (const char*)mCvSymbolRecordReader.GetPermanentPtr(offsetStart + offsetof(PUBSYM32, name), symLen - offsetof(PUBSYM32, name) + 2); // pubSym.name;
+			//OutputDebugStrF("Sym: %s\n", name);			
+#ifdef BF_DBG_32
+			if ((name != NULL) && (name[0] == '_'))
+				name++;
+#endif
+
+			dbgSymbol->mName = name;
+			dbgSymbol->mAddress = GetSectionAddr(pubSym.seg, pubSym.off);
+			dbgSymbol->mDbgModule = this;
+			
+			if ((dbgSymbol->mAddress >= mImageBase) && (dbgSymbol->mAddress < mImageBase + mImageSize))
+			{
+				if ((dbgSymbol->mAddress & 0xFFFF'0000'0000'0000) == 0)
+					mDebugTarget->mSymbolMap.Insert(dbgSymbol);
+			}
+			else
+			{
+				NOP;
+			}
+			mSymbolNameMap.Insert(dbgSymbol);
+			outAddr = dbgSymbol->mAddress;
+
+			retName = name;
+		}
+		break;
+	case S_CONSTANT:
+		{
+			CONSTSYM& constSym = *(CONSTSYM*)dataStart;			
+		}
+		break;
+	case S_GDATA32:
+	case S_LDATA32:
+		{
+			uint8* permDataPtr = madeCopy ? mCvSymbolRecordReader.GetPermanentPtr(offsetStart, symLen + 2) : dataStart;
+			DATASYM32& dataSym = *(DATASYM32*)permDataPtr;
+
+			if (strcmp((const char*)dataSym.name, "_tls_index") == 0)
+			{
+				mTLSIndexAddr = GetSectionAddr(dataSym.seg, dataSym.off);
+			}
+						
+			char* name = (char*)dataSym.name;
+			retName = name;
+			
+			if (symStreamType == CvSymStreamType_Globals_Scan)
+			{
+				scanName = (char*)dataSym.name;
+				break;			
+			}
+			
+			bool wasBeef = false;
+			const char* memberName = CvCheckTargetMatch(name, wasBeef);
+			if (memberName == NULL)
+				break;
+			
+			DbgType* dbgType = CvGetType(dataSym.typind);
+
+			BP_ALLOC_T(DbgVariable);
+			DbgVariable* variable = mAlloc.Alloc<DbgVariable>();
+			variable->mType = dbgType;			
+			variable->mLocationData = permDataPtr;
+			variable->mLocationLen = 1;
+
+			variable->mIsStatic = true;
+			variable->mCompileUnit = mMasterCompileUnit;
+			variable->mName = memberName;			
+			variable->mLinkName = name;
+
+			if (strcmp((const char*)dataSym.name, "__ImageBase") == 0)
+				variable->mLinkName = NULL; // Avoid adding to map
+
+			variable->mIsExtern = symType == S_GDATA32;
+			variable->mCompileUnit = mGlobalsTargetType->mCompileUnit;			
+			// Push front so we will find before the original static declaration (that has no memory associated with it)
+			mGlobalsTargetType->mMemberList.PushFront(variable);			
+
+			if (mIsHotObjectFile)
+			{
+				if ((variable->mIsExtern) && (variable->mLinkName != NULL))
+					mStaticVariables.push_back(variable);
+			}
+		}
+		break;
+	case S_GTHREAD32:
+	case S_LTHREAD32:
+		{
+			uint8* permDataPtr = madeCopy ? mCvSymbolRecordReader.GetPermanentPtr(offsetStart, symLen + 2) : dataStart;
+			THREADSYM32& threadSym = *(THREADSYM32*)permDataPtr;
+						
+			if (symStreamType == CvSymStreamType_Globals_Scan)
+			{
+				scanName = (char*)threadSym.name;
+				break;
+			}
+
+			char* name = (char*)threadSym.name;
+			retName = name;
+			bool wasBeef = false;
+			const char* memberName = CvCheckTargetMatch(name, wasBeef);
+			if (memberName == NULL)
+				break;
+
+			addr_target addr = GetSectionAddr(threadSym.seg, threadSym.off);
+			DbgType* dbgType = CvGetType(threadSym.typind);
+
+			BP_ALLOC_T(DbgVariable);
+			DbgVariable* variable = mAlloc.Alloc<DbgVariable>();
+			variable->mType = dbgType;			
+			variable->mLocationData = permDataPtr;
+			variable->mLocationLen = 1;
+			variable->mIsStatic = true;
+			variable->mCompileUnit = mMasterCompileUnit;
+			variable->mName = memberName;
+			variable->mLinkName = name;
+			variable->mIsExtern = symType == S_GTHREAD32;
+			variable->mCompileUnit = mGlobalsTargetType->mCompileUnit;
+			// Push front so we will find before the original static declaration (that has no memory associated with it)
+			mGlobalsTargetType->mMemberList.PushFront(variable);
+		}
+		break;
+	case S_PROCREF:
+		{
+			REFSYM2& refSym = *(REFSYM2*)dataStart;
+			if (refSym.imod == 0)
+				break;
+
+			char* name = (char*)refSym.name;
+			retName = name;
+			
+			if (symStreamType == CvSymStreamType_Globals_Scan)
+			{
+				scanName = (char*)refSym.name;
+				break;
+			}			
+
+			int moduleId = refSym.imod - 1;									
+			
+			bool wasBeef = false;
+			const char* memberName = CvCheckTargetMatch(name, wasBeef);
+			if (memberName == NULL)									
+				break;
+			
+			bool isIllegal = false;
+			for (const char* cPtr = memberName; *cPtr != 0; cPtr++)
+			{
+				char c = *cPtr;
+				if ((c == '<') || (c == '`') || (c == '$'))
+					isIllegal = true;
+			}
+
+			if (!isIllegal)
+			{				
+				BP_ALLOC_T(DbgMethodNameEntry);
+				auto methodNameEntry = mAlloc.Alloc<DbgMethodNameEntry>();
+				methodNameEntry->mCompileUnitId = moduleId;
+				methodNameEntry->mName = madeCopy ? DbgDupString(memberName) : memberName;
+				mGlobalsTargetType->mMethodNameList.PushBack(methodNameEntry);
+			}			
+		}
+		break;
+	default:
+		//BF_FATAL("Unhandled");
+		break;
+	}
+
+	if (scanName != NULL)
+	{		
+		//TODO: Remove
+		//String origName = name;
+
+		//CvFixupName(name);
+		char* lastDblColon = (char*)GetNamespaceEnd(scanName);
+		if (lastDblColon != NULL)
+		{			
+			if (mPrevScanName != NULL)
+			{
+				int namespaceLen = lastDblColon - scanName;
+				if (strncmp(scanName, mPrevScanName, namespaceLen + 2) == 0) // +2 includes the ending '::'
+				{
+					// We've already inserted this namespace
+					return retName;		
+				}
+			}
+
+			StringT<256> tempName;
+			tempName = String(scanName, lastDblColon - scanName);
+			DbgType* dbgType = CvGetTypeOrNamespace((char*)tempName.c_str());
+
+// 			*lastDblColon = '\0';				
+// 			DbgType* dbgType = CvGetTypeOrNamespace(scanName);
+// 			*lastDblColon = ':';
+
+			/*if (strcmp(lastDblColon, "::this") == 0)
+			{
+				dbgType->mLanguage = DbgLanguage_Beef;
+			}*/
+			if (dbgType != NULL)
+				dbgType->mNeedsGlobalsPopulated = true;
+
+			mPrevScanName = scanName;
+
+			/*const char* methodName = NULL;
+
+			DbgType* dbgParent = NULL;
+			if (lastDblColon != NULL)
+			{
+			*lastDblColon = 0;
+			const char* namespaceName = name;
+			dbgParent = CvGetTypeOrNamespace(namespaceName);
+			methodName = lastDblColon + 2;
+			}
+			else
+			{
+			dbgParent = &mMasterCompileUnit->mGlobalType;
+			//mStaticVariables.push_back(variable);
+			methodName = name;
+			}
+
+			if (dbgParent != NULL)
+			{
+			auto methodNameEntry = mAlloc.Alloc<DbgMethodNameEntry>();
+			methodNameEntry->mCompileUnitId = moduleId;
+			methodNameEntry->mName = methodName;
+			dbgParent->mMethodNameList.PushBack(methodNameEntry);
+			}*/				
+		}
+		else
+		{
+			mMasterCompileUnit->mGlobalType->mNeedsGlobalsPopulated = true;
+		}
+	}	
+
+	return retName;
+}
+
+uint8* COFF::HandleSymStreamEntries(CvSymStreamType symStreamType, uint8* data, uint8* addrMap)
+{
+	uint32 tickStart = BFTickCount();
+
+	GET_INTO(uint32, verSig);
+	GET_INTO(uint32, verHdr);
+	GET_INTO(int32, sizeHr);
+	GET_INTO(int32, sizeBuckets);
+
+	BF_ASSERT(verSig == 0xffffffff);
+	BF_ASSERT(verHdr == 0xf12f091a);
+
+	uint8* dataEnd = data + sizeHr;
+	uint8* refDataHead = data;
+	int entryIdxMax = sizeHr / 8;
+	
+	data = dataEnd;
+
+	dataEnd = data + sizeBuckets ;
+
+	int32* hashBucketHead = (int32*)(data + 0x81 * 4);
+	int32* hashBucketPtr = hashBucketHead;
+
+	int numRecordsRead = 0;
+
+#ifdef _DEBUG
+	bool verify = false;
+#endif
+
+	if (mIsFastLink)
+		return dataEnd; // FOrmat changed
+
+	std::multimap<addr_target, int> checkAddrMap;
+	
+	int bitCount = 0;
+	for (int blockIdx = 0; blockIdx < 0x81; blockIdx++)
+	{
+		GET_INTO(uint32, bits);
+		for (int i = 0; i < 32; i++)
+		{
+			if ((bits & (1 << i)) != 0)
+			{
+				bitCount++;
+				int32 entryStart = *(hashBucketPtr++) / 12;
+				int32 entryEnd;
+				if ((uint8*)hashBucketPtr != (uint8*)dataEnd)
+					entryEnd = *(hashBucketPtr) / 12;
+				else
+					entryEnd = entryIdxMax;
+
+				BF_ASSERT(entryStart <= entryEnd);
+
+				for (int entryIdx = entryStart; entryIdx < entryEnd; entryIdx++)
+				{
+					int32 symDataPtr = *(int32*)(refDataHead + entryIdx * 8);
+					if (symDataPtr == 0)
+						continue;
+
+					addr_target addr = 0;
+					const char* symName = CvParseSymbol(symDataPtr - 1, symStreamType, addr);					
+#ifdef _DEBUG
+					if ((verify) && (addrMap != NULL))
+					{
+						checkAddrMap.insert(std::make_pair(addr, symDataPtr - 1));
+					}
+
+					if ((verify) && (symName != NULL))
+					{
+						int hashIdx = (blockIdx * 32) + i;
+						int wantHash = BlHash::HashStr_PdbV1(symName) % 4096;
+						BF_ASSERT(hashIdx == wantHash);
+					}
+#endif
+					numRecordsRead++;
+				}
+			}
+		}
+	}
+
+#ifdef _DEBUG
+	if ((verify) && (addrMap != NULL))
+	{
+		auto itr = checkAddrMap.begin();
+
+		data = addrMap;
+		for (int entryIdx = 0; entryIdx < numRecordsRead; entryIdx++)
+		{
+			int verifyIdx = GET(int32);			
+			int actualIdx = itr->second;
+			if (actualIdx != verifyIdx)
+			{
+				OutputDebugStrF("Mismatch #%X %X %X %08X\n", entryIdx, verifyIdx, actualIdx, itr->first);
+			}
+			++itr;
+		} 
+	} 
+#endif
+
+	BF_ASSERT(numRecordsRead == entryIdxMax);
+
+	OutputDebugStrF("HandleSymStreamEntries Ticks: %d\n", BFTickCount() - tickStart);
+
+	return dataEnd;
+}
+
+void COFF::ParseSymbolStream(CvSymStreamType symStreamType)
+{
+	if (mCvSymbolRecordStream == 0)	
+		return;	
+
+	BP_ZONE("COFF::ParseSymbolStream");
+
+	if (!mCvSymbolRecordReader.IsSetup())
+		CvReadStream(mCvSymbolRecordStream, mCvSymbolRecordReader);
+
+	if ((symStreamType == CvSymStreamType_Globals_Scan) || (symStreamType == CvSymStreamType_Globals_Targeted))
+	{
+		int streamSize = 0;
+		uint8* data;
+		if (mCvGlobalSymbolData == NULL)
+			mCvGlobalSymbolData = CvReadStream(mCvGlobalSymbolInfoStream, &streamSize);
+		data = mCvGlobalSymbolData;
+
+		HandleSymStreamEntries(symStreamType, data, NULL);
+	}
+	else
+	{
+		int streamSize = 0;
+		uint8* data;
+		if (mCvPublicSymbolData == NULL)
+			mCvPublicSymbolData = CvReadStream(mCvPublicSymbolInfoStream, &streamSize); // psgsi
+		data = mCvPublicSymbolData;		
+		uint8* sectionData = data;		
+
+		GET_INTO(int32, symHashSize);
+		GET_INTO(int32, addrMapSize);		
+		GET_INTO(int32, thunkCount);
+		GET_INTO(int32, thunkSize);
+		GET_INTO(int32, thunkTableStream);		
+		GET_INTO(int32, thunkTableOfs);
+		GET_INTO(int32, thunkSectCount);
+
+		data = HandleSymStreamEntries(symStreamType, data, data + symHashSize);
+
+		//TODO: Hm, not quite right?
+		/*int addrMapEntryCount = addrMapSize / 4;
+		for (int addrIdx = 0; addrIdx < addrMapEntryCount; addrIdx++)
+		{
+			GET_INTO(int32, addrVal);			
+		}
+
+		for (int thunkIdx = 0; thunkIdx < thunkCount; thunkIdx++)
+		{
+			GET_INTO(int32, thunkVal);			
+		}
+
+		for (int sectionIdx = 0; sectionIdx < thunkSectCount; sectionIdx++)
+		{
+			GET_INTO(int32, ofs);
+			GET_INTO(int32, sectNum);						
+		}*/
+	}	
+}
+
+void COFF::ParseGlobalsData()
+{
+	if (!mPDBLoaded)
+		return;
+	if (mParsedGlobalsData)
+		return;
+	mParsedGlobalsData = true;
+
+	//gDbgPerfManager->StartRecording();
+
+	int startTypeIdx = (int)mTypes.size();
+
+	ParseSymbolStream(CvSymStreamType_Globals_Scan);
+	
+	//gDbgPerfManager->StopRecording(true);
+
+	//int addedTypes = (int)mTypes.size() - startTypeIdx;
+	//OutputDebugStrF("Types Added: %d ProcSymCount: %d\n", addedTypes, mProcSymCount);
+}
+
+void COFF::ParseSymbolData()
+{
+	if (!mPDBLoaded)
+		return;
+	if (mParsedSymbolData)
+		return;
+	mParsedSymbolData = true;
+	ParseSymbolStream(CvSymStreamType_Symbols);
+}
+
+bool COFF::ParseCv(DataStream& pdbFS, uint8* rootDirData, int pageSize, uint8 wantGuid[16], int32 wantAge)
+{
+	BP_ZONE("ParseCv");
+
+	mParsedGlobalsData = false;
+	mParsedSymbolData = false;
+	mParsedTypeData = false;
+	mPopulatedStaticVariables = false;
+
+	InitCvTypes();
+
+	int startingTypeIdx = mTypes.size();	
+
+	uint8* data = rootDirData;
+
+	bool failed = false;
+	int numStreams = GET(int32);
+	if (numStreams == 0)	
+		return true;
+
+	mCvStreamSizes.Resize(numStreams);
+	mCvStreamPtrStartIdxs.Resize(numStreams);
+
+	int streamPages = 0;	
+	for (int i = 0; i < (int)mCvStreamSizes.size(); i++)
+		mCvStreamSizes[i] = GET(int32);
+	for (int streamIdx = 0; streamIdx < numStreams; streamIdx++)
+	{
+		mCvStreamPtrStartIdxs[streamIdx] = streamPages;
+		if (mCvStreamSizes[streamIdx] > 0)
+			streamPages += (mCvStreamSizes[streamIdx] + pageSize - 1) / pageSize;
+	}
+	mCvStreamPtrs.Resize(streamPages);
+	for (int i = 0; i < (int)mCvStreamPtrs.size(); i++)
+		mCvStreamPtrs[i] = GET(int32);	
+
+
+	//////////////////////////////////////////////////////////////////////////
+
+	if (!CvParseHeader(wantGuid, wantAge))
+		return false;
+		
+	if (!CvParseDBI(wantAge))
+		return false;
+
+	if (mParseKind == ParseKind_Header)
+		return true;
+
+	//ParseSymbolData();
+
+	//TODO: Remove
+	/*for (int streamIdx = 0; streamIdx < numStreams; streamIdx++)
+	{
+		int outSize;
+		uint8* data = CvReadStream(streamIdx, &outSize);
+		if (outSize > 0)
+		{
+			FILE* fp = fopen(StrFormat("c:/temp/test4/pdb_stream_%d.bin", streamIdx).c_str(), "wb");
+			fwrite(data, 1, outSize, fp);
+			fclose(fp);
+			delete [] data;
+		}
+	}*/
+		
+	{
+		BP_ZONE("COFF::ParseCv_ReadStrTable");
+		if (mStringTable.mStream != -1)
+		{
+			mCvStrTableData = CvReadStream(mStringTable.mStream);
+			mStringTable.mStrTable = (const char*)mCvStrTableData + 12;
+		}
+	}
+
+	for (int compileUnitId = 0; compileUnitId < (int)mCvModuleInfo.size(); compileUnitId++)
+	{
+		//ParseCompileUnit(compileUnitId);
+		ScanCompileUnit(compileUnitId);
+	}
+
+	/*for (int streamIdx = 0; streamIdx < (int)mDeferredModuleInfo.size(); streamIdx++)
+	{	
+		if (mDeferredModuleInfo[streamIdx].empty())
+			continue;
+
+		uint8* data = CvReadStream(streamIdx);
+		uint8* sectionData = data;
+
+		for (auto& moduleInfo : mDeferredModuleInfo[streamIdx])
+		{
+			CvParseModuleInfo(*moduleInfo, data, sectionData, mCvTypeSectionData, mStringTable);
+		}
+	}*/
+
+	//////////////////////////////////////////////////////////////////////////
+
+	
+	return true;
+}
+
+void COFF::ReportMemory(MemReporter* memReporter)
+{
+	DbgModule::ReportMemory(memReporter);
+	
+	memReporter->AddVec("mCvTypeMap", mCvTypeMap);
+	memReporter->AddVec("mCvTagStartMap", mCvTagStartMap);
+	memReporter->AddVec("mCvIPITagStartMap", mCvIPITagStartMap);
+	memReporter->AddVec(mCvStreamSizes);
+	memReporter->AddVec(mCvStreamPtrStartIdxs);
+	memReporter->AddVec(mCvStreamPtrs);
+	memReporter->AddVec(mCvModuleInfo);
+	memReporter->AddVec(mCVSrcFileRefCache);
+
+	if (mCvHeaderData != NULL)
+		memReporter->Add("mCvHeaderData", mCvStreamSizes[1]);	
+	for (auto& entry : mCvTypeSectionData)	
+	{
+		if (entry.mSize != -1)
+			memReporter->Add("mCvTypeSectionData", entry.mSize);
+		else
+			memReporter->Add("mCvTypeSectionData", mCvStreamSizes[2]);
+	}		
+	if (mCvStrTableData != NULL)
+		memReporter->Add("mCvStrTableData", mCvStreamSizes[mStringTable.mStream]);
+	if (mCvPublicSymbolData != NULL)
+		memReporter->Add("mCvPublicSymbolData", mCvStreamSizes[mCvPublicSymbolInfoStream]);
+	if (mCvGlobalSymbolData != NULL)
+		memReporter->Add("mCvGlobalSymbolData", mCvStreamSizes[mCvGlobalSymbolInfoStream]);
+
+	//memReporter->AddVec(mCvNamespaceStaticEntries);
+}
+
+bool COFF::TryLoadPDB(const String& pdbPath, uint8 wantGuid[16], int32 wantAge)
+{
+	bool isVerifyOnly = mDebugger == NULL;
+
+	if (!mPDBPath.IsEmpty())
+		return false; // Already have a PDB loaded
+
+	mCvMappedFile = CreateFileA(pdbPath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
+	if (mCvMappedFile == INVALID_HANDLE_VALUE)
+	{		
+		return false;
+	}
+
+	BP_ZONE("COFF::TryLoadPDB");
+
+	if (!isVerifyOnly)
+		mDebugger->OutputMessage(StrFormat("Loading PDB %s\n", pdbPath.c_str()));
+
+	DWORD highFileSize = 0;
+	int fileSize = (int)GetFileSize(mCvMappedFile, &highFileSize);
+	mCvMappedFileMapping = CreateFileMapping(mCvMappedFile, NULL, PAGE_READONLY, 0, fileSize, NULL);
+	mCvMappedViewOfFile = MapViewOfFile(mCvMappedFileMapping, FILE_MAP_READ, 0, 0, fileSize);
+	mCvMappedFileSize = fileSize;
+
+	//FileStream pdbFS;
+	//if (!pdbFS.Open(pdbPath, "rb"))
+		//return false;
+
+	mPDBPath = pdbPath;
+	mCvDataStream = new SafeMemStream(mCvMappedViewOfFile, fileSize, false);
+
+	//Cv_HEADER
+	//pdbFS.Read
+
+	char sig[32];
+	mCvDataStream->Read(sig, 32);
+	if (memcmp(sig, MSF_SIGNATURE_700, 32) != 0)
+	{
+		if (!isVerifyOnly)
+			Fail("PDB signature error");
+		return false;
+	}
+	
+	BfLogDbg("Loading PDB %s\n", pdbPath.c_str());
+
+	BP_ZONE_F("LoadCv %s", pdbPath.c_str());
+	
+	int pageSize = mCvDataStream->ReadInt32();
+	int fpmPageNum = mCvDataStream->ReadInt32();
+	int totalPageCount = mCvDataStream->ReadInt32();
+	int rootDirSize = mCvDataStream->ReadInt32();
+	int unknown = mCvDataStream->ReadInt32();
+	
+	int rootDirPtrs[NUM_ROOT_DIRS];
+	mCvDataStream->ReadT(rootDirPtrs);
+	
+	bool failed = false;
+	
+	mCvPageSize = pageSize;
+	for (int i = 0; i < 31; i++)
+	{
+		if (mCvPageSize < (1 << i))
+			break;
+		mCvPageBits = i;
+	}
+
+	int rootPageCount = (rootDirSize + pageSize - 1) / pageSize;
+	int rootPointersPages = (rootPageCount*sizeof(int32) + pageSize - 1) / pageSize;
+	int rootPageIdx = 0;
+
+	Array<uint8> rootDirData;
+	rootDirData.Resize(rootPageCount * pageSize);
+
+	for (int rootDirIdx = 0; rootDirIdx < rootPointersPages; rootDirIdx++)
+	{
+		int rootDirPtr = rootDirPtrs[rootDirIdx];
+		if (rootDirPtr == 0)
+			continue;
+		mCvDataStream->SetPos(rootDirPtr * pageSize);
+
+		int32 rootPages[1024];
+		mCvDataStream->Read(rootPages, pageSize);
+
+		for (int subRootPageIdx = 0; subRootPageIdx < pageSize / 4; subRootPageIdx++, rootPageIdx++)
+		{
+			if (rootPageIdx >= rootPageCount)
+				break;
+
+			int rootPagePtr = rootPages[subRootPageIdx];
+			if (rootPagePtr == 0)
+				break;
+			mCvDataStream->SetPos(rootPagePtr * pageSize);
+			mCvDataStream->Read(&rootDirData[rootPageIdx * pageSize], pageSize);
+		}
+	}
+
+	int startingTypeIdx = mTypes.size();	
+	if (!ParseCv(*mCvDataStream, &rootDirData[0], pageSize, wantGuid, wantAge))
+	{
+		//mDebugger->OutputMessage("Failed to parse PDB\n");
+		return false;	
+	}
+	
+	//FixTypes(startingTypeIdx);
+	//MapTypes(startingTypeIdx);
+
+	if (mCvDataStream->mFailed)
+		return false;
+		
+	//OutputDebugStrF("COFF::TryLoadPDB %s\n", pdbPath.c_str());
+	if (!isVerifyOnly)
+		mDebugger->ModuleChanged(this);
+
+	mPDBLoaded = true;
+
+	return true;
+}
+
+void COFF::ClosePDB()
+{
+	delete mCvDataStream;
+	mCvDataStream = NULL;
+	delete mCvHeaderData;
+	mCvHeaderData = NULL;		
+	delete mCvStrTableData;
+	mCvStrTableData = NULL;
+	for (auto& entry : mCvTypeSectionData)
+		delete entry.mData;
+	mCvTypeSectionData.Clear();
+	for (auto& entry : mCvCompileUnitData)
+		delete entry.mData;
+	mCvCompileUnitData.Clear();
+	delete mCvPublicSymbolData;
+	mCvPublicSymbolData = NULL;
+	delete mCvGlobalSymbolData;
+	mCvGlobalSymbolData = NULL;
+	delete mNewFPOData;
+	mNewFPOData = NULL;
+	if (mCvMappedViewOfFile != NULL)
+		::UnmapViewOfFile(mCvMappedViewOfFile);
+	mCvMappedViewOfFile = NULL;
+	if (mCvMappedFileMapping != INVALID_HANDLE_VALUE)
+		::CloseHandle(mCvMappedFileMapping);
+	mCvMappedFileMapping = NULL;
+	if (mCvMappedFile != INVALID_HANDLE_VALUE)
+		::CloseHandle(mCvMappedFile);
+	mCvMappedFile = NULL;
+
+	for (auto kv : mHotLibMap)
+		delete kv.mValue;
+	mHotLibMap.Clear();	
+	mHotLibSymMap.Clear();
+}
+
+bool COFF::LoadPDB(const String& pdbPath, uint8 wantGuid[16], int32 wantAge)
+{	
+	if (mDebugTarget->mTargetBinary == this)
+	{
+		// If we don't have to load the debug symbols from a remote source or the cache
+		//  then we assume we were locally built, meaning we don't attempt to auto-load
+		//  any symbols since we assume we already have what we built for all referenced
+		//  dlls
+		mDebugTarget->mWasLocallyBuilt = FileExists(pdbPath);
+	}
+
+	mDbgSymRequest = mDebugger->mDbgSymSrv.CreateRequest(mFilePath, pdbPath, wantGuid, wantAge);	
+	mDbgSymRequest->SearchLocal();
+
+	if (!mDbgSymRequest->mFinalPDBPath.IsEmpty())
+	{		
+		TryLoadPDB(mDbgSymRequest->mFinalPDBPath, wantGuid, wantAge);
+		mDebugger->mDbgSymSrv.ReleaseRequest(mDbgSymRequest);
+		mDbgSymRequest = NULL;
+	}
+	else
+		mMayBeOld = true;
+	
+	String fileName = GetFileName(mFilePath);
+	mWantsAutoLoadDebugInfo = !mDebugTarget->mWasLocallyBuilt;	
+
+	if ((fileName.Equals("KERNEL32.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+		(fileName.Equals("KERNELBASE.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+		(fileName.Equals("USER32.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+		(fileName.Equals("SHELL32.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+		(fileName.Equals("GDI32.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+		(fileName.Equals("GDI32FULL.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+		(fileName.Equals("NTDLL.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("COMDLG32.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("MSVCRT.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("COMBASE.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("UCRTBASE.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("RPCRT4.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("BCRYPTPRIMITIVES.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("SHCORE.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("WIN32U.DLL", String::CompareKind_OrdinalIgnoreCase)) ||
+        (fileName.Equals("MSWSOCK.DLL", String::CompareKind_OrdinalIgnoreCase)))
+	{
+		mWantsAutoLoadDebugInfo = false;
+	}
+
+	/*if (pdbPath.IndexOf('\\') != -1) // Do we have an absolute path at all?
+	{
+		if (TryLoadPDB(pdbPath, wantGuid, wantAge))
+			return true;
+		ClosePDB();
+	}*/
+
+	//char exePath[MAX_PATH];
+	//GetModuleFileNameA(NULL, exePath, sizeof(exePath));
+	
+	/*String checkPath = ::GetFileDir(mFilePath);
+	checkPath += "/";
+	checkPath += GetFileName(pdbPath);
+
+	if (!FileNameEquals(checkPath, pdbPath))
+	{
+		if (TryLoadPDB(checkPath, wantGuid, wantAge))
+			return true;
+	}*/
+
+	return false;
+}
+
+bool COFF::CheckSection(const char* name, uint8* sectionData, int sectionSize)
+{
+	if (strcmp(name, ".debug$T") == 0)
+	{
+		mDbgFlavor = DbgFlavor_MS;
+		DbgSectionData entry;
+		entry.mData = sectionData;
+		entry.mSize = sectionSize;
+		mCvTypeSectionData.Add(entry);		
+		return true;
+	}
+
+	if (strcmp(name, ".debug$S") == 0)
+	{		
+		DbgSectionData entry;
+		entry.mData = sectionData;
+		entry.mSize = sectionSize;
+		mCvCompileUnitData.Add(entry);
+		return true;
+	}
+
+	return false;
+}
+
+void COFF::ProcessDebugInfo()
+{
+	BP_ZONE("COFF::ProcessDebugInfo");
+
+	if ((!mCvTypeSectionData.IsEmpty()) && (!mCvCompileUnitData.IsEmpty()))
+	{		
+		auto linkedModule = (COFF*)GetLinkedModule();
+		int startingTypeIdx = (int)linkedModule->mTypes.size();
+
+		InitCvTypes();
+		
+		for (auto entry : mCvTypeSectionData)
+		{
+			uint8* data = entry.mData;
+			GET_INTO(uint32, infoType);
+			BF_ASSERT(infoType == CV_SIGNATURE_C13);
+
+			CvInitStreamRaw(mCvTypeSectionReader, entry.mData + 4, entry.mSize - 4);
+			//ParseTypeData(data, mCvTypeSectionDataSize - sizeof(uint32));
+			ParseTypeData(mCvTypeSectionReader, 0);
+		}
+
+		FixTypes(startingTypeIdx);
+		linkedModule->MapTypes(startingTypeIdx);
+
+		/*std::unordered_set<String, >
+		for (int typeIdx = startingTypeIdx; typeIdx < (int)mTypes.size(); typeIdx++)
+		{
+			DbgType* dbgType = linkedModule->mTypes[typeIdx];
+			if ((!dbgType->mIsDeclaration) && (dbgType->IsCompositeType()))
+			{
+
+			}
+		}*/
+
+		CvCompileUnit* compileUnit = NULL;
+		for (auto entry : mCvCompileUnitData)
+		{
+			compileUnit = ParseCompileUnit(NULL, compileUnit, entry.mData, entry.mSize);			
+		}
+		compileUnit->mLanguage = DbgLanguage_Beef;
+		mMasterCompileUnit->mLanguage = DbgLanguage_Beef;
+		MapCompileUnitMethods(compileUnit);
+		mEndTypeIdx = (int)linkedModule->mTypes.size();
+	}
+}
+
+void COFF::FinishHotSwap()
+{	
+	DbgModule::FinishHotSwap();
+	mTypeMap.Clear();	
+}
+
+addr_target COFF::EvaluateLocation(DbgSubprogram* dwSubprogram, const uint8* locData, int locDataLen, WdStackFrame* stackFrame, DbgAddrType* outAddrType, bool allowReg)
+{
+	if (mDbgFlavor == DbgFlavor_GNU)
+		return DbgModule::EvaluateLocation(dwSubprogram, locData, locDataLen, stackFrame, outAddrType, allowReg);
+
+	addr_target pc = 0;
+	if (stackFrame != NULL)
+	{
+		// Use 'GetSourcePC', which will offset the RSP when we're not at the top positon of the call stack, since RSP will be the 
+		//  return address in those cases
+		pc = stackFrame->GetSourcePC();
+	}
+	
+	int inlineDepth = 0;
+	uint8* data = (uint8*)locData;
+	for (int locIdx = 0; locIdx < locDataLen; locIdx++)
+	{
+		uint8* dataStart = data;
+		GET_INTO(uint16, symLen);
+		uint8* dataEnd = data + symLen;
+		GET_INTO(uint16, symType);
+		
+		CV_LVAR_ADDR_RANGE* rangeInfo = NULL;
+		CV_LVAR_ADDR_GAP* gapsInfo = NULL;
+		addr_target result = 0;
+
+		if (inlineDepth > 0)
+		{
+			if (symType == S_INLINESITE)
+				inlineDepth++;
+			else if (symType == S_INLINESITE_END)
+				inlineDepth--;
+			data = dataEnd;
+			continue;
+		}
+
+		bool handled = false;
+		switch (symType)
+		{
+		case S_GDATA32:
+		case S_LDATA32:
+			{
+				DATASYM32& dataSym = *(DATASYM32*)dataStart;				
+				*outAddrType = DbgAddrType_Target;
+				return GetSectionAddr(dataSym.seg, dataSym.off);
+			}
+			break;
+		case S_BPREL32:
+			{
+				BPRELSYM32* bpRel32 = (BPRELSYM32*)dataStart;
+#if BF_DBG_32
+				*outAddrType = DbgAddrType_Target;
+				return stackFrame->mRegisters.mIntRegs.ebp + (int)bpRel32->off;
+#else
+
+				*outAddrType = DbgAddrType_Target;
+				return stackFrame->mRegisters.mIntRegs.rbp + (int)bpRel32->off;
+#endif
+			}
+			break;
+		case S_LTHREAD32:
+		case S_GTHREAD32:
+			{
+				THREADSYM32& threadSym = *(THREADSYM32*)dataStart;
+				
+				int tlsIndex = mDebugger->ReadMemory<int>(mTLSIndexAddr);
+				addr_target tlsEntry = mDebugger->GetTLSOffset(tlsIndex);
+								
+				*outAddrType = DbgAddrType_Target;
+				return threadSym.off + tlsEntry;
+			}
+			break;
+		case S_REGISTER:
+			{
+				REGSYM* regSym = (REGSYM*)dataStart;
+				*outAddrType = DbgAddrType_Register;
+				int regNum = CvConvRegNum(regSym->reg);
+				return regNum;
+			}
+			break;
+		case S_REGREL32:
+			{
+				REGREL32* regRel32 = (REGREL32*)dataStart;
+				*outAddrType = DbgAddrType_Target;
+				int regNum = CvConvRegNum(regRel32->reg); 
+				return stackFrame->mRegisters.mIntRegsArray[regNum] + regRel32->off;
+			}
+			break;
+		case S_DEFRANGE_REGISTER:
+			{
+				DEFRANGESYMREGISTER& defRangeReg = *(DEFRANGESYMREGISTER*)dataStart;
+				*outAddrType = DbgAddrType_Register;
+				result = CvConvRegNum(defRangeReg.reg);
+				rangeInfo = &defRangeReg.range;
+				gapsInfo = &defRangeReg.gaps[0];
+			}
+			break;
+		case S_DEFRANGE_FRAMEPOINTER_REL:
+			{
+				DEFRANGESYMFRAMEPOINTERREL& defRangeFPRel = *(DEFRANGESYMFRAMEPOINTERREL*)dataStart;
+				
+				*outAddrType = DbgAddrType_Target;
+#ifdef BF_DBG_64				
+				if (dwSubprogram->mLocalBaseReg == DbgSubprogram::LocalBaseRegKind_RSP)
+					result = stackFrame->mRegisters.mIntRegsArray[X64Reg_RSP] + defRangeFPRel.offFramePointer;
+				else if (dwSubprogram->mLocalBaseReg == DbgSubprogram::LocalBaseRegKind_R13)
+					result = stackFrame->mRegisters.mIntRegsArray[X64Reg_R13] + defRangeFPRel.offFramePointer;
+				else
+					result = stackFrame->mRegisters.mIntRegsArray[X64Reg_RBP] + defRangeFPRel.offFramePointer;
+#else				
+				if (dwSubprogram->mLocalBaseReg == DbgSubprogram::LocalBaseRegKind_ESP)
+					//result = stackFrame->mRegisters.mIntRegsArray[X86Reg_ESP] + BF_ALIGN(dwSubprogram->mFrameBaseLen, 16) + defRangeFPRel.offFramePointer;
+					result = stackFrame->mRegisters.mIntRegsArray[X86Reg_ESP] + dwSubprogram->mFrameBaseLen + defRangeFPRel.offFramePointer;
+				else if (dwSubprogram->mLocalBaseReg == DbgSubprogram::LocalBaseRegKind_EBX)
+					result = stackFrame->mRegisters.mIntRegsArray[X86Reg_EBX] + defRangeFPRel.offFramePointer;
+				else
+					result = stackFrame->mRegisters.mIntRegsArray[X86Reg_EBP] + defRangeFPRel.offFramePointer;
+#endif									
+				
+				rangeInfo = &defRangeFPRel.range;
+				gapsInfo = &defRangeFPRel.gaps[0];
+			}
+			break;
+		case S_DEFRANGE_SUBFIELD_REGISTER:
+			{
+				DEFRANGESYMSUBFIELDREGISTER& defRangeSubfieldReg = *(DEFRANGESYMSUBFIELDREGISTER*)dataStart;				
+				
+				*outAddrType = DbgAddrType_Target;
+				int regNum = CvConvRegNum(defRangeSubfieldReg.reg); 
+				result = stackFrame->mRegisters.mIntRegsArray[regNum] + defRangeSubfieldReg.offParent;
+
+				rangeInfo = &defRangeSubfieldReg.range;
+				gapsInfo = &defRangeSubfieldReg.gaps[0];
+			}
+			break;
+		case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:
+			{
+				DEFRANGESYMFRAMEPOINTERREL_FULL_SCOPE& defFPRel = *(DEFRANGESYMFRAMEPOINTERREL_FULL_SCOPE*)dataStart;
+
+#ifdef BF_DBG_64
+				int regNum = X64Reg_RSP;
+#else
+				int regNum = X86Reg_ESP;
+#endif			
+				*outAddrType = DbgAddrType_Target;
+				result = stackFrame->mRegisters.mIntRegsArray[regNum] + defFPRel.offFramePointer;
+				return result;
+			}
+			break;
+		case S_DEFRANGE_REGISTER_REL:
+			{
+				DEFRANGESYMREGISTERREL& defRangeRegRel = *(DEFRANGESYMREGISTERREL*)dataStart;
+				*outAddrType = DbgAddrType_Target;
+				int regNum = CvConvRegNum(defRangeRegRel.baseReg);
+				result = stackFrame->mRegisters.mIntRegsArray[regNum] + defRangeRegRel.offBasePointer;
+				rangeInfo = &defRangeRegRel.range;
+				gapsInfo = &defRangeRegRel.gaps[0];
+			}
+			break;
+		case S_PROCREF:
+			{
+				// Not currently handled.
+			}
+			break;
+		case S_INLINESITE:
+			{
+				inlineDepth++;
+			}
+			break;		
+		default:
+			BF_FATAL("Not handled");
+		}
+
+		if (rangeInfo != NULL)
+		{			
+			auto rangeStart = GetSectionAddr(rangeInfo->isectStart, rangeInfo->offStart);			
+			
+			if ((pc >= rangeStart) && (pc < rangeStart + rangeInfo->cbRange))
+			{
+				bool inRange = true;
+				while ((uint8*)gapsInfo < (uint8*)dataEnd)
+				{
+					if ((pc >= rangeStart + gapsInfo->gapStartOffset) && (pc < rangeStart + gapsInfo->gapStartOffset + gapsInfo->cbRange))
+					{
+						inRange = false;
+						break;						
+					}
+					gapsInfo++;
+				}
+
+				if (inRange)
+					return result;
+			}
+		}
+
+		data = dataEnd;
+	}
+
+	if ((dwSubprogram != NULL) && (dwSubprogram->mIsOptimized))
+		*outAddrType = DbgAddrType_OptimizedOut;
+	else
+		*outAddrType = DbgAddrType_NoValue;
+	return 0;
+}
+
+bool COFF::CanGetOldSource()
+{
+	return mCvSrcSrvStream != -1;
+}
+
+String COFF::GetOldSourceCommand(const StringImpl& path)
+{
+	if (mCvSrcSrvStream == -1)
+		return "";
+	
+	int outSize;
+	uint8* data = CvReadStream(mCvSrcSrvStream, &outSize);
+	String cmdBlock = String((char*)data, outSize);
+	delete data;
+
+	bool inFileSection = false;
+	Dictionary<String, String> defs;
+
+	enum _SectType
+	{
+		_SectType_None,
+		_SectType_Ini,
+		_SectType_Variables,
+		_SectType_SourceFiles
+	};
+	_SectType sectType = _SectType_None;
+	
+	//
+	{
+		AutoCrit autoCrit(gDebugManager->mCritSect);
+		defs["TARG"] = gDebugManager->mSymSrvOptions.mSourceServerCacheDir;
+	}
+
+	std::function<void (String&)> _Expand = [&](String& str)
+	{
+		for (int i = 0; i < str.length(); i++)
+		{
+			if (str[i] == '%')
+			{
+				int endIdx = str.IndexOf('%', i + 1);
+				if (endIdx != -1)
+				{
+					String varName = ToUpper(str.Substring(i + 1, endIdx - i - 1));					
+					if (((endIdx < str.length() - 1) && (str[endIdx + 1] == '(')) &&
+						((varName == "FNVAR") || (varName == "FNBKSL") || (varName == "FNFILE")))
+					{
+						int closePos = str.IndexOf(')', endIdx + 2);
+						if (closePos != -1)
+						{
+							String paramStr = str.Substring(endIdx + 2, closePos - endIdx - 2);
+							_Expand(paramStr);
+
+							if (varName == "FNVAR")
+							{
+								paramStr = defs[paramStr];
+							}
+							else
+							{
+								if (varName == "FNBKSL")
+								{									
+									paramStr.Replace("/", "\\");
+								}
+								else if (varName == "FNFILE")
+								{
+									paramStr = GetFileName(paramStr);
+								}
+							}
+
+							str.Remove(i, closePos - i + 1);
+							str.Insert(i, paramStr);
+							i--;
+						}
+					}
+					else
+					{
+						auto replaceStr = defs[varName];
+						if (!replaceStr.IsEmpty())
+						{
+							str.Remove(i, endIdx - i + 1);
+							str.Insert(i, replaceStr);
+							i--;
+						}
+					}
+				}
+			}
+		}
+	};
+
+	int linePos = 0;
+	while (true)
+	{
+		int crPos = cmdBlock.IndexOf('\n', linePos);
+		if (crPos == -1)
+			break;
+		int lineEndPos = crPos;
+		if (cmdBlock[lineEndPos - 1] == '\r')
+			lineEndPos--;
+
+		String line = cmdBlock.Substring(linePos, lineEndPos - linePos);
+
+		if (line.StartsWith("SRCSRV: ini -"))
+		{
+			sectType = _SectType_Ini;
+		}
+		else if (line.StartsWith("SRCSRV: variables -"))
+		{
+			sectType = _SectType_Variables;
+		}
+		else if (line.StartsWith("SRCSRV: source files -"))
+		{
+			sectType = _SectType_SourceFiles;
+		}
+		else if (line.StartsWith("SRCSRV: end -"))
+		{
+			break;
+		}
+		else
+		{
+			switch (sectType)
+			{
+			case _SectType_Ini:
+			case _SectType_Variables:
+				{
+					int eqPos = line.IndexOf('=');
+					if (eqPos != -1)
+					{
+						defs[ToUpper(line.Substring(0, eqPos))] = line.Substring(eqPos + 1);
+					}
+					break;
+				}
+			case _SectType_SourceFiles:
+				{
+					int curStrIdx = 0;
+					int curStrPos = 0;
+
+					StringT<256> var;
+
+					bool matches = false;
+					while (curStrPos < (int)line.length())
+					{
+						int starPos = line.IndexOf('*', curStrPos);
+						if (starPos == -1)
+							starPos = line.length();
+						
+						//var = line.Substring(curStrPos, starPos - curStrPos);
+						var.Clear();
+						var.Insert(0, line.c_str() + curStrPos, starPos - curStrPos);
+
+						if (curStrIdx == 0)
+						{
+							matches = FileNameEquals(var, path);
+							if (!matches)
+								break;
+						}
+						
+						defs[StrFormat("VAR%d", curStrIdx + 1)] = var;
+
+						curStrIdx++;
+						curStrPos = starPos + 1;
+					}
+
+					if (!matches)
+						break;
+
+					String target = defs["SRCSRVTRG"];
+					String cmd = defs["SRCSRVCMD"];
+					String env = defs["SRCSRVENV"];
+
+					_Expand(target);
+					_Expand(cmd);
+					_Expand(env);
+					
+					String retVal;
+					if ((cmd.IsEmpty()) && (target.StartsWith("HTTP", StringImpl::CompareKind_OrdinalIgnoreCase)))
+					{
+						String localFile;
+
+						BfpFileResult result;
+						BFP_GETSTR_HELPER(localFile, result, BfpFile_GetTempPath(__STR, __STRLEN, &result));
+						int dotPos = target.IndexOf("://");
+						if (dotPos != -1)
+						{
+							localFile.Append("SymbolCache\\src\\");
+							localFile.Append(StringView(target, dotPos + 3));
+							localFile.Replace("/", "\\");
+						}						
+
+						retVal = localFile;
+						retVal += "\n";
+						retVal += target;
+						retVal += "\n";
+						retVal += env;
+					}
+					else if (!cmd.IsWhitespace())
+					{
+						retVal = target;
+						retVal += "\n";
+						retVal += cmd;
+						retVal += "\n";
+						retVal += env;
+					}
+					
+					return retVal;
+				}
+				break;
+			}			
+		}
+
+		linePos = crPos + 1;
+	}
+
+	return "";
+}
+
+bool COFF::HasPendingDebugInfo()
+{
+	if (mDbgSymRequest == NULL)
+		return false;
+
+	return true;
+}
+
+void COFF::PreCacheImage()
+{
+	if (!mDebugger->IsMiniDumpDebugger())
+		return;
+
+	if (mLoadState != DbgModuleLoadState_NotLoaded)
+		return;
+
+	auto miniDumpDebugger = (MiniDumpDebugger*)mDebugger;
+
+	if (mOrigImageData != NULL)
+		return;
+
+	mDebugger->mDbgSymSrv.PreCacheImage(mFilePath, mTimeStamp, mImageSize);
+}
+
+void COFF::PreCacheDebugInfo()
+{
+	if (mDbgSymRequest == NULL)
+		return;
+
+	if (mDbgSymRequest->mInProcess)
+		return;
+
+	bool hasDebugInfo = false;
+	mDbgSymRequest->SearchCache();
+	if (mDbgSymRequest->mFinalPDBPath.IsEmpty())
+	{
+		if (GetCurrentThreadId() == mDebugger->mDebuggerThreadId)
+		{
+			mDbgSymRequest->mIsPreCache = true;
+			mDbgSymRequest->SearchSymSrv();
+			mDbgSymRequest->mIsPreCache = false;
+			mDbgSymRequest->mFailed = false;
+		}
+	}
+}
+
+bool COFF::RequestImage()
+{
+	if (!mDebugger->IsMiniDumpDebugger())
+		return false;
+
+	if (mLoadState != DbgModuleLoadState_NotLoaded)
+		return false;
+
+	auto miniDumpDebugger = (MiniDumpDebugger*)mDebugger;
+	
+	if (mOrigImageData != NULL)
+		return false;
+
+	if (GetCurrentThreadId() == mDebugger->mDebuggerThreadId)
+	{		
+		auto prevRunState = mDebugger->mRunState;
+		mDebugger->mRunState = RunState_SearchingSymSrv;
+		mDebugger->mDebugManager->mOutMessages.push_back(StrFormat("symsrv Searching for image '%s'", mFilePath.c_str()));
+		
+		auto dbgSymRequest = mDebugger->mDbgSymSrv.CreateRequest();
+		mDebugger->mActiveSymSrvRequest = dbgSymRequest;
+		BF_ASSERT(mDebugger->mDebugManager->mCritSect.mLockCount == 1);
+		mDebugger->mDebugManager->mCritSect.Unlock();		
+		// We unlock to allow the IDE to continue updating while we search
+		String imagePath = dbgSymRequest->SearchForImage(mFilePath, mTimeStamp, mImageSize);
+		mDebugger->mDebugManager->mCritSect.Lock();
+		delete mDebugger->mActiveSymSrvRequest;
+		mDebugger->mActiveSymSrvRequest = NULL;
+
+		mDebugger->mRunState = prevRunState;
+		
+		if (!imagePath.IsEmpty())
+		{
+			MappedFile* mappedFile = miniDumpDebugger->MapModule(this, imagePath);
+			mMappedImageFile = mappedFile;
+
+			if (mappedFile != NULL)
+			{
+				MemStream memStream(mappedFile->mData, mappedFile->mFileSize, false);
+				ReadCOFF(&memStream, false);
+
+				mOrigImageData = new DbgModuleMemoryCache(mImageBase, mImageSize);
+			}
+		}				
+		
+		if (mOrigImageData == NULL) // Failed?
+		{
+			mLoadState = DbgModuleLoadState_NotLoaded;			
+			return false;
+		}
+
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+
+	return false;
+}
+
+bool COFF::RequestDebugInfo(bool allowRemote)
+{
+	if (mDbgSymRequest == NULL)
+		return false;
+
+	if (mDbgSymRequest->mInProcess)
+		return false;
+		
+	bool hasDebugInfo = false;
+	mDbgSymRequest->SearchCache();
+	if (mDbgSymRequest->mFinalPDBPath.IsEmpty())
+	{	
+		if (!allowRemote)
+			return false;
+
+		if (GetCurrentThreadId() == mDebugger->mDebuggerThreadId)
+		{ 
+			auto prevRunState = mDebugger->mRunState;
+			mDebugger->mRunState = RunState_SearchingSymSrv;
+			
+			mDbgSymRequest->mInProcess = true;
+			mDebugger->mActiveSymSrvRequest = mDbgSymRequest;
+			BF_ASSERT(mDebugger->mDebugManager->mCritSect.mLockCount == 1);
+			mDebugger->mDebugManager->mCritSect.Unlock();			
+			mDbgSymRequest->SearchSymSrv();
+			mDebugger->mDebugManager->mCritSect.Lock();
+			mDebugger->mActiveSymSrvRequest = NULL;
+			mDbgSymRequest->mInProcess = false;
+			
+			mDebugger->mRunState = prevRunState;
+		}
+		else
+		{
+			return false;
+		}
+	}
+	if (!mDbgSymRequest->mFinalPDBPath.IsEmpty())
+		hasDebugInfo = TryLoadPDB(mDbgSymRequest->mFinalPDBPath, mDbgSymRequest->mWantGuid, mDbgSymRequest->mWantAge);
+	mDebugger->mDbgSymSrv.ReleaseRequest(mDbgSymRequest);
+	mDbgSymRequest = NULL;
+	return hasDebugInfo;
+}
+
+bool COFF::WantsAutoLoadDebugInfo()
+{
+	return mWantsAutoLoadDebugInfo;
+}
+
+bool COFF::DbgIsStrMutable(const char* str)
+{
+	if (mIsHotObjectFile)
+	{
+		return GetLinkedModule()->DbgIsStrMutable(str);
+	}
+
+	if (mCvMappedViewOfFile == NULL)
+		return true;
+
+	if ((str >= (const char*)mCvMappedViewOfFile) && (str < (const char*)mCvMappedViewOfFile + mCvMappedFileSize))
+		return false;
+	return true;
+}
+
+// We don't need this for Beef linkining because of "FORCELINK_", but we DO need it for
+//  libraries we linked to, either in the DLL or in the LIB
+addr_target COFF::LocateSymbol(const StringImpl& name)
+{
+	BP_ZONE("COFF::LocateSymbol");
+
+	BfLogDbg("COFF:LocateSymbol '%s'\n", name.c_str());
+
+	if (mHotLibMap.IsEmpty())
+	{
+		for (auto moduleInfo : mCvModuleInfo)
+		{
+			if (moduleInfo->mObjectName == NULL)
+				continue;
+			String libName = moduleInfo->mObjectName;
+			if (!libName.EndsWith(".lib", StringImpl::CompareKind_OrdinalIgnoreCase))
+				continue;
+			
+			CvLibInfo** libInfoPtr;
+			if (!mHotLibMap.TryAdd(libName, NULL, &libInfoPtr))
+				continue;
+
+			CvLibInfo* libInfo = new CvLibInfo();
+			*libInfoPtr = libInfo;
+
+			if (!libInfo->mLibFile.Init(libName, false))			
+				continue;
+
+			for (auto kv : libInfo->mLibFile.mOldEntries)
+			{
+				auto libEntry = kv.mValue;
+				while (libEntry != NULL)
+				{
+					for (auto sym : libEntry->mSymbols)
+					{
+#ifdef BF_DBG_32
+						if (sym.StartsWith('_'))
+							mHotLibSymMap[sym.Substring(1)] = libEntry;
+						else
+							// Fallthrough
+#endif
+						mHotLibSymMap[sym] = libEntry;
+					}
+					libEntry = libEntry->mNextWithSameName;
+				}
+			}
+		}
+	}
+
+	BeLibEntry* libEntry;
+	if (!mHotLibSymMap.TryGetValue(name, &libEntry))
+		return 0;
+
+	if (libEntry->mLength == -1)
+	{
+		BfLogDbg("Already loaded obj '%s' in '%s'\n", libEntry->mName.c_str(), libEntry->mLibFile->mFilePath.c_str());
+
+		// We already tried to load this
+		return 0;
+	}
+	
+	auto fileExt = GetFileExtension(libEntry->mName);
+	if (String::Equals(fileExt, ".dll", StringImpl::CompareKind_OrdinalIgnoreCase))
+	{
+		for (auto dbgModule : mDebugTarget->mDbgModules)
+		{
+			if (String::Equals(libEntry->mName, dbgModule->mDisplayName))
+			{				
+				dbgModule->ParseSymbolData();
+				auto entry = dbgModule->mSymbolNameMap.Find(name.c_str());
+				if (entry == NULL)
+					continue;
+
+				addr_target callTarget;
+
+#ifdef BF_DBG_32
+				callTarget = entry->mValue->mAddress;
+#else
+
+				BfLogDbg("Setting up DLL thunk for '%s' in '%s'\n", name.c_str(), dbgModule->mFilePath.c_str());
+
+				int wantHotSize = 16;
+				if (mHotThunkDataLeft < wantHotSize)
+				{
+					int allocSize = 4096;
+					mDebugger->ReserveHotTargetMemory(allocSize);
+					int outAllocSize = 0;
+					mHotThunkCurAddr = mDebugger->AllocHotTargetMemory(allocSize, true, false, &outAllocSize);
+					mHotThunkDataLeft = outAllocSize;
+				}
+
+				int outAllocSize = 0;
+				addr_target hotAddr = mHotThunkCurAddr;
+				mHotThunkCurAddr += wantHotSize;
+				mHotThunkDataLeft -= wantHotSize;
+
+#pragma pack(push, 1)
+				struct HotLongJmpOp
+				{
+					uint8 mOpCode0;
+					uint8 mOpCode1;
+					int32 mRIPRel;					
+					uint64 mTarget;
+				};
+#pragma pack(pop)
+
+				HotLongJmpOp jumpOp;
+				jumpOp.mOpCode0 = 0xFF;
+				jumpOp.mOpCode1 = 0x25;
+				jumpOp.mRIPRel = 0;
+				jumpOp.mTarget = entry->mValue->mAddress;
+				mDebugger->WriteMemory(hotAddr, jumpOp);
+
+				callTarget = hotAddr;
+#endif
+				char* dupStr = (char*)mAlloc.AllocBytes(name.length() + 1);
+				memcpy(dupStr, name.c_str(), name.length());
+
+				DbgSymbol* dwSymbol = mAlloc.Alloc<DbgSymbol>();
+				dwSymbol->mDbgModule = this;
+				dwSymbol->mName = dupStr;
+				dwSymbol->mAddress = callTarget;
+				mSymbolNameMap.Insert(dwSymbol);
+				return callTarget;
+			}
+		}
+
+		return 0;
+	}
+	BfLogDbg("Loading obj '%s' in '%s'\n", libEntry->mName.c_str(), libEntry->mLibFile->mFilePath.c_str());
+
+// #ifdef _DEBUG
+// 	FILE* fpTest = fopen("c:\\temp\\locateSym.obj", "wb");
+// 
+// 	uint8* data = new uint8[libEntry->mLength];
+// 
+// 	fseek(libEntry->mLibFile->mOldFileStream.mFP, libEntry->mOldDataPos + sizeof(BeLibMemberHeader), SEEK_SET);
+// 	fread(data, 1, libEntry->mLength, libEntry->mLibFile->mOldFileStream.mFP);
+// 	fwrite(data, 1, libEntry->mLength, fpTest);
+// 	fclose(fpTest);
+// 	delete data;
+// #endif
+
+
+	FileSubStream fileStream;
+	fileStream.mFP = libEntry->mLibFile->mOldFileStream.mFP;
+	fileStream.mOffset = libEntry->mOldDataPos + sizeof(BeLibMemberHeader);
+	fileStream.mSize = libEntry->mLength;
+	fileStream.SetPos(0);
+
+	DbgModule* dbgModule = new COFF(mDebugger->mDebugTarget);
+	dbgModule->mHotIdx = mDebugger->mActiveHotIdx;
+	dbgModule->mFilePath = libEntry->mName + "@" + libEntry->mLibFile->mFilePath;
+	bool success = dbgModule->ReadCOFF(&fileStream, true);
+	fileStream.mFP = NULL;
+
+	// Mark as loaded
+	libEntry->mLength = -1;
+
+	if (!success)
+	{
+		BfLogDbg("Failed\n");
+
+		Fail(StrFormat("Debugger failed to read binary '%s' in '%s'", libEntry->mName.c_str(), libEntry->mLibFile->mFilePath.c_str()));
+		delete dbgModule;
+		return 0;
+	}	
+	mDebugger->mDebugTarget->mDbgModules.push_back(dbgModule);
+
+	auto symbolEntry = mSymbolNameMap.Find(name.c_str());
+	if (symbolEntry != NULL)
+		return symbolEntry->mValue->mAddress;
+
+	return 0;
+}
+
+void COFF::ParseFrameDescriptors(uint8* data, int size, addr_target baseAddr)
+{
+	uint8* ptr = data;
+	uint8* endPtr = data + size;
+
+	Dictionary<int, COFFFrameProgram> programMap;
+	Array<COFFFrameProgram::Command> cmds;
+
+	while (ptr < endPtr)
+	{
+		COFFFrameDescriptor* frame = (COFFFrameDescriptor*)ptr;
+		ptr += sizeof(COFFFrameDescriptor);
+
+		COFFFrameDescriptorEntry entry;
+		entry.mFrameDescriptor = frame;
+
+		bool failed = false;
+
+		COFFFrameProgram* programPtr = NULL;
+		if (programMap.TryAdd(frame->mFrameFunc, NULL, &programPtr))
+		{
+			COFFFrameProgram program;
+
+			cmds.Clear();
+			String curCmd;
+			const char* ptr = mStringTable.mStrTable + frame->mFrameFunc;
+			while (true)
+			{
+				char c = *(ptr++);
+				if ((c == ' ') || (c == 0))
+				{
+					if (curCmd == "$eip")
+						cmds.Add(COFFFrameProgram::Command_EIP);
+					else if ((curCmd == "$esp") || (curCmd == "$21"))
+						cmds.Add(COFFFrameProgram::Command_ESP);
+					else if ((curCmd == "$ebp") || (curCmd == "$22"))
+						cmds.Add(COFFFrameProgram::Command_EBP);
+					else if ((curCmd == "$eax") || (curCmd == "$17"))
+						cmds.Add(COFFFrameProgram::Command_EAX);
+					else if ((curCmd == "$ebx") || (curCmd == "$20"))
+						cmds.Add(COFFFrameProgram::Command_EBX);
+					else if ((curCmd == "$ecx") || (curCmd == "$18"))
+						cmds.Add(COFFFrameProgram::Command_ECX);
+					else if ((curCmd == "$edx") || (curCmd == "$19"))
+						cmds.Add(COFFFrameProgram::Command_EDX);
+					else if ((curCmd == "$esi") || (curCmd == "$23"))
+						cmds.Add(COFFFrameProgram::Command_ESI);
+					else if ((curCmd == "$edi") || (curCmd == "$24"))
+						cmds.Add(COFFFrameProgram::Command_EDI);
+					else if (curCmd == "$T0")
+						cmds.Add(COFFFrameProgram::Command_T0);
+					else if (curCmd == "$T1")
+						cmds.Add(COFFFrameProgram::Command_T1);
+					else if (curCmd == "$T2")
+						cmds.Add(COFFFrameProgram::Command_T2);
+					else if (curCmd == "$T3")
+						cmds.Add(COFFFrameProgram::Command_T3);
+					else if ((curCmd == ".raSearch") || (curCmd == ".raSearchStart"))
+						cmds.Add(COFFFrameProgram::Command_RASearch);
+					else if (curCmd == "+")
+						cmds.Add(COFFFrameProgram::Command_Add);
+					else if (curCmd == "-")
+						cmds.Add(COFFFrameProgram::Command_Subtract);
+					else if (curCmd == "@")
+						cmds.Add(COFFFrameProgram::Command_Align);
+					else if (curCmd == "=")
+						cmds.Add(COFFFrameProgram::Command_Set);
+					else if (curCmd == "^")
+						cmds.Add(COFFFrameProgram::Command_Deref);
+					else if (!curCmd.IsEmpty())
+					{
+						if ((curCmd[0] >= '0') && (curCmd[0] <= '9'))
+						{
+							int val = atoi(curCmd.c_str());
+							if ((val >= 0) && (val <= 255))
+							{
+								cmds.Add(COFFFrameProgram::Command_Value8);
+								cmds.Add((COFFFrameProgram::Command)val);
+							}
+							else
+							{
+								cmds.Add(COFFFrameProgram::Command_Value);
+								cmds.Insert(cmds.size(), (COFFFrameProgram::Command*)&val, 4);
+							}
+						}
+						else
+						{
+							failed = true;
+							Fail(StrFormat("Invalid COFF frame program: %s", curCmd.c_str()));
+						}
+					}
+					if (c == 0)
+						break;
+					curCmd.Clear();
+				}
+				else
+					curCmd.Append(c);
+			}
+			if (failed)
+				cmds.Clear();
+			cmds.Add(COFFFrameProgram::Command_None);
+			program.mCommands = (COFFFrameProgram::Command*)mAlloc.AllocBytes(cmds.size());
+			memcpy(program.mCommands, &cmds[0], cmds.size());
+
+			*programPtr = program;
+		}
+
+		entry.mProgram = *programPtr;
+		mDebugTarget->mCOFFFrameDescriptorMap.insert(std::make_pair(baseAddr + frame->mRvaStart, entry));
+	}
+
+	mParsedFrameDescriptors = true;
+
+}
+
+void COFF::ParseFrameDescriptors()
+{
+	if (mParsedFrameDescriptors)
+		return;
+	if (mCvNewFPOStream == 0)
+		return;
+
+	int streamSize = 0;
+	mNewFPOData = CvReadStream(mCvNewFPOStream, &streamSize);
+	ParseFrameDescriptors(mNewFPOData, streamSize, mImageBase);
+}
+
+NS_BF_DBG_BEGIN
+// void TestCoff(void* tdata, int tdataSize, void* cuData, int cuDataSize)
+// {
+// 	DebugTarget* debugTarget = new DebugTarget(NULL);
+// 	{
+// 		COFF coff(debugTarget);
+// 		coff.mCvTypeSectionData = (uint8*)tdata;
+// 		coff.mCvTypeSectionDataSize = tdataSize;
+// 
+// 		coff.mCvCompileUnitData = (uint8*)cuData;
+// 		coff.mCvCompileUnitDataSize = cuDataSize;
+// 
+// 		coff.ProcessDebugInfo();
+// 	}
+// 	delete debugTarget;
+// }
+
+void TestPDB(const String& fileName)
+{
+	DebugTarget* debugTarget = new DebugTarget(NULL);
+	COFF coff(debugTarget);	
+	uint8 wantGuid[16];
+	coff.LoadPDB(fileName, wantGuid, -1);
+	coff.CvParseIPI();
+	coff.ParseGlobalsData();
+	coff.ParseSymbolData();
+	for (int compileUnitId = 0; compileUnitId < (int)coff.mCvModuleInfo.size(); compileUnitId++)
+		coff.ParseCompileUnit(compileUnitId);
+}
+
+NS_BF_DBG_END