Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-09 03:52:19 +02:00
Code Activity

Comptime debugging

Browse source
This commit is contained in:
Brian Fiete 2022-03-08 06:27:06 -08:00
parent bbb97d1490
commit ff2e40e3bf
40 changed files with 6213 additions and 443 deletions
Download patch file Download diff file Expand all files Collapse all files

20
BeefySysLib/util/Array.h
View file

@ -1080,6 +1080,26 @@ public:
return NULL; return NULL;
return &this->mVals[this->mSize - addSize]; return &this->mVals[this->mSize - addSize];
} }
template <typename TAlt>
int BinarySearchAlt(const TAlt& val, const std::function<int(const T& lhs, const TAlt& rhs)>& func)
{
int lo = 0;
int hi = this->mSize - 1;
while (lo <= hi)
{
int i = (lo + hi) / 2;
const T& midVal = this->mVals[i];
int c = func(midVal, val);
if (c == 0) return i;
if (c < 0)
lo = i + 1;
else
hi = i - 1;
}
return ~lo;
}
}; };
template <typename T, typename TAlloc = AllocatorCLib<T> > template <typename T, typename TAlloc = AllocatorCLib<T> >

1
IDE/src/Commands.bf
View file

@ -225,6 +225,7 @@ namespace IDE
Add("Comment Toggle", new => gApp.[Friend]CommentToggle, .Editor); Add("Comment Toggle", new => gApp.[Friend]CommentToggle, .Editor);
Add("Compile File", new => gApp.Cmd_CompileFile); Add("Compile File", new => gApp.Cmd_CompileFile);
Add("Debug All Tests", new () => { gApp.[Friend]RunTests(true, true); }); Add("Debug All Tests", new () => { gApp.[Friend]RunTests(true, true); });
Add("Debug Comptime", new => gApp.DebugComptime);
Add("Debug Normal Tests", new () => { gApp.[Friend]RunTests(false, true); }); Add("Debug Normal Tests", new () => { gApp.[Friend]RunTests(false, true); });
Add("Delete All Right", new => gApp.[Friend]DeleteAllRight); Add("Delete All Right", new => gApp.[Friend]DeleteAllRight);
Add("Duplicate Line", new () => { gApp.[Friend]DuplicateLine(); }); Add("Duplicate Line", new () => { gApp.[Friend]DuplicateLine(); });

26
IDE/src/Debugger/DebugManager.bf
View file

@ -5,6 +5,7 @@ using System.Threading.Tasks;
using System.Diagnostics; using System.Diagnostics;
using Beefy.utils; using Beefy.utils;
using IDE.util; using IDE.util;
using IDE.Compiler;
namespace IDE.Debugger namespace IDE.Debugger
{ {
@ -80,7 +81,8 @@ namespace IDE.Debugger
Optimized = 1, Optimized = 1,
HasPendingDebugInfo = 2, HasPendingDebugInfo = 2,
CanLoadOldVersion = 4, CanLoadOldVersion = 4,
WasHotReplaced = 8 WasHotReplaced = 8,
HadError = 0x10
} }
//[Flags] //[Flags]
@ -142,6 +144,9 @@ namespace IDE.Debugger
[CallingConvention(.Stdcall),CLink] [CallingConvention(.Stdcall),CLink]
static extern bool Debugger_OpenFile(char8* launchPath, char8* targetPath, char8* args, char8* workingDir, void* envBlockPtr, int32 envBlockLen, bool hotSwapEnabled); static extern bool Debugger_OpenFile(char8* launchPath, char8* targetPath, char8* args, char8* workingDir, void* envBlockPtr, int32 envBlockLen, bool hotSwapEnabled);
[CallingConvention(.Stdcall),CLink]
static extern bool Debugger_ComptimeAttach(void* bfCompiler);
[CallingConvention(.Stdcall),CLink] [CallingConvention(.Stdcall),CLink]
static extern bool Debugger_Attach(int32 processId, AttachFlags attachFlags); static extern bool Debugger_Attach(int32 processId, AttachFlags attachFlags);
@ -371,6 +376,7 @@ namespace IDE.Debugger
public bool mIsRunning; public bool mIsRunning;
public bool mIsRunningCompiled; public bool mIsRunningCompiled;
public bool mIsRunningWithHotSwap; public bool mIsRunningWithHotSwap;
public bool mIsComptimeDebug;
//public RunState mLastUpdatedRunState; //public RunState mLastUpdatedRunState;
public bool mCallStackDirty; public bool mCallStackDirty;
public int32 mActiveCallStackIdx; public int32 mActiveCallStackIdx;
@ -427,11 +433,21 @@ namespace IDE.Debugger
DeleteAndNullify!(mRunningPath); DeleteAndNullify!(mRunningPath);
mRunningPath = new String(launchPath); mRunningPath = new String(launchPath);
mIsComptimeDebug = false;
mIsRunningCompiled = isCompiled; mIsRunningCompiled = isCompiled;
mIsRunningWithHotSwap = hotSwapEnabled; mIsRunningWithHotSwap = hotSwapEnabled;
return Debugger_OpenFile(launchPath, targetPath, args, workingDir, envBlock.Ptr, (int32)envBlock.Length, hotSwapEnabled); return Debugger_OpenFile(launchPath, targetPath, args, workingDir, envBlock.Ptr, (int32)envBlock.Length, hotSwapEnabled);
} }
public bool ComptimeAttach(BfCompiler compiler)
{
mIsComptimeDebug = true;
mIsRunningCompiled = false;
mIsRunningWithHotSwap = false;
mIsRunning = true;
return Debugger_ComptimeAttach(compiler.mNativeBfCompiler);
}
public void SetSymSrvOptions(String symCacheDir, String symSrvStr, SymSrvFlags symSrvFlags) public void SetSymSrvOptions(String symCacheDir, String symSrvStr, SymSrvFlags symSrvFlags)
{ {
Debugger_SetSymSrvOptions(symCacheDir, symSrvStr, (int32)symSrvFlags); Debugger_SetSymSrvOptions(symCacheDir, symSrvStr, (int32)symSrvFlags);
@ -439,7 +455,9 @@ namespace IDE.Debugger
public bool OpenMiniDump(String file) public bool OpenMiniDump(String file)
{ {
mIsComptimeDebug = false;
mIsRunningCompiled = false; mIsRunningCompiled = false;
mIsRunningWithHotSwap = false;
return Debugger_OpenMiniDump(file); return Debugger_OpenMiniDump(file);
} }
@ -482,6 +500,9 @@ namespace IDE.Debugger
if (breakpoint.mThreadId != -1) if (breakpoint.mThreadId != -1)
breakpoint.mThreadId = 0; breakpoint.mThreadId = 0;
} }
mIsComptimeDebug = false;
mIsRunning = false;
} }
public RunState GetRunState() public RunState GetRunState()
@ -1083,6 +1104,9 @@ namespace IDE.Debugger
public bool Attach(Process process, AttachFlags attachFlags) public bool Attach(Process process, AttachFlags attachFlags)
{ {
mIsRunningCompiled = false;
mIsComptimeDebug = false;
mIsRunningWithHotSwap = false;
return Debugger_Attach(process.Id, attachFlags); return Debugger_Attach(process.Id, attachFlags);
} }

49
IDE/src/IDEApp.bf
View file

@ -862,6 +862,7 @@ namespace IDE
let sourceViewPanel = GetActiveSourceViewPanel(); let sourceViewPanel = GetActiveSourceViewPanel();
if (sourceViewPanel != null) if (sourceViewPanel != null)
{ {
if (sourceViewPanel.mFilePath != null)
Path.GetDirectoryPath(sourceViewPanel.mFilePath, fullDir); Path.GetDirectoryPath(sourceViewPanel.mFilePath, fullDir);
} }
else if ((gApp.mDebugger.mRunningPath != null) && (!mWorkspace.IsInitialized)) else if ((gApp.mDebugger.mRunningPath != null) && (!mWorkspace.IsInitialized))
@ -4342,6 +4343,9 @@ namespace IDE
if (mExecutionQueue.Count == 0) if (mExecutionQueue.Count == 0)
{ {
mOutputPanel.Clear(); mOutputPanel.Clear();
if (mDebugger?.mIsComptimeDebug == true)
OutputLine("Compiling with comptime debugging...");
else
OutputLine("Compiling..."); OutputLine("Compiling...");
Compile(.Normal, null); Compile(.Normal, null);
} }
@ -4447,6 +4451,24 @@ namespace IDE
} }
} }
[IDECommand]
public void DebugComptime()
{
if (mDebugger.mIsRunning)
return;
if (IsCompiling)
return;
CheckDebugVisualizers();
mTargetDidInitBreak = true;
mTargetStartWithStep = false;
mDebugger.ComptimeAttach(mBfBuildCompiler);
mDebugger.RehupBreakpoints(true);
mBfBuildCompiler.ForceRebuild();
Compile();
}
[IDECommand] [IDECommand]
void RunWithoutCompiling() void RunWithoutCompiling()
{ {
@ -5622,6 +5644,7 @@ namespace IDE
subMenu = root.AddMenuItem("&Build"); subMenu = root.AddMenuItem("&Build");
AddMenuItem(subMenu, "&Build Workspace", "Build Workspace", new => UpdateMenuItem_HasWorkspace); AddMenuItem(subMenu, "&Build Workspace", "Build Workspace", new => UpdateMenuItem_HasWorkspace);
AddMenuItem(subMenu, "&Debug Comptime", "Debug Comptime", new => UpdateMenuItem_HasWorkspace);
AddMenuItem(subMenu, "&Clean", "Clean", new => UpdateMenuItem_DebugStopped_HasWorkspace); AddMenuItem(subMenu, "&Clean", "Clean", new => UpdateMenuItem_DebugStopped_HasWorkspace);
AddMenuItem(subMenu, "Clean Beef", "Clean Beef", new => UpdateMenuItem_DebugStopped_HasWorkspace); AddMenuItem(subMenu, "Clean Beef", "Clean Beef", new => UpdateMenuItem_DebugStopped_HasWorkspace);
//subMenu.AddMenuItem("Compile Current File", null, new (menu) => { CompileCurrentFile(); }); //subMenu.AddMenuItem("Compile Current File", null, new (menu) => { CompileCurrentFile(); });
@ -7211,7 +7234,7 @@ namespace IDE
// No 'wrong hash' warnings // No 'wrong hash' warnings
} }
else if (((hash != .None) && (sourceViewPanel.mEditData != null) && (!sourceViewPanel.mEditData.CheckHash(hash))) || else if (((hash != .None) && (sourceViewPanel.mEditData != null) && (!sourceViewPanel.mEditData.CheckHash(hash))) ||
(sourceViewPanel.mHasChangedSinceLastCompile)) (sourceViewPanel.mHasChangedSinceLastCompile) && (mDebugger?.mIsComptimeDebug != true))
{ {
sourceViewPanel.ShowWrongHash(); sourceViewPanel.ShowWrongHash();
} }
@ -7695,6 +7718,11 @@ namespace IDE
void SysKeyDown(KeyDownEvent evt) void SysKeyDown(KeyDownEvent evt)
{ {
if (evt.mKeyCode != .Alt)
{
NOP!();
}
if (evt.mHandled) if (evt.mHandled)
return; return;
@ -8723,6 +8751,9 @@ namespace IDE
if ((mVerbosity >= .Detailed) && (buildCompletedCmd.mStopwatch != null)) if ((mVerbosity >= .Detailed) && (buildCompletedCmd.mStopwatch != null))
OutputLine("Total build time: {0:0.00}s", buildCompletedCmd.mStopwatch.ElapsedMilliseconds / 1000.0f); OutputLine("Total build time: {0:0.00}s", buildCompletedCmd.mStopwatch.ElapsedMilliseconds / 1000.0f);
if (mDebugger?.mIsComptimeDebug == true)
DebuggerComptimeStop();
CompileDone(!buildCompletedCmd.mFailed); CompileDone(!buildCompletedCmd.mFailed);
if (mTestManager != null) if (mTestManager != null)
@ -9427,6 +9458,9 @@ namespace IDE
bool needsComptime = bfCompiler.GetLastHadComptimeRebuilds(); bool needsComptime = bfCompiler.GetLastHadComptimeRebuilds();
if (mDebugger?.mIsComptimeDebug == true)
needsComptime = true;
if ((!workspaceOptions.mIncrementalBuild) && (!lastCompileHadMessages)) if ((!workspaceOptions.mIncrementalBuild) && (!lastCompileHadMessages))
{ {
tryQueueFiles = false; tryQueueFiles = false;
@ -10376,6 +10410,9 @@ namespace IDE
{ {
Beep(MessageBeepType.Error); Beep(MessageBeepType.Error);
} }
if (mDebugger?.mIsComptimeDebug == true)
DebuggerComptimeStop();
} }
void DbgCopyChangedFiles(DateTime cmpTime, StringView srcDir, StringView destDir) void DbgCopyChangedFiles(DateTime cmpTime, StringView srcDir, StringView destDir)
@ -10767,6 +10804,9 @@ namespace IDE
if (mDebugger.mIsRunning) if (mDebugger.mIsRunning)
{ {
if (mDebugger.mIsComptimeDebug)
CancelBuild();
mDebugger.StopDebugging(); mDebugger.StopDebugging();
} }
} }
@ -12104,6 +12144,12 @@ namespace IDE
return .Normal; return .Normal;
} }
void DebuggerComptimeStop()
{
mDebugger.DisposeNativeBreakpoints();
mDebugger.Detach();
}
void DebuggerPaused() void DebuggerPaused()
{ {
mDebugger.mActiveCallStackIdx = 0; mDebugger.mActiveCallStackIdx = 0;
@ -14027,6 +14073,7 @@ namespace IDE
[Import("user32.lib"), CLink, CallingConvention(.Stdcall)] [Import("user32.lib"), CLink, CallingConvention(.Stdcall)]
public static extern bool MessageBeep(MessageBeepType type); public static extern bool MessageBeep(MessageBeepType type);
#endif #endif
} }
static static

1
IDE/src/Settings.bf
View file

@ -787,6 +787,7 @@ namespace IDE
Add("Comment Block", "Ctrl+K, Ctrl+C"); Add("Comment Block", "Ctrl+K, Ctrl+C");
Add("Comment Lines", "Ctrl+K, Ctrl+/"); Add("Comment Lines", "Ctrl+K, Ctrl+/");
Add("Comment Toggle", "Ctrl+K, Ctrl+T"); Add("Comment Toggle", "Ctrl+K, Ctrl+T");
Add("Debug Comptime", "Alt+F7");
Add("Duplicate Line", "Ctrl+D"); Add("Duplicate Line", "Ctrl+D");
Add("Find Class", "Alt+Shift+L"); Add("Find Class", "Alt+Shift+L");
Add("Find in Document", "Ctrl+F"); Add("Find in Document", "Ctrl+F");

58
IDE/src/ui/DisassemblyPanel.bf
View file

@ -539,6 +539,7 @@ namespace IDE.ui
String sourceLineText = scope .(1024); String sourceLineText = scope .(1024);
int32 maxLine = 0; int32 maxLine = 0;
int addrOffset = 0;
for (var lineStrView in codeData.Split('\n')) for (var lineStrView in codeData.Split('\n'))
{ {
@ -557,6 +558,9 @@ namespace IDE.ui
switch (line[0]) switch (line[0])
{ {
case 'A':
addrOffset = (int)int64.Parse(StringView(line, 2), System.Globalization.NumberStyles.HexNumber);
continue;
case 'O': case 'O':
isOptimized = true; isOptimized = true;
addLineData = false; addLineData = false;
@ -612,7 +616,7 @@ namespace IDE.ui
//int ptrSize = 8; //int ptrSize = 8;
var addrString = scope String(disasmLine, 0, parenPos); var addrString = scope String(disasmLine, 0, parenPos);
addrString.Replace("'", ""); addrString.Replace("'", "");
lineData.mAddr = (int)int64.Parse(addrString, System.Globalization.NumberStyles.HexNumber); lineData.mAddr = (int)int64.Parse(addrString, System.Globalization.NumberStyles.HexNumber) + addrOffset;
lineData.mAddrEnd = lineData.mAddr + 1; lineData.mAddrEnd = lineData.mAddr + 1;
if (prevDisasmLineData != -1) if (prevDisasmLineData != -1)
@ -709,7 +713,7 @@ namespace IDE.ui
addLineData = false; addLineData = false;
JumpEntry jumpEntry = new JumpEntry(); JumpEntry jumpEntry = new JumpEntry();
int64 addrFrom = (int64)mLineDatas[mLineDatas.Count - 1].mAddr; int64 addrFrom = (int64)mLineDatas[mLineDatas.Count - 1].mAddr;
int64 addrTo = int64.Parse(scope String(line, 2), System.Globalization.NumberStyles.HexNumber); int64 addrTo = int64.Parse(scope String(line, 2), System.Globalization.NumberStyles.HexNumber) + addrOffset;
jumpEntry.mAddrMin = (int)Math.Min(addrFrom, addrTo); jumpEntry.mAddrMin = (int)Math.Min(addrFrom, addrTo);
jumpEntry.mAddrMax = (int)Math.Max(addrFrom, addrTo); jumpEntry.mAddrMax = (int)Math.Max(addrFrom, addrTo);
jumpEntry.mIsReverse = jumpEntry.mAddrMin == (int)addrTo; jumpEntry.mIsReverse = jumpEntry.mAddrMin == (int)addrTo;
@ -1193,6 +1197,7 @@ namespace IDE.ui
int leftIdx = -1; int leftIdx = -1;
int rightIdx = -1; int rightIdx = -1;
int commaIdx = -1;
String debugExpr = null; String debugExpr = null;
if ((cursorPos < content.mData.mTextLength) && (!((char8)content.mData.mText[cursorPos].mChar).IsWhiteSpace)) if ((cursorPos < content.mData.mTextLength) && (!((char8)content.mData.mText[cursorPos].mChar).IsWhiteSpace))
@ -1208,11 +1213,45 @@ namespace IDE.ui
content.ExtractString(lineStart, lineEnd - lineStart, lineStr); content.ExtractString(lineStart, lineEnd - lineStart, lineStr);
int strIdx = 0; int strIdx = 0;
bool isComptime = false;
for (int i in 0..<lineStr.Length-1)
{
if ((lineStr[i] == '[') && (lineStr[i+1] == 'F'))
isComptime = true;
}
if (isComptime)
{
int cursorStrIdx = cursorPos - lineStart;
if ((cursorStrIdx >= 0) && (cursorStrIdx < lineStr.Length))
{
leftIdx = cursorStrIdx;
rightIdx = cursorStrIdx;
while (leftIdx > 0)
{
if (lineStr[leftIdx - 1].IsWhiteSpace)
break;
leftIdx--;
}
while (rightIdx < lineStr.Length - 1)
{
if (lineStr[rightIdx + 1].IsWhiteSpace)
break;
rightIdx++;
}
leftIdx += lineStart;
rightIdx += lineStart;
}
}
else
{
int colonPos = -1; int colonPos = -1;
int instrStartIdx = -1; int instrStartIdx = -1;
int instrEndIdx = -1; int instrEndIdx = -1;
int firstParamIdx = -1; int firstParamIdx = -1;
int commaIdx = -1;
for (; strIdx < lineStr.Length; strIdx++) for (; strIdx < lineStr.Length; strIdx++)
{ {
@ -1261,6 +1300,7 @@ namespace IDE.ui
else else
rightIdx = lineEnd - 1; rightIdx = lineEnd - 1;
} }
}
if (leftIdx != -1) if (leftIdx != -1)
{ {
@ -1273,6 +1313,11 @@ namespace IDE.ui
int32 semiPos = (int32)debugExpr.IndexOf(';'); int32 semiPos = (int32)debugExpr.IndexOf(';');
if (semiPos != -1) if (semiPos != -1)
debugExpr.RemoveToEnd(semiPos); debugExpr.RemoveToEnd(semiPos);
debugExpr.Trim();
int atPos = debugExpr.IndexOf('@');
if (atPos != -1)
debugExpr.RemoveToEnd(atPos);
debugExpr.Replace('[', '('); debugExpr.Replace('[', '(');
debugExpr.Replace(']', ')'); debugExpr.Replace(']', ')');
@ -1282,6 +1327,13 @@ namespace IDE.ui
debugExpr.Replace("word ptr", "(int16*)"); debugExpr.Replace("word ptr", "(int16*)");
debugExpr.Replace("byte ptr", "(int8*)"); debugExpr.Replace("byte ptr", "(int8*)");
if ((debugExpr.Contains('(')) && (debugExpr[0].IsLetter))
{
int parenPos = debugExpr.IndexOf('(');
debugExpr.Insert(parenPos, "*)");
debugExpr.Insert(0, "*(");
}
if (line < mLineDatas.Count - 1) if (line < mLineDatas.Count - 1)
{ {
if (mLineDatas[line].mAddrEnd != (int)0) if (mLineDatas[line].mAddrEnd != (int)0)

9
IDE/src/ui/StatusBar.bf
View file

@ -321,6 +321,11 @@ namespace IDE.ui
float statusLabelPos = (int)GS!(-1.3f); float statusLabelPos = (int)GS!(-1.3f);
if ((gApp.mDebugger?.mIsComptimeDebug == true) && (gApp.mDebugger.IsPaused()))
{
completionPct = null;
}
//completionPct = 0.4f; //completionPct = 0.4f;
if (completionPct.HasValue) if (completionPct.HasValue)
{ {
@ -331,6 +336,10 @@ namespace IDE.ui
using (g.PushColor(0xFF00FF00)) using (g.PushColor(0xFF00FF00))
g.FillRect(completionRect.mX, completionRect.mY, completionRect.mWidth * completionPct.Value, completionRect.mHeight); g.FillRect(completionRect.mX, completionRect.mY, completionRect.mWidth * completionPct.Value, completionRect.mHeight);
} }
else if ((gApp.mDebugger?.mIsComptimeDebug == true) && (gApp.mDebugger.IsPaused()))
{
g.DrawString("Debugging Comptime", GS!(200), statusLabelPos, FontAlign.Centered, GS!(120));
}
else if ((gApp.mDebugger.mIsRunning) && (gApp.HaveSourcesChanged())) else if ((gApp.mDebugger.mIsRunning) && (gApp.HaveSourcesChanged()))
{ {
Rect completionRect = Rect(GS!(200), GS!(1), GS!(120), GS!(17)); Rect completionRect = Rect(GS!(200), GS!(1), GS!(120), GS!(17));

25
IDEHelper/Backend/BeCOFFObject.cpp
View file

@ -475,9 +475,9 @@ void BeCOFFObject::DbgMakeFuncType(BeDbgFunction* dbgFunc)
if (hasThis) if (hasThis)
{ {
if ((dbgFunc->mVariables.size() > 0) && (dbgFunc->mVariables[0] == NULL)) if ((dbgFunc->mVariables.size() > 0) && (dbgFunc->mVariables[0] == NULL))
outT.Write(DbgGetTypeId(dbgFunc->GetParamType(1))); // 0 is sret, 1 = this outT.Write(DbgGetTypeId(BeValueDynCast<BeDbgType>(dbgFunc->GetParamType(1)))); // 0 is sret, 1 = this
else else
outT.Write(DbgGetTypeId(dbgFunc->GetParamType(0))); // 0 = this outT.Write(DbgGetTypeId(BeValueDynCast<BeDbgType>(dbgFunc->GetParamType(0)))); // 0 = this
} }
else else
outT.Write((int32)T_VOID); outT.Write((int32)T_VOID);
@ -941,7 +941,7 @@ int BeCOFFObject::DbgGetTypeId(BeDbgType* dbgType, bool doDefine)
{ {
CV_modifier_t attr = { 0 }; CV_modifier_t attr = { 0 };
attr.MOD_const = 1; attr.MOD_const = 1;
int32 elementId = DbgGetTypeId(constType->mElement); int32 elementId = DbgGetTypeId(BeValueDynCast<BeDbgType>(constType->mElement));
DbgTStartTag(); DbgTStartTag();
outT.Write((int16)LF_MODIFIER); outT.Write((int16)LF_MODIFIER);
@ -985,10 +985,10 @@ void BeCOFFObject::DbgGenerateTypeInfo()
auto& outT = mDebugTSect.mData; auto& outT = mDebugTSect.mData;
outT.Write((int)CV_SIGNATURE_C13); outT.Write((int)CV_SIGNATURE_C13);
for (auto dbgType : mBeModule->mDbgModule->mTypes) for (auto mdNode : mBeModule->mDbgModule->mTypes)
{ {
bool defineType = true; bool defineType = true;
if (auto dbgStructType = BeValueDynCast<BeDbgStructType>(dbgType)) if (auto dbgStructType = BeValueDynCast<BeDbgStructType>(mdNode))
{ {
if (!dbgStructType->mIsFullyDefined) if (!dbgStructType->mIsFullyDefined)
defineType = false; defineType = false;
@ -996,6 +996,7 @@ void BeCOFFObject::DbgGenerateTypeInfo()
if (defineType) if (defineType)
{ {
if (auto dbgType = BeValueDynCast<BeDbgType>(mdNode))
DbgGetTypeId(dbgType, true); DbgGetTypeId(dbgType, true);
} }
} }
@ -1032,6 +1033,8 @@ void BeCOFFObject::DbgStartVarDefRange(BeDbgFunction* dbgFunc, BeDbgVariable* db
auto funcSym = GetSymbol(dbgFunc->mValue); auto funcSym = GetSymbol(dbgFunc->mValue);
auto varType = BeValueDynCast<BeDbgType>(dbgVar->mType);
auto& outS = mDebugSSect.mData; auto& outS = mDebugSSect.mData;
if (varLoc.mKind == BeDbgVariableLoc::Kind_SymbolAddr) if (varLoc.mKind == BeDbgVariableLoc::Kind_SymbolAddr)
{ {
@ -1042,14 +1045,14 @@ void BeCOFFObject::DbgStartVarDefRange(BeDbgFunction* dbgFunc, BeDbgVariable* db
if (varLoc.mOfs == 0) if (varLoc.mOfs == 0)
{ {
outS.Write((int16)S_DEFRANGE_REGISTER); outS.Write((int16)S_DEFRANGE_REGISTER);
outS.Write((int16)GetCVRegNum(varLoc.mReg, dbgVar->mType->mSize * 8)); outS.Write((int16)GetCVRegNum(varLoc.mReg, varType->mSize * 8));
CV_RANGEATTR rangeAttr = { 0 }; CV_RANGEATTR rangeAttr = { 0 };
outS.Write(*(int16*)&rangeAttr); // offset to register outS.Write(*(int16*)&rangeAttr); // offset to register
} }
else else
{ {
outS.Write((int16)S_DEFRANGE_REGISTER_REL); outS.Write((int16)S_DEFRANGE_REGISTER_REL);
outS.Write((int16)GetCVRegNum(varLoc.mReg, dbgVar->mType->mSize * 8)); outS.Write((int16)GetCVRegNum(varLoc.mReg, varType->mSize * 8));
outS.Write((int16)0); outS.Write((int16)0);
outS.Write((int32)varLoc.mOfs); outS.Write((int32)varLoc.mOfs);
// CV_RANGEATTR rangeAttr = { 0 }; // CV_RANGEATTR rangeAttr = { 0 };
@ -1135,6 +1138,8 @@ void BeCOFFObject::DbgSEndTag()
void BeCOFFObject::DbgOutputLocalVar(BeDbgFunction* dbgFunc, BeDbgVariable* dbgVar) void BeCOFFObject::DbgOutputLocalVar(BeDbgFunction* dbgFunc, BeDbgVariable* dbgVar)
{ {
auto varType = BeValueDynCast<BeDbgType>(dbgVar->mType);
// CodeView only allows 16-bit lengths, so we need to split ranges for very long spans // CodeView only allows 16-bit lengths, so we need to split ranges for very long spans
if (dbgVar->mDeclEnd - dbgVar->mDeclStart > 0xFFFF) if (dbgVar->mDeclEnd - dbgVar->mDeclStart > 0xFFFF)
{ {
@ -1215,7 +1220,7 @@ void BeCOFFObject::DbgOutputLocalVar(BeDbgFunction* dbgFunc, BeDbgVariable* dbgV
DbgSStartTag(); DbgSStartTag();
outS.Write((int16)S_LOCAL); outS.Write((int16)S_LOCAL);
outS.Write(DbgGetTypeId(dbgVar->mType)); outS.Write(DbgGetTypeId(varType));
CV_LVARFLAGS flags = { 0 }; CV_LVARFLAGS flags = { 0 };
if (dbgVar->mParamNum != -1) if (dbgVar->mParamNum != -1)
@ -1732,7 +1737,7 @@ void BeCOFFObject::DbgGenerateModuleInfo()
else else
outS.Write(dbgGlobalVar->mIsLocalToUnit ? (int16)S_LDATA32 : (int16)S_GDATA32); outS.Write(dbgGlobalVar->mIsLocalToUnit ? (int16)S_LDATA32 : (int16)S_GDATA32);
outS.Write(DbgGetTypeId(dbgGlobalVar->mType)); outS.Write(DbgGetTypeId(BeValueDynCast<BeDbgType>(dbgGlobalVar->mType)));
BF_ASSERT(dbgGlobalVar->mValue != NULL); BF_ASSERT(dbgGlobalVar->mValue != NULL);
@ -1896,7 +1901,7 @@ void BeCOFFObject::WriteConst(BeCOFFSection& sect, BeConstant* constVal)
{ {
WriteConst(sect, constCast->mTarget); WriteConst(sect, constCast->mTarget);
} }
else if (auto constGep = BeValueDynCast<BeGEPConstant>(constVal)) else if (auto constGep = BeValueDynCast<BeGEP2Constant>(constVal))
{ {
if (auto globalVar = BeValueDynCast<BeGlobalVariable>(constGep->mTarget)) if (auto globalVar = BeValueDynCast<BeGlobalVariable>(constGep->mTarget))
{ {

77
IDEHelper/Backend/BeIRCodeGen.cpp
View file

@ -5,6 +5,9 @@
#include "BeefySysLib/util/AllocDebug.h" #include "BeefySysLib/util/AllocDebug.h"
#include "BeefySysLib/util/Hash.h" #include "BeefySysLib/util/Hash.h"
#include "BeModule.h"
#include "BeContext.h"
#include "..\Compiler\CeMachine.h"
#ifdef _DEBUG #ifdef _DEBUG
#define BE_EXTRA_CHECKS #define BE_EXTRA_CHECKS
@ -736,6 +739,20 @@ void BeIRCodeGen::Read(BeValue*& beValue)
BE_MEM_END("ParamType_Const_BitCast"); BE_MEM_END("ParamType_Const_BitCast");
return; return;
} }
else if (constType == BfConstType_GEP32_1)
{
CMD_PARAM(BeConstant*, target);
CMD_PARAM(int, idx0);
BF_ASSERT(target->GetType()->IsPointer());
auto gepConstant = mBeModule->mAlloc.Alloc<BeGEP1Constant>();
gepConstant->mTarget = target;
gepConstant->mIdx0 = idx0;
beValue = gepConstant;
BE_MEM_END("ParamType_Const_GEP32_1");
return;
}
else if (constType == BfConstType_GEP32_2) else if (constType == BfConstType_GEP32_2)
{ {
CMD_PARAM(BeConstant*, target); CMD_PARAM(BeConstant*, target);
@ -743,7 +760,7 @@ void BeIRCodeGen::Read(BeValue*& beValue)
CMD_PARAM(int, idx1); CMD_PARAM(int, idx1);
BF_ASSERT(target->GetType()->IsPointer()); BF_ASSERT(target->GetType()->IsPointer());
auto gepConstant = mBeModule->mAlloc.Alloc<BeGEPConstant>(); auto gepConstant = mBeModule->mAlloc.Alloc<BeGEP2Constant>();
gepConstant->mTarget = target; gepConstant->mTarget = target;
gepConstant->mIdx0 = idx0; gepConstant->mIdx0 = idx0;
gepConstant->mIdx1 = idx1; gepConstant->mIdx1 = idx1;
@ -2852,6 +2869,14 @@ void BeIRCodeGen::HandleNextCmd()
case BfIRCmd_DbgGetType: case BfIRCmd_DbgGetType:
{ {
CMD_PARAM(int, typeId); CMD_PARAM(int, typeId);
if (mBeModule->mCeMachine != NULL)
{
auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgTypeId>();
dbgType->mTypeId = typeId;
SetResult(curId, dbgType);
}
else
SetResult(curId, GetTypeEntry(typeId).mDIType); SetResult(curId, GetTypeEntry(typeId).mDIType);
} }
break; break;
@ -2974,7 +2999,21 @@ void BeIRCodeGen::HandleNextCmd()
{ {
CMD_PARAM(BeMDNode*, elementTypeNode); CMD_PARAM(BeMDNode*, elementTypeNode);
BeDbgType* elementType = (BeDbgType*)elementTypeNode; BeDbgType* elementType = BeValueDynCast<BeDbgType>(elementTypeNode);
if (elementType == NULL)
{
if (auto dbgTypeId = BeValueDynCast<BeDbgTypeId>(elementTypeNode))
{
auto bfElementType = mBeModule->mCeMachine->mCeModule->mContext->mTypes[dbgTypeId->mTypeId];
auto bfPtrType = mBeModule->mCeMachine->mCeModule->CreatePointerType(bfElementType);
auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgTypeId>();
dbgType->mTypeId = bfPtrType->mTypeId;
SetResult(curId, dbgType);
break;
}
}
BeDbgType* useType = elementType->FindDerivedType(BeDbgPointerType::TypeId); BeDbgType* useType = elementType->FindDerivedType(BeDbgPointerType::TypeId);
if (useType == NULL) if (useType == NULL)
{ {
@ -2992,7 +3031,23 @@ void BeIRCodeGen::HandleNextCmd()
case BfIRCmd_DbgCreateReferenceType: case BfIRCmd_DbgCreateReferenceType:
{ {
CMD_PARAM(BeMDNode*, elementTypeNode); CMD_PARAM(BeMDNode*, elementTypeNode);
auto useType = mBeModule->mDbgModule->CreateReferenceType((BeDbgType*)elementTypeNode);
BeDbgType* elementType = BeValueDynCast<BeDbgType>(elementTypeNode);
if (elementType == NULL)
{
if (auto dbgTypeId = BeValueDynCast<BeDbgTypeId>(elementTypeNode))
{
auto bfElementType = mBeModule->mCeMachine->mCeModule->mContext->mTypes[dbgTypeId->mTypeId];
auto bfPtrType = mBeModule->mCeMachine->mCeModule->CreateRefType(bfElementType);
auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgTypeId>();
dbgType->mTypeId = bfPtrType->mTypeId;
SetResult(curId, dbgType);
break;
}
}
auto useType = mBeModule->mDbgModule->CreateReferenceType(elementType);
SetResult(curId, useType); SetResult(curId, useType);
} }
break; break;
@ -3000,7 +3055,15 @@ void BeIRCodeGen::HandleNextCmd()
{ {
CMD_PARAM(BeMDNode*, elementTypeNode); CMD_PARAM(BeMDNode*, elementTypeNode);
BeDbgType* elementType = (BeDbgType*)elementTypeNode; BeDbgType* elementType = BeValueDynCast<BeDbgType>(elementTypeNode);
if (elementType == NULL)
{
auto dbgType = mBeModule->mDbgModule->mTypes.Alloc<BeDbgConstType>();
dbgType->mElement = elementTypeNode;
SetResult(curId, dbgType);
break;
}
BeDbgType* useType = elementType->FindDerivedType(BeDbgConstType::TypeId); BeDbgType* useType = elementType->FindDerivedType(BeDbgConstType::TypeId);
if (useType == NULL) if (useType == NULL)
{ {
@ -3363,7 +3426,7 @@ void BeIRCodeGen::HandleNextCmd()
auto dbgVar = mBeModule->mOwnedValues.Alloc<BeDbgVariable>(); auto dbgVar = mBeModule->mOwnedValues.Alloc<BeDbgVariable>();
dbgVar->mName = name; dbgVar->mName = name;
dbgVar->mType = (BeDbgType*)type; dbgVar->mType = type;
dbgVar->mParamNum = argNo - 1; dbgVar->mParamNum = argNo - 1;
int argIdx = argNo - 1; int argIdx = argNo - 1;
@ -3411,7 +3474,7 @@ void BeIRCodeGen::HandleNextCmd()
auto dbgVar = mBeModule->mOwnedValues.Alloc<BeDbgVariable>(); auto dbgVar = mBeModule->mOwnedValues.Alloc<BeDbgVariable>();
dbgVar->mName = name; dbgVar->mName = name;
dbgVar->mType = (BeDbgType*)type; dbgVar->mType = type;
dbgVar->mScope = scope; dbgVar->mScope = scope;
dbgVar->mInitType = (BfIRInitType)initType; dbgVar->mInitType = (BfIRInitType)initType;
mActiveFunction->mDbgFunction->mVariables.push_back(dbgVar); mActiveFunction->mDbgFunction->mVariables.push_back(dbgVar);
@ -3490,7 +3553,7 @@ void BeIRCodeGen::HandleNextCmd()
dbgGlobalVariable->mLinkageName = linkageName; dbgGlobalVariable->mLinkageName = linkageName;
dbgGlobalVariable->mFile = (BeDbgFile*)file; dbgGlobalVariable->mFile = (BeDbgFile*)file;
dbgGlobalVariable->mLineNum = lineNum; dbgGlobalVariable->mLineNum = lineNum;
dbgGlobalVariable->mType = (BeDbgType*)type; dbgGlobalVariable->mType = type;
dbgGlobalVariable->mIsLocalToUnit = isLocalToUnit; dbgGlobalVariable->mIsLocalToUnit = isLocalToUnit;
dbgGlobalVariable->mValue = val; dbgGlobalVariable->mValue = val;
dbgGlobalVariable->mDecl = decl; dbgGlobalVariable->mDecl = decl;

37
IDEHelper/Backend/BeMCContext.cpp
View file

@ -2279,9 +2279,34 @@ BeMCOperand BeMCContext::GetOperand(BeValue* value, bool allowMetaResult, bool a
return mcOperand; return mcOperand;
} }
case BeGEPConstant::TypeId: case BeGEP1Constant::TypeId:
{ {
auto gepConstant = (BeGEPConstant*)value; auto gepConstant = (BeGEP1Constant*)value;
auto mcVal = GetOperand(gepConstant->mTarget);
BePointerType* ptrType = (BePointerType*)GetType(mcVal);
BEMC_ASSERT(ptrType->mTypeCode == BeTypeCode_Pointer);
auto result = mcVal;
// We assume we never do both an idx0 and idx1 at once. Fix if we change that.
int byteOffset = 0;
BeType* elementType = ptrType->mElementType;
byteOffset += gepConstant->mIdx0 * ptrType->mElementType->GetStride();
result = AllocRelativeVirtualReg(ptrType, result, GetImmediate(byteOffset), 1);
// The def is primary to create a single 'master location' for the GEP vreg to become legalized before use
auto vregInfo = GetVRegInfo(result);
vregInfo->mDefOnFirstUse = true;
result.mKind = BeMCOperandKind_VReg;
return result;
}
break;
case BeGEP2Constant::TypeId:
{
auto gepConstant = (BeGEP2Constant*)value;
auto mcVal = GetOperand(gepConstant->mTarget); auto mcVal = GetOperand(gepConstant->mTarget);
@ -2887,7 +2912,11 @@ static bool NeedsDecompose(BeConstant* constant)
if (auto targetConstant = BeValueDynCast<BeConstant>(castConst->mValue)) if (auto targetConstant = BeValueDynCast<BeConstant>(castConst->mValue))
return NeedsDecompose(targetConstant); return NeedsDecompose(targetConstant);
} }
else if (auto castConst = BeValueDynCast<BeGEPConstant>(constant)) else if (auto castConst = BeValueDynCast<BeGEP1Constant>(constant))
{
return NeedsDecompose(castConst->mTarget);
}
else if (auto castConst = BeValueDynCast<BeGEP2Constant>(constant))
{ {
return NeedsDecompose(castConst->mTarget); return NeedsDecompose(castConst->mTarget);
} }
@ -8681,7 +8710,7 @@ void BeMCContext::DoActualization()
else else
{ {
inst->mArg0.mKind = BeMCOperandKind_VRegAddr; inst->mArg0.mKind = BeMCOperandKind_VRegAddr;
vregInfo->mDbgVariable->mType = mModule->mDbgModule->CreateReferenceType(vregInfo->mDbgVariable->mType); vregInfo->mDbgVariable->mType = mModule->mDbgModule->CreateReferenceType(BeValueDynCast<BeDbgType>(vregInfo->mDbgVariable->mType));
} }
} }
vregInfo->mWantsExprActualize = false; vregInfo->mWantsExprActualize = false;

38
IDEHelper/Backend/BeModule.cpp
View file

@ -497,7 +497,13 @@ void BeStructConstant::GetData(BeConstData& data)
val->GetData(data); val->GetData(data);
} }
BeType* BeGEPConstant::GetType() BeType* BeGEP1Constant::GetType()
{
BePointerType* ptrType = (BePointerType*)mTarget->GetType();
return ptrType;
}
BeType* BeGEP2Constant::GetType()
{ {
BePointerType* ptrType = (BePointerType*)mTarget->GetType(); BePointerType* ptrType = (BePointerType*)mTarget->GetType();
BF_ASSERT(ptrType->mTypeCode == BeTypeCode_Pointer); BF_ASSERT(ptrType->mTypeCode == BeTypeCode_Pointer);
@ -1040,6 +1046,12 @@ void BeDumpContext::ToString(StringImpl& str, BeValue* value, bool showType, boo
return; return;
} }
if (auto dbgType = BeValueDynCast<BeDbgTypeId>(mdNode))
{
str += StrFormat("DbgTypeId: %d", dbgType->mTypeId);
return;
}
if (auto dbgVar = BeValueDynCast<BeDbgVariable>(mdNode)) if (auto dbgVar = BeValueDynCast<BeDbgVariable>(mdNode))
{ {
ToString(str, dbgVar->mType); ToString(str, dbgVar->mType);
@ -1281,9 +1293,17 @@ void BeDumpContext::ToString(StringImpl& str, BeValue* value, bool showType, boo
return; return;
} }
if (auto constantGEP = BeValueDynCast<BeGEPConstant>(value)) if (auto constantGEP = BeValueDynCast<BeGEP1Constant>(value))
{ {
str += "ConstGep "; str += "ConstGEP1 ";
ToString(str, constantGEP->mTarget);
str += StrFormat(" %d %d", constantGEP->mIdx0);
return;
}
if (auto constantGEP = BeValueDynCast<BeGEP2Constant>(value))
{
str += "ConstGEP2 ";
ToString(str, constantGEP->mTarget); ToString(str, constantGEP->mTarget);
str += StrFormat(" %d %d", constantGEP->mIdx0, constantGEP->mIdx1); str += StrFormat(" %d %d", constantGEP->mIdx0, constantGEP->mIdx1);
return; return;
@ -1373,7 +1393,16 @@ void BeDumpContext::ToString(StringImpl& str, BeValue* value, bool showType, boo
return; return;
} }
if (auto constant = BeValueDynCast<BeGEPConstant>(value)) if (auto constant = BeValueDynCast<BeGEP1Constant>(value))
{
ToString(str, constant->GetType());
str += " gep (";
ToString(str, constant->mTarget);
str += StrFormat(", %d)", constant->mIdx0);
return;
}
if (auto constant = BeValueDynCast<BeGEP2Constant>(value))
{ {
ToString(str, constant->GetType()); ToString(str, constant->GetType());
str += " gep ("; str += " gep (";
@ -1762,6 +1791,7 @@ BeModule::BeModule(const StringImpl& moduleName, BeContext* context)
mLastDbgLoc = NULL; mLastDbgLoc = NULL;
mActiveFunction = NULL; mActiveFunction = NULL;
mDbgModule = NULL; mDbgModule = NULL;
mCeMachine = NULL;
mPrevDbgLocInline = NULL; mPrevDbgLocInline = NULL;
mCurDbgLocIdx = 0; mCurDbgLocIdx = 0;
mCurLexBlockId = 0; mCurLexBlockId = 0;

52
IDEHelper/Backend/BeModule.h
View file

@ -55,6 +55,7 @@ class BePhiInst;
class BeSwitchInst; class BeSwitchInst;
class BeRetInst; class BeRetInst;
class BeCallInst; class BeCallInst;
class CeMachine;
class BeDbgVariable; class BeDbgVariable;
class BeDbgDeclareInst; class BeDbgDeclareInst;
@ -357,10 +358,26 @@ public:
} }
}; };
class BeGEPConstant : public BeConstant class BeGEP1Constant : public BeConstant
{ {
public: public:
BE_VALUE_TYPE(BeGEPConstant, BeConstant); BE_VALUE_TYPE(BeGEP1Constant, BeConstant);
int mIdx0;
virtual BeType* GetType();
virtual void HashContent(BeHashContext& hashCtx) override
{
hashCtx.Mixin(TypeId);
mTarget->HashReference(hashCtx);
hashCtx.Mixin(mIdx0);
}
};
class BeGEP2Constant : public BeConstant
{
public:
BE_VALUE_TYPE(BeGEP2Constant, BeConstant);
int mIdx0; int mIdx0;
int mIdx1; int mIdx1;
@ -1646,6 +1663,26 @@ public:
} }
}; };
class BeDbgTypeId : public BeMDNode
{
public:
BE_VALUE_TYPE(BeDbgTypeId, BeMDNode);
public:
int mTypeId;
BeDbgTypeId()
{
mTypeId = -1;
}
virtual void HashContent(BeHashContext& hashCtx) override
{
hashCtx.Mixin(TypeId);
hashCtx.Mixin(mTypeId);
}
};
class BeDbgType : public BeMDNode class BeDbgType : public BeMDNode
{ {
public: public:
@ -1743,7 +1780,7 @@ public:
BE_VALUE_TYPE(BeDbgConstType, BeDbgType); BE_VALUE_TYPE(BeDbgConstType, BeDbgType);
public: public:
BeDbgType* mElement; BeMDNode* mElement;
virtual void HashContent(BeHashContext& hashCtx) override virtual void HashContent(BeHashContext& hashCtx) override
{ {
@ -1920,7 +1957,7 @@ public:
public: public:
String mName; String mName;
BeDbgType* mType; BeMDNode* mType;
BeValue* mValue; BeValue* mValue;
int mParamNum; int mParamNum;
BfIRInitType mInitType; BfIRInitType mInitType;
@ -2044,7 +2081,7 @@ public:
mCvArgListId = -1; mCvArgListId = -1;
} }
BeDbgType* GetParamType(int paramIdx) BeMDNode* GetParamType(int paramIdx)
{ {
/*if (!mParams.empty()) /*if (!mParams.empty())
return mParams[paramIdx]->mType;*/ return mParams[paramIdx]->mType;*/
@ -2209,7 +2246,7 @@ public:
String mLinkageName; String mLinkageName;
BeDbgFile* mFile; BeDbgFile* mFile;
int mLineNum; int mLineNum;
BeDbgType* mType; BeMDNode* mType;
bool mIsLocalToUnit; bool mIsLocalToUnit;
BeConstant* mValue; BeConstant* mValue;
BeMDNode* mDecl; BeMDNode* mDecl;
@ -2246,7 +2283,7 @@ public:
OwnedVector<BeDbgNamespace> mNamespaces; OwnedVector<BeDbgNamespace> mNamespaces;
OwnedVector<BeDbgGlobalVariable> mGlobalVariables; OwnedVector<BeDbgGlobalVariable> mGlobalVariables;
OwnedVector<BeDbgType> mTypes; OwnedVector<BeMDNode> mTypes;
Array<BeDbgFunction*> mFuncs; // Does not include methods in structs Array<BeDbgFunction*> mFuncs; // Does not include methods in structs
virtual void HashContent(BeHashContext& hashCtx) override; virtual void HashContent(BeHashContext& hashCtx) override;
@ -2284,6 +2321,7 @@ public:
int mCurLexBlockId; int mCurLexBlockId;
BeDbgModule* mDbgModule; BeDbgModule* mDbgModule;
CeMachine* mCeMachine;
public: public:
void AddInst(BeInst* inst); void AddInst(BeInst* inst);

5
IDEHelper/Compiler/BfAst.h
View file

@ -750,6 +750,11 @@ public:
return (mKind == BfTypedValueKind_UntypedValue); return (mKind == BfTypedValueKind_UntypedValue);
} }
bool IsNoValueType() const
{
return (mKind == BfTypedValueKind_NoValue);
}
bool IsParams() bool IsParams()
{ {
return (mKind == BfTypedValueKind_ParamsSplat) || (mKind == BfTypedValueKind_Params); return (mKind == BfTypedValueKind_ParamsSplat) || (mKind == BfTypedValueKind_Params);

8
IDEHelper/Compiler/BfCompiler.cpp
View file

@ -7658,6 +7658,12 @@ void BfCompiler::Cancel()
mCanceling = true; mCanceling = true;
mFastFinish = true; mFastFinish = true;
mHadCancel = true; mHadCancel = true;
if (mCEMachine != NULL)
{
AutoCrit autoCrit(mCEMachine->mCritSect);
mCEMachine->mSpecialCheck = true;
mFastFinish = true;
}
BfLogSysM("BfCompiler::Cancel\n"); BfLogSysM("BfCompiler::Cancel\n");
BpEvent("BfCompiler::Cancel", ""); BpEvent("BfCompiler::Cancel", "");
} }
@ -7665,6 +7671,8 @@ void BfCompiler::Cancel()
void BfCompiler::RequestFastFinish() void BfCompiler::RequestFastFinish()
{ {
mFastFinish = true; mFastFinish = true;
if (mCEMachine != NULL)
mCEMachine->mSpecialCheck = true;
BfLogSysM("BfCompiler::RequestFastFinish\n"); BfLogSysM("BfCompiler::RequestFastFinish\n");
BpEvent("BfCompiler::RequestFastFinish", ""); BpEvent("BfCompiler::RequestFastFinish", "");
} }

144
IDEHelper/Compiler/BfExprEvaluator.cpp
View file

@ -21,6 +21,8 @@
#include "BfFixits.h" #include "BfFixits.h"
#include "CeMachine.h" #include "CeMachine.h"
#include "BfDefBuilder.h" #include "BfDefBuilder.h"
#include "CeMachine.h"
#include "CeDebugger.h"
#pragma warning(pop) #pragma warning(pop)
#pragma warning(disable:4996) #pragma warning(disable:4996)
@ -4018,6 +4020,35 @@ BfTypedValue BfExprEvaluator::LoadLocal(BfLocalVariable* varDecl, bool allowRef)
BfTypedValue BfExprEvaluator::LookupIdentifier(BfAstNode* refNode, const StringImpl& findName, bool ignoreInitialError, bool* hadError) BfTypedValue BfExprEvaluator::LookupIdentifier(BfAstNode* refNode, const StringImpl& findName, bool ignoreInitialError, bool* hadError)
{ {
if ((mModule->mCompiler->mCEMachine != NULL) && (mModule->mCompiler->mCEMachine->mDebugger != NULL) && (mModule->mCompiler->mCEMachine->mDebugger->mCurDbgState != NULL))
{
auto ceDebugger = mModule->mCompiler->mCEMachine->mDebugger;
auto ceContext = ceDebugger->mCurDbgState->mCeContext;
auto activeFrame = ceDebugger->mCurDbgState->mActiveFrame;
if (activeFrame->mFunction->mDbgInfo != NULL)
{
int instIdx = activeFrame->GetInstIdx();
for (auto& dbgVar : activeFrame->mFunction->mDbgInfo->mVariables)
{
if (dbgVar.mName == findName)
{
if (dbgVar.mValue.mKind == CeOperandKind_AllocaAddr)
{
return BfTypedValue(mModule->mBfIRBuilder->CreateConstAggCE(mModule->mBfIRBuilder->MapType(dbgVar.mType), activeFrame->mFrameAddr + dbgVar.mValue.mFrameOfs), dbgVar.mType, true);
}
}
}
}
if (findName == "FR")
{
auto ptrType = mModule->CreatePointerType(mModule->GetPrimitiveType(BfTypeCode_UInt8));
auto intVal = mModule->mBfIRBuilder->CreateConst(BfTypeCode_IntPtr, activeFrame->mFrameAddr);
auto ptrVal = mModule->mBfIRBuilder->CreateIntToPtr(intVal, mModule->mBfIRBuilder->MapType(ptrType));
return BfTypedValue(ptrVal, ptrType);
}
}
auto identifierNode = BfNodeDynCast<BfIdentifierNode>(refNode); auto identifierNode = BfNodeDynCast<BfIdentifierNode>(refNode);
if (mModule->mCurMethodState != NULL) if (mModule->mCurMethodState != NULL)
{ {
@ -4649,6 +4680,7 @@ BfTypedValue BfExprEvaluator::LoadField(BfAstNode* targetSrc, BfTypedValue targe
if (isFailurePass) if (isFailurePass)
{ {
if (mModule->GetCeDbgState() == NULL)
mModule->Fail(StrFormat("'%s.%s' is inaccessible due to its protection level", mModule->TypeToString(typeInstance).c_str(), fieldDef->mName.c_str()), targetSrc); mModule->Fail(StrFormat("'%s.%s' is inaccessible due to its protection level", mModule->TypeToString(typeInstance).c_str(), fieldDef->mName.c_str()), targetSrc);
} }
@ -6039,6 +6071,28 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, BfMethodInstance*
CeEvalFlags evalFlags = CeEvalFlags_None; CeEvalFlags evalFlags = CeEvalFlags_None;
if ((mBfEvalExprFlags & BfEvalExprFlags_NoCeRebuildFlags) != 0) if ((mBfEvalExprFlags & BfEvalExprFlags_NoCeRebuildFlags) != 0)
evalFlags = (CeEvalFlags)(evalFlags | CeEvalFlags_NoRebuild); evalFlags = (CeEvalFlags)(evalFlags | CeEvalFlags_NoRebuild);
if ((mModule->mIsComptimeModule) && (mModule->mCompiler->mCEMachine->mDebugger != NULL) && (mModule->mCompiler->mCEMachine->mDebugger->mCurDbgState != NULL))
{
auto ceDbgState = mModule->mCompiler->mCEMachine->mDebugger->mCurDbgState;
if ((ceDbgState->mDbgExpressionFlags & DwEvalExpressionFlag_AllowCalls) != 0)
{
ceDbgState->mHadSideEffects = true;
SetAndRestoreValue<CeDebugger*> prevDebugger(mModule->mCompiler->mCEMachine->mDebugger, NULL);
evalFlags = (CeEvalFlags)(evalFlags | CeEvalFlags_DbgCall);
auto result = ceDbgState->mCeContext->Call(targetSrc, mModule, methodInstance, irArgs, evalFlags, mExpectingType);
if (result)
return result;
}
else
{
ceDbgState->mBlockedSideEffects = true;
}
}
else
{
auto constRet = mModule->mCompiler->mCEMachine->Call(targetSrc, mModule, methodInstance, irArgs, evalFlags, mExpectingType); auto constRet = mModule->mCompiler->mCEMachine->Call(targetSrc, mModule, methodInstance, irArgs, evalFlags, mExpectingType);
if (constRet) if (constRet)
{ {
@ -6058,6 +6112,7 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, BfMethodInstance*
doConstReturn = true; doConstReturn = true;
} }
} }
}
else if (mModule->mIsComptimeModule) else if (mModule->mIsComptimeModule)
{ {
if (methodInstance->mIsUnspecialized) if (methodInstance->mIsUnspecialized)
@ -17499,6 +17554,51 @@ void BfExprEvaluator::DoInvocation(BfAstNode* target, BfMethodBoundExpression* m
} }
return; return;
} }
if (auto ceDbgState = mModule->GetCeDbgState())
{
if (targetFunctionName.StartsWith("__"))
{
auto ceDebugger = mModule->mCompiler->mCEMachine->mDebugger;
auto _ResolveArg = [&](int argIdx, BfType* type = NULL)
{
if (argIdx >= args.mSize)
return BfTypedValue();
return mModule->CreateValueFromExpression(args[argIdx], type);
};
if (targetFunctionName == "__getHighBits")
{
auto typedVal = _ResolveArg(0);
if ((typedVal) && (typedVal.mType->IsPrimitiveType()))
{
auto primType = (BfPrimitiveType*)typedVal.mType;
int64 val = ceDebugger->ValueToInt(typedVal);
int64 bitCount = ceDebugger->ValueToInt(_ResolveArg(1));
int64 resultVal = val >> (typedVal.mType->mSize * 8 - bitCount);
mResult = BfTypedValue(mModule->mBfIRBuilder->CreateConst(primType->mTypeDef->mTypeCode, (uint64)resultVal), typedVal.mType);
return;
}
}
else if (targetFunctionName == "__clearHighBits")
{
auto typedVal = _ResolveArg(0);
if ((typedVal) && (typedVal.mType->IsPrimitiveType()))
{
auto primType = (BfPrimitiveType*)typedVal.mType;
int64 val = ceDebugger->ValueToInt(typedVal);
int64 bitCount = ceDebugger->ValueToInt(_ResolveArg(1));
int64 andBits = (0x8000000000000000LL) >> ((typedVal.mType->mSize - 8) * 8 + bitCount - 1);
int64 resultVal = val & ~andBits;
mResult = BfTypedValue(mModule->mBfIRBuilder->CreateConst(primType->mTypeDef->mTypeCode, (uint64)resultVal), typedVal.mType);
return;
}
}
}
}
} }
else if (auto expr = BfNodeDynCast<BfExpression>(target)) else if (auto expr = BfNodeDynCast<BfExpression>(target))
{ {
@ -19374,6 +19474,49 @@ void BfExprEvaluator::PerformAssignment(BfAssignmentExpression* assignExpr, bool
mModule->EmitEnsureInstructionAt(); mModule->EmitEnsureInstructionAt();
} }
else if (!alreadyWritten) else if (!alreadyWritten)
{
if ((mModule->mIsComptimeModule) && (mModule->mCompiler->mCEMachine->mDebugger != NULL) && (mModule->mCompiler->mCEMachine->mDebugger->mCurDbgState != NULL))
{
auto ceDbgState = mModule->mCompiler->mCEMachine->mDebugger->mCurDbgState;
bool success = false;
if ((convVal.mValue.IsConst()) && (ptr.mValue.IsConst()))
{
auto constant = mModule->mBfIRBuilder->GetConstant(ptr.mValue);
auto valConstant = mModule->mBfIRBuilder->GetConstant(convVal.mValue);
auto ceTypedVal = mModule->mCompiler->mCEMachine->mDebugger->GetAddr(constant);
if (!ceTypedVal)
{
mModule->Fail("Invalid assignment address", assignExpr);
return;
}
auto ceContext = mModule->mCompiler->mCEMachine->mCurContext;
if (ceContext->CheckMemory(ceTypedVal.mAddr, convVal.mType->mSize))
{
if ((ceDbgState->mDbgExpressionFlags & DwEvalExpressionFlag_AllowSideEffects) != 0)
{
ceDbgState->mHadSideEffects = true;
if (ceContext->WriteConstant(mModule, ceTypedVal.mAddr, valConstant, convVal.mType))
success = true;
}
else
{
ceDbgState->mBlockedSideEffects = true;
success = true;
}
}
}
if (!success)
{
mModule->Fail("Assignment failed", assignExpr);
return;
}
}
if (!alreadyWritten)
{ {
//ptr = mModule->LoadValue(ptr); //ptr = mModule->LoadValue(ptr);
BF_ASSERT(ptr.IsAddr()); BF_ASSERT(ptr.IsAddr());
@ -19383,6 +19526,7 @@ void BfExprEvaluator::PerformAssignment(BfAssignmentExpression* assignExpr, bool
} }
} }
} }
}
else else
{ {
BF_ASSERT(convVal.mType->IsValuelessType()); BF_ASSERT(convVal.mType->IsValuelessType());

61
IDEHelper/Compiler/BfIRBuilder.cpp
View file

@ -1684,6 +1684,12 @@ String BfIRBuilder::ToString(BfIRValue irValue)
BfIRValue targetConst(BfIRValueFlags_Const, box->mTarget); BfIRValue targetConst(BfIRValueFlags_Const, box->mTarget);
return ToString(targetConst) + " box to " + ToString(box->mToType); return ToString(targetConst) + " box to " + ToString(box->mToType);
} }
else if (constant->mConstType == BfConstType_GEP32_1)
{
auto gepConst = (BfConstantGEP32_1*)constant;
BfIRValue targetConst(BfIRValueFlags_Const, gepConst->mTarget);
return ToString(targetConst) + StrFormat(" Gep32 %d", gepConst->mIdx0);
}
else if (constant->mConstType == BfConstType_GEP32_2) else if (constant->mConstType == BfConstType_GEP32_2)
{ {
auto gepConst = (BfConstantGEP32_2*)constant; auto gepConst = (BfConstantGEP32_2*)constant;
@ -4616,8 +4622,30 @@ BfIRValue BfIRBuilder::CreateIntToPtr(BfIRValue val, BfIRType type)
return retVal; return retVal;
} }
BfIRValue BfIRBuilder::CreateIntToPtr(uint64 val, BfIRType type)
{
return CreateIntToPtr(CreateConst(BfTypeCode_IntPtr, val), type);
}
BfIRValue BfIRBuilder::CreateInBoundsGEP(BfIRValue val, int idx0) BfIRValue BfIRBuilder::CreateInBoundsGEP(BfIRValue val, int idx0)
{ {
if (val.IsConst())
{
auto constGEP = mTempAlloc.Alloc<BfConstantGEP32_1>();
constGEP->mConstType = BfConstType_GEP32_1;
constGEP->mTarget = val.mId;
constGEP->mIdx0 = idx0;
BfIRValue retVal;
retVal.mFlags = BfIRValueFlags_Const;
retVal.mId = mTempAlloc.GetChunkedId(constGEP);
#ifdef CHECK_CONSTHOLDER
retVal.mHolder = this;
#endif
return retVal;
}
BfIRValue retVal = WriteCmd(BfIRCmd_InboundsGEP1_32, val, idx0); BfIRValue retVal = WriteCmd(BfIRCmd_InboundsGEP1_32, val, idx0);
NEW_CMD_INSERTED_IRVALUE; NEW_CMD_INSERTED_IRVALUE;
return retVal; return retVal;
@ -4650,6 +4678,39 @@ BfIRValue BfIRBuilder::CreateInBoundsGEP(BfIRValue val, int idx0, int idx1)
BfIRValue BfIRBuilder::CreateInBoundsGEP(BfIRValue val, BfIRValue idx0) BfIRValue BfIRBuilder::CreateInBoundsGEP(BfIRValue val, BfIRValue idx0)
{ {
auto constant = GetConstant(val);
if (constant != NULL)
{
if (constant->mConstType == BfConstType_IntToPtr)
{
auto fromPtrToInt = (BfConstantIntToPtr*)constant;
auto fromTarget = GetConstantById(fromPtrToInt->mTarget);
if (IsInt(fromTarget->mTypeCode))
{
if (fromPtrToInt->mToType.mKind == BfIRTypeData::TypeKind_TypeId)
{
auto type = mModule->mContext->mTypes[fromPtrToInt->mToType.mId];
if (type->IsPointer())
{
auto elementType = type->GetUnderlyingType();
auto addConstant = GetConstant(idx0);
if ((addConstant != NULL) && (IsInt(addConstant->mTypeCode)))
{
return CreateIntToPtr(CreateConst(fromTarget->mTypeCode, (uint64)(fromTarget->mInt64 + addConstant->mInt64 * elementType->GetStride())),
fromPtrToInt->mToType);
}
}
}
}
}
if (auto idxConstant = GetConstant(idx0))
{
if (IsInt(idxConstant->mTypeCode))
return CreateInBoundsGEP(val, idxConstant->mInt32);
}
}
BfIRValue retVal = WriteCmd(BfIRCmd_InBoundsGEP1, val, idx0); BfIRValue retVal = WriteCmd(BfIRCmd_InBoundsGEP1, val, idx0);
NEW_CMD_INSERTED_IRVALUE; NEW_CMD_INSERTED_IRVALUE;
return retVal; return retVal;

9
IDEHelper/Compiler/BfIRBuilder.h
View file

@ -126,6 +126,7 @@ enum BfConstType
BfConstType_GlobalVar = BfTypeCode_Length, BfConstType_GlobalVar = BfTypeCode_Length,
BfConstType_BitCast, BfConstType_BitCast,
BfConstType_BitCastNull, BfConstType_BitCastNull,
BfConstType_GEP32_1,
BfConstType_GEP32_2, BfConstType_GEP32_2,
BfConstType_ExtractValue, BfConstType_ExtractValue,
BfConstType_PtrToInt, BfConstType_PtrToInt,
@ -878,6 +879,13 @@ struct BfConstantIntToPtr
BfIRType mToType; BfIRType mToType;
}; };
struct BfConstantGEP32_1
{
BfConstType mConstType;
int mTarget;
int mIdx0;
};
struct BfConstantGEP32_2 struct BfConstantGEP32_2
{ {
BfConstType mConstType; BfConstType mConstType;
@ -1223,6 +1231,7 @@ public:
BfIRValue CreateBitCast(BfIRValue val, BfIRType type); BfIRValue CreateBitCast(BfIRValue val, BfIRType type);
BfIRValue CreatePtrToInt(BfIRValue val, BfTypeCode typeCode); BfIRValue CreatePtrToInt(BfIRValue val, BfTypeCode typeCode);
BfIRValue CreateIntToPtr(BfIRValue val, BfIRType type); BfIRValue CreateIntToPtr(BfIRValue val, BfIRType type);
BfIRValue CreateIntToPtr(uint64 val, BfIRType type);
BfIRValue CreateInBoundsGEP(BfIRValue val, int idx0); BfIRValue CreateInBoundsGEP(BfIRValue val, int idx0);
BfIRValue CreateInBoundsGEP(BfIRValue val, int idx0, int idx1); BfIRValue CreateInBoundsGEP(BfIRValue val, int idx0, int idx1);
BfIRValue CreateInBoundsGEP(BfIRValue val, BfIRValue idx0); BfIRValue CreateInBoundsGEP(BfIRValue val, BfIRValue idx0);

56
IDEHelper/Compiler/BfModule.cpp
View file

@ -25,6 +25,7 @@
#include "BfDefBuilder.h" #include "BfDefBuilder.h"
#include "BfDeferEvalChecker.h" #include "BfDeferEvalChecker.h"
#include "CeMachine.h" #include "CeMachine.h"
#include "CeDebugger.h"
#include <fcntl.h> #include <fcntl.h>
#include <time.h> #include <time.h>
@ -1045,7 +1046,7 @@ void BfModule::FinishInit()
mHasFullDebugInfo = moduleOptions.mEmitDebugInfo == 1; mHasFullDebugInfo = moduleOptions.mEmitDebugInfo == 1;
if (mIsComptimeModule) if (mIsComptimeModule)
mHasFullDebugInfo = false; mHasFullDebugInfo = true;
if (((!mCompiler->mIsResolveOnly) && (!mIsScratchModule) && (moduleOptions.mEmitDebugInfo != 0) && (mIsReified)) || if (((!mCompiler->mIsResolveOnly) && (!mIsScratchModule) && (moduleOptions.mEmitDebugInfo != 0) && (mIsReified)) ||
(mIsComptimeModule)) (mIsComptimeModule))
@ -1732,6 +1733,15 @@ String* BfModule::GetStringPoolString(BfIRValue constantStr, BfIRConstHolder * c
return NULL; return NULL;
} }
CeDbgState* BfModule::GetCeDbgState()
{
if (!mIsComptimeModule)
return NULL;
if ((mCompiler->mCEMachine != NULL) && (mCompiler->mCEMachine->mDebugger != NULL))
return mCompiler->mCEMachine->mDebugger->mCurDbgState;
return NULL;
}
BfIRValue BfModule::GetStringCharPtr(int stringId, bool force) BfIRValue BfModule::GetStringCharPtr(int stringId, bool force)
{ {
if ((mBfIRBuilder->mIgnoreWrites) && (!force)) if ((mBfIRBuilder->mIgnoreWrites) && (!force))
@ -3066,8 +3076,10 @@ BfError* BfModule::Fail(const StringImpl& error, BfAstNode* refNode, bool isPers
//BF_ASSERT(refNode != NULL); //BF_ASSERT(refNode != NULL);
if (mIsComptimeModule) if ((mIsComptimeModule) && (!mCompiler->mCEMachine->mDbgPaused))
{ {
mHadBuildError = true;
if ((mCompiler->mCEMachine->mCurContext != NULL) && (mCompiler->mCEMachine->mCurContext->mCurTargetSrc != NULL)) if ((mCompiler->mCEMachine->mCurContext != NULL) && (mCompiler->mCEMachine->mCurContext->mCurTargetSrc != NULL))
{ {
BfError* bfError = mCompiler->mPassInstance->Fail("Comptime method generation had errors", mCompiler->mCEMachine->mCurContext->mCurTargetSrc); BfError* bfError = mCompiler->mPassInstance->Fail("Comptime method generation had errors", mCompiler->mCEMachine->mCurContext->mCurTargetSrc);
@ -3076,7 +3088,6 @@ BfError* BfModule::Fail(const StringImpl& error, BfAstNode* refNode, bool isPers
return bfError; return bfError;
} }
mHadBuildError = true;
return NULL; return NULL;
} }
@ -12452,6 +12463,39 @@ BfTypedValue BfModule::LoadValue(BfTypedValue typedValue, BfAstNode* refNode, bo
return GetDefaultTypedValue(typedValue.mType); return GetDefaultTypedValue(typedValue.mType);
} }
} }
if ((mIsComptimeModule) && (mCompiler->mCEMachine->mDebugger != NULL) && (mCompiler->mCEMachine->mDebugger->mCurDbgState != NULL))
{
auto ceDebugger = mCompiler->mCEMachine->mDebugger;
auto ceContext = ceDebugger->mCurDbgState->mCeContext;
auto activeFrame = ceDebugger->mCurDbgState->mActiveFrame;
auto ceTypedValue = ceDebugger->GetAddr(constantValue);
if (ceTypedValue)
{
if ((typedValue.mType->IsObjectOrInterface()) || (typedValue.mType->IsPointer()))
{
void* data = ceContext->GetMemoryPtr(ceTypedValue.mAddr, sizeof(addr_ce));
if (data == NULL)
{
Fail("Invalid address", refNode);
return GetDefaultTypedValue(typedValue.mType);
}
addr_ce dataAddr = *(addr_ce*)data;
return BfTypedValue(mBfIRBuilder->CreateIntToPtr(
mBfIRBuilder->CreateConst(BfTypeCode_IntPtr, (uint64)dataAddr), mBfIRBuilder->MapType(typedValue.mType)), typedValue.mType);
}
auto constVal = ceContext->CreateConstant(this, ceContext->mMemory.mVals + ceTypedValue.mAddr, typedValue.mType);
if (!constVal)
{
Fail("Failed to create const", refNode);
return GetDefaultTypedValue(typedValue.mType);
}
return BfTypedValue(constVal, typedValue.mType);
}
}
} }
} }
@ -14605,6 +14649,11 @@ void BfModule::MarkUsingThis()
BfTypedValue BfModule::GetThis(bool markUsing) BfTypedValue BfModule::GetThis(bool markUsing)
{ {
if ((mIsComptimeModule) && (mCompiler->mCEMachine->mDebugger != NULL) && (mCompiler->mCEMachine->mDebugger->mCurDbgState != NULL))
{
return mCompiler->mCEMachine->mDebugger->mCurDbgState->mExplicitThis;
}
auto useMethodState = mCurMethodState; auto useMethodState = mCurMethodState;
while ((useMethodState != NULL) && (useMethodState->mClosureState != NULL) && (useMethodState->mClosureState->mCapturing)) while ((useMethodState != NULL) && (useMethodState->mClosureState != NULL) && (useMethodState->mClosureState->mCapturing))
{ {
@ -16616,6 +16665,7 @@ void BfModule::EmitDtorBody()
} }
else else
{ {
PopulateType(fieldInst->mResolvedType);
if (fieldInst->mResolvedType->IsValuelessType()) if (fieldInst->mResolvedType->IsValuelessType())
{ {
value = mBfIRBuilder->GetFakeVal(); value = mBfIRBuilder->GetFakeVal();

2
IDEHelper/Compiler/BfModule.h
View file

@ -33,6 +33,7 @@ class BfType;
class BfResolvedType; class BfResolvedType;
class BfExprEvaluator; class BfExprEvaluator;
class CeEmitContext; class CeEmitContext;
class CeDbgState;
enum BfPopulateType enum BfPopulateType
{ {
@ -1543,6 +1544,7 @@ public:
void VerifyOnDemandMethods(); void VerifyOnDemandMethods();
bool IsSkippingExtraResolveChecks(); bool IsSkippingExtraResolveChecks();
bool AddErrorContext(StringImpl& errorString, BfAstNode* refNode, bool& isWhileSpecializing, bool isWarning); bool AddErrorContext(StringImpl& errorString, BfAstNode* refNode, bool& isWhileSpecializing, bool isWarning);
CeDbgState* GetCeDbgState();
BfError* Fail(const StringImpl& error, BfAstNode* refNode = NULL, bool isPersistent = false, bool deferError = false); BfError* Fail(const StringImpl& error, BfAstNode* refNode = NULL, bool isPersistent = false, bool deferError = false);
BfError* FailInternal(const StringImpl& error, BfAstNode* refNode = NULL); BfError* FailInternal(const StringImpl& error, BfAstNode* refNode = NULL);
BfError* FailAfter(const StringImpl& error, BfAstNode* refNode); BfError* FailAfter(const StringImpl& error, BfAstNode* refNode);

10
IDEHelper/Compiler/BfParser.cpp
View file

@ -720,7 +720,7 @@ BfBlock* BfParser::ParseInlineBlock(int spaceIdx, int endIdx)
while (true) while (true)
{ {
NextToken(endIdx + 1); NextToken(endIdx + 1, false, true);
if (mSyntaxToken == BfSyntaxToken_HIT_END_IDX) if (mSyntaxToken == BfSyntaxToken_HIT_END_IDX)
{ {
mSrcIdx = usedEndIdx; mSrcIdx = usedEndIdx;
@ -1384,7 +1384,7 @@ double BfParser::ParseLiteralDouble()
return strtod(buf, NULL); return strtod(buf, NULL);
} }
void BfParser::NextToken(int endIdx, bool outerIsInterpolate) void BfParser::NextToken(int endIdx, bool outerIsInterpolate, bool disablePreprocessor)
{ {
auto prevToken = mToken; auto prevToken = mToken;
@ -2337,6 +2337,12 @@ void BfParser::NextToken(int endIdx, bool outerIsInterpolate)
} }
break; break;
case '#': case '#':
if (disablePreprocessor)
{
TokenFail("Unexpected character");
continue;
}
else
HandlePreprocessor(); HandlePreprocessor();
if (mSyntaxToken == BfSyntaxToken_EOF) if (mSyntaxToken == BfSyntaxToken_EOF)
return; return;

2
IDEHelper/Compiler/BfParser.h
View file

@ -227,7 +227,7 @@ public:
void MoveSource(const char* data, int length); // Takes ownership of data ptr void MoveSource(const char* data, int length); // Takes ownership of data ptr
void RefSource(const char* data, int length); void RefSource(const char* data, int length);
void MakeNegative(uint64& val, bool& hadOverflow); void MakeNegative(uint64& val, bool& hadOverflow);
void NextToken(int endIdx = -1, bool outerIsInterpolate = false); void NextToken(int endIdx = -1, bool outerIsInterpolate = false, bool disablePreprocessor = false);
BfAstNode* CreateNode(); BfAstNode* CreateNode();
void Parse(BfPassInstance* passInstance); void Parse(BfPassInstance* passInstance);

4
IDEHelper/Compiler/BfResolvedTypeUtils.cpp
View file

@ -3503,6 +3503,10 @@ int BfResolvedTypeSet::DoHash(BfTypeReference* typeRef, LookupContext* ctx, BfHa
BF_ASSERT(sizeExpr != NULL); BF_ASSERT(sizeExpr != NULL);
if (sizeExpr != NULL) if (sizeExpr != NULL)
{ {
BfMethodState methodState;
SetAndRestoreValue<BfMethodState*> prevMethodState(ctx->mModule->mCurMethodState, &methodState);
methodState.mTempKind = BfMethodState::TempKind_Static;
BfConstResolver constResolver(ctx->mModule); BfConstResolver constResolver(ctx->mModule);
BfType* intType = ctx->mModule->GetPrimitiveType(BfTypeCode_IntPtr); BfType* intType = ctx->mModule->GetPrimitiveType(BfTypeCode_IntPtr);
constResolver.mAllowGenericConstValue = true; constResolver.mAllowGenericConstValue = true;

2
IDEHelper/Compiler/BfStmtEvaluator.cpp
View file

@ -3523,7 +3523,7 @@ void BfModule::VisitCodeBlock(BfBlock* block)
mCurMethodState->mMixinState->mResultExpr = expr; mCurMethodState->mMixinState->mResultExpr = expr;
break; break;
} }
else if ((mCurMethodInstance->IsMixin()) && (mCurMethodState->mCurScope == &mCurMethodState->mHeadScope)) else if ((mCurMethodInstance != NULL) && (mCurMethodInstance->IsMixin()) && (mCurMethodState->mCurScope == &mCurMethodState->mHeadScope))
{ {
// Only in mixin definition - result ignored // Only in mixin definition - result ignored
CreateValueFromExpression(expr); CreateValueFromExpression(expr);

8
IDEHelper/Compiler/BfUtil.cpp
View file

@ -27,6 +27,14 @@ String Beefy::EncodeDataPtr(uint32 addr, bool doPrefix)
return StrFormat("%08X", addr); return StrFormat("%08X", addr);
} }
String Beefy::EncodeDataPtr(int addr, bool doPrefix)
{
if (doPrefix)
return StrFormat("0x%08X", addr);
else
return StrFormat("%08X", addr);
}
String Beefy::EncodeDataPtr(uint64 addr, bool doPrefix) String Beefy::EncodeDataPtr(uint64 addr, bool doPrefix)
{ {
if (doPrefix) if (doPrefix)

1
IDEHelper/Compiler/BfUtil.h
View file

@ -269,6 +269,7 @@ void* DecodeLocalDataPtr(const char*& strRef);
String EncodeDataPtr(void* addr, bool doPrefix); String EncodeDataPtr(void* addr, bool doPrefix);
String EncodeDataPtr(uint32 addr, bool doPrefix); String EncodeDataPtr(uint32 addr, bool doPrefix);
String EncodeDataPtr(uint64 addr, bool doPrefix); String EncodeDataPtr(uint64 addr, bool doPrefix);
String EncodeDataPtr(int addr, bool doPrefix);
void* ZeroedAlloc(int size); void* ZeroedAlloc(int size);
/*template <typename T> /*template <typename T>
T* ZeroedAlloc() T* ZeroedAlloc()

4239
IDEHelper/Compiler/CeDebugger.cpp Normal file
View file

File diff suppressed because it is too large Load diff

357
IDEHelper/Compiler/CeDebugger.h Normal file
View file

@ -0,0 +1,357 @@
#pragma once
#include "BfSystem.h"
#include "BfModule.h"
#include "BeefySysLib/util/Heap.h"
#include "BeefySysLib/util/AllocDebug.h"
#include "../Debugger.h"
NS_BF_BEGIN
class BfCompiler;
class CeFrame;
class CeExprEvaluator;
class CeContext;
class CeMachine;
class CeFunction;
class BfReducer;
class CeDebugger;
class DebugVisualizerEntry;
class CeBreakpoint : public Breakpoint
{
public:
uintptr mCurBindAddr;
bool mHasBound;
int mIdx;
public:
CeBreakpoint()
{
mCurBindAddr = 1;
mHasBound = false;
mIdx = -1;
}
virtual uintptr GetAddr() { return mCurBindAddr; }
virtual bool IsMemoryBreakpointBound() { return false; }
};
struct CeFormatInfo
{
int mCallStackIdx;
bool mHidePointers;
bool mIgnoreDerivedClassInfo;
bool mNoVisualizers;
bool mNoMembers;
bool mRawString;
bool mNoEdit;
DbgTypeKindFlags mTypeKindFlags;
intptr mArrayLength;
intptr mOverrideCount;
intptr mMaxCount;
DwDisplayType mDisplayType;
int mTotalSummaryLength;
String mReferenceId;
String mSubjectExpr;
String mExpectedType;
String mNamespaceSearch;
int mExpandItemDepth;
BfTypedValue mExplicitThis;
CeFormatInfo()
{
mCallStackIdx = -1;
mHidePointers = false;
mIgnoreDerivedClassInfo = false;
mRawString = false;
mNoVisualizers = false;
mNoMembers = false;
mNoEdit = false;
mTypeKindFlags = DbgTypeKindFlag_None;
mArrayLength = -1;
mOverrideCount = -1;
mMaxCount = -1;
mTotalSummaryLength = 0;
mDisplayType = DwDisplayType_NotSpecified;
mExpandItemDepth = 0;
}
};
class CeEvaluationContext
{
public:
CeDebugger* mDebugger;
BfParser* mParser;
BfReducer* mReducer;
BfPassInstance* mPassInstance;
BfExprEvaluator* mExprEvaluator;
BfExpression* mExprNode;
BfTypedValue mResultOverride;
String mExprString;
BfTypedValue mExplicitThis;
int mCallStackIdx;
public:
CeEvaluationContext(CeDebugger* winDebugger, const StringImpl& expr, CeFormatInfo* formatInfo = NULL, BfTypedValue contextValue = BfTypedValue());
void Init(CeDebugger* winDebugger, const StringImpl& expr, CeFormatInfo* formatInfo = NULL, BfTypedValue contextValue = BfTypedValue());
bool HasExpression();
~CeEvaluationContext();
BfTypedValue EvaluateInContext(BfTypedValue contextTypedValue);
String GetErrorStr();
bool HadError();
};
class CeDbgState
{
public:
CeFrame* mActiveFrame;
CeContext* mCeContext;
BfTypedValue mExplicitThis;
DwEvalExpressionFlags mDbgExpressionFlags;
bool mHadSideEffects;
bool mBlockedSideEffects;
public:
CeDbgState()
{
mActiveFrame = NULL;
mCeContext = NULL;
mDbgExpressionFlags = DwEvalExpressionFlag_None;
mHadSideEffects = false;
mBlockedSideEffects = false;
}
};
class CePendingExpr
{
public:
int mThreadId;
BfParser* mParser;
BfType* mExplitType;
CeFormatInfo mFormatInfo;
DwEvalExpressionFlags mExpressionFlags;
int mCursorPos;
BfAstNode* mExprNode;
String mReferenceId;
int mCallStackIdx;
String mResult;
int mIdleTicks;
String mException;
CePendingExpr();
~CePendingExpr();
};
class CeFileInfo
{
public:
Array<CeBreakpoint*> mOrderedBreakpoints;
};
class CeDbgFieldEntry
{
public:
BfType* mType;
int mDataOffset;
public:
CeDbgFieldEntry()
{
mType = NULL;
mDataOffset = 0;
}
};
class CeDbgTypeInfo
{
public:
struct ConstIntEntry
{
public:
int mFieldIdx;
int64 mVal;
};
public:
BfType* mType;
Array<CeDbgFieldEntry> mFieldOffsets;
Array<ConstIntEntry> mConstIntEntries;
};
struct CeTypedValue
{
addr_ce mAddr;
BfIRType mType;
CeTypedValue()
{
mAddr = 0;
mType = BfIRType();
}
CeTypedValue(addr_ce addr, BfIRType type)
{
mAddr = addr;
mType = type;
}
operator bool() const
{
return mType.mKind != BfIRTypeData::TypeKind_None;
}
};
class CeDebugger : public Debugger
{
public:
BfCompiler* mCompiler;
CeMachine* mCeMachine;
DebugManager* mDebugManager;
CePendingExpr* mDebugPendingExpr;
CeDbgState* mCurDbgState;
Array<CeBreakpoint*> mBreakpoints;
Dictionary<String, CeFileInfo*> mFileInfo;
Dictionary<int, CeDbgTypeInfo> mDbgTypeInfoMap;
CeEvaluationContext* mCurEvaluationContext;
CeBreakpoint* mActiveBreakpoint;
int mBreakpointVersion;
bool mBreakpointCacheDirty;
bool mBreakpointFramesDirty;
int mCurDisasmFuncId;
public:
bool SetupStep(int frameIdx = 0);
CeFrame* GetFrame(int callStackIdx);
String EvaluateContinue(CePendingExpr* pendingExpr, BfPassInstance& bfPassInstance);
String Evaluate(const StringImpl& expr, CeFormatInfo formatInfo, int callStackIdx, int cursorPos, int language, DwEvalExpressionFlags expressionFlags);
DwDisplayInfo* GetDisplayInfo(const StringImpl& referenceId);
String GetMemberList(BfType* type, addr_ce addr, addr_ce addrInst, bool isStatic);
DebugVisualizerEntry* FindVisualizerForType(BfType* dbgType, Array<String>* wildcardCaptures);
bool ParseFormatInfo(const StringImpl& formatInfoStr, CeFormatInfo* formatInfo, BfPassInstance* bfPassInstance, int* assignExprOffset, String* assignExprString, String* errorString, BfTypedValue contextTypedValue = BfTypedValue());
String MaybeQuoteFormatInfoParam(const StringImpl& str);
BfTypedValue EvaluateInContext(const BfTypedValue& contextTypedValue, const StringImpl& subExpr, CeFormatInfo* formatInfo = NULL, String* outReferenceId = NULL, String* outErrors = NULL);
void DbgVisFailed(DebugVisualizerEntry* debugVis, const StringImpl& evalString, const StringImpl& errors);
String GetArrayItems(DebugVisualizerEntry* debugVis, BfType* valueType, BfTypedValue& curNode, int& count, String* outContinuationData);
String GetLinkedListItems(DebugVisualizerEntry* debugVis, addr_ce endNodePtr, BfType* valueType, BfTypedValue& curNode, int& count, String* outContinuationData);
String GetDictionaryItems(DebugVisualizerEntry* debugVis, BfTypedValue dictValue, int bucketIdx, int nodeIdx, int& count, String* outContinuationData);
String GetTreeItems(DebugVisualizerEntry* debugVis, Array<addr_ce>& parentList, BfType*& valueType, BfTypedValue& curNode, int count, String* outContinuationData);
bool EvalCondition(DebugVisualizerEntry* debugVis, BfTypedValue typedVal, CeFormatInfo& formatInfo, const StringImpl& condition, const Array<String>& dbgVisWildcardCaptures, String& errorStr);
CeTypedValue GetAddr(BfConstant* constant);
CeTypedValue GetAddr(const BfTypedValue typeVal);
String ReadString(BfTypeCode charType, intptr addr, intptr maxLength, CeFormatInfo& formatInfo);
void ProcessEvalString(BfTypedValue useTypedValue, String& evalStr, String& displayString, CeFormatInfo& formatInfo, DebugVisualizerEntry* debugVis, bool limitLength);
String TypedValueToString(const BfTypedValue& typedValue, const StringImpl& expr, CeFormatInfo& formatFlags, bool fullPrecision = false);
void HandleCustomExpandedItems(String& retVal, DebugVisualizerEntry* debugVis, BfTypedValue typedValue, addr_ce addr, addr_ce addrInst, Array<String>& dbgVisWildcardCaptures, CeFormatInfo& formatInfo);
void ClearBreakpointCache();
void UpdateBreakpointCache();
void UpdateBreakpointFrames();
void UpdateBreakpointAddrs();
void UpdateBreakpoints(CeFunction* ceFunction);
void Continue();
CeDbgTypeInfo* GetDbgTypeInfo(int typeId);
CeDbgTypeInfo* GetDbgTypeInfo(BfIRType irType);
int64 ValueToInt(const BfTypedValue& typedVal);
BfType* FindType(const StringImpl& name);
public:
CeDebugger(DebugManager* debugManager, BfCompiler* bfCompiler);
~CeDebugger();
virtual void OutputMessage(const StringImpl& msg) override;
virtual void OutputRawMessage(const StringImpl& msg) override;
virtual int GetAddrSize() override;
virtual bool CanOpen(const StringImpl& fileName, DebuggerResult* outResult) override;
virtual void OpenFile(const StringImpl& launchPath, const StringImpl& targetPath, const StringImpl& args, const StringImpl& workingDir, const Array<uint8>& envBlock, bool hotSwapEnabled) override;
virtual bool Attach(int processId, BfDbgAttachFlags attachFlags) override;
virtual void Run() override;
virtual void HotLoad(const Array<String>& objectFiles, int hotIdx) override;
virtual void InitiateHotResolve(DbgHotResolveFlags flags) override;
virtual intptr GetDbgAllocHeapSize() override;
virtual String GetDbgAllocInfo() override;
virtual void Update() override;
virtual void ContinueDebugEvent() override;
virtual void ForegroundTarget() override;
virtual Breakpoint* CreateBreakpoint(const StringImpl& fileName, int lineNum, int wantColumn, int instrOffset) override;
virtual Breakpoint* CreateMemoryBreakpoint(intptr addr, int byteCount) override;
virtual Breakpoint* CreateSymbolBreakpoint(const StringImpl& symbolName) override;
virtual Breakpoint* CreateAddressBreakpoint(intptr address) override;
virtual uintptr GetBreakpointAddr(Breakpoint* breakpoint) override;
virtual void CheckBreakpoint(Breakpoint* breakpoint) override;
virtual void HotBindBreakpoint(Breakpoint* wdBreakpoint, int lineNum, int hotIdx) override;
virtual void DeleteBreakpoint(Breakpoint* wdBreakpoint) override;
virtual void DetachBreakpoint(Breakpoint* wdBreakpoint) override;
virtual void MoveBreakpoint(Breakpoint* wdBreakpoint, int lineNum, int wantColumn, bool rebindNow) override;
virtual void MoveMemoryBreakpoint(Breakpoint* wdBreakpoint, intptr addr, int byteCount) override;
virtual void DisableBreakpoint(Breakpoint* wdBreakpoint) override;
virtual void SetBreakpointCondition(Breakpoint* wdBreakpoint, const StringImpl& condition) override;
virtual void SetBreakpointLogging(Breakpoint* wdBreakpoint, const StringImpl& logging, bool breakAfterLogging) override;
virtual Breakpoint* FindBreakpointAt(intptr address) override;
virtual Breakpoint* GetActiveBreakpoint() override;
virtual void BreakAll() override;
virtual bool TryRunContinue() override;
virtual void StepInto(bool inAssembly) override;
virtual void StepIntoSpecific(intptr addr) override;
virtual void StepOver(bool inAssembly) override;
virtual void StepOut(bool inAssembly) override;
virtual void SetNextStatement(bool inAssembly, const StringImpl& fileName, int64 lineNumOrAsmAddr, int wantColumn) override;
//virtual DbgTypedValue GetRegister(const StringImpl& regName, CPURegisters* registers, Array<RegForm>* regForms = NULL) override;
virtual String Evaluate(const StringImpl& expr, int callStackIdx, int cursorPos, int language, DwEvalExpressionFlags expressionFlags) override;
virtual String EvaluateContinue() override;
virtual void EvaluateContinueKeep() override;
virtual String EvaluateToAddress(const StringImpl& expr, int callStackIdx, int cursorPos) override;
virtual String EvaluateAtAddress(const StringImpl& expr, intptr atAddr, int cursorPos) override;
virtual String GetCollectionContinuation(const StringImpl& continuationData, int callStackIdx, int count) override;
virtual String GetAutoExpressions(int callStackIdx, uint64 memoryRangeStart, uint64 memoryRangeLen) override;
virtual String GetAutoLocals(int callStackIdx, bool showRegs) override;
virtual String CompactChildExpression(const StringImpl& expr, const StringImpl& parentExpr, int callStackIdx) override;
virtual String GetProcessInfo() override;
virtual String GetThreadInfo() override;
virtual void SetActiveThread(int threadId) override;
virtual int GetActiveThread() override;
virtual void FreezeThread(int threadId) override;
virtual void ThawThread(int threadId) override;
virtual bool IsActiveThreadWaiting() override;
virtual void ClearCallStack() override;
virtual void UpdateCallStack(bool slowEarlyOut = true) override;
virtual int GetCallStackCount() override;
virtual int GetRequestedStackFrameIdx() override;
virtual int GetBreakStackFrameIdx() override;
virtual bool ReadMemory(intptr address, uint64 length, void* dest, bool local = false) override;
virtual bool WriteMemory(intptr address, void* src, uint64 length) override;
virtual DbgMemoryFlags GetMemoryFlags(intptr address) override;
virtual void UpdateRegisterUsage(int stackFrameIdx) override;
virtual void UpdateCallStackMethod(int stackFrameIdx) override;
virtual void GetCodeAddrInfo(intptr addr, String* outFile, int* outHotIdx, int* outDefLineStart, int* outDefLineEnd, int* outLine, int* outColumn) override;
virtual void GetStackAllocInfo(intptr addr, int* outThreadId, int* outStackIdx) override;
virtual String GetStackFrameInfo(int stackFrameIdx, intptr* addr, String* outFile, int32* outHotIdx, int32* outDefLineStart, int32* outDefLineEnd, int32* outLine, int32* outColumn, int32* outLanguage, int32* outStackSize, int8* outFlags) override;
virtual String Callstack_GetStackFrameOldFileInfo(int stackFrameIdx) override;
virtual int GetJmpState(int stackFrameIdx) override;
virtual intptr GetStackFrameCalleeAddr(int stackFrameIdx) override;
virtual String GetStackMethodOwner(int stackFrameIdx, int& language) override;
virtual String FindCodeAddresses(const StringImpl& fileName, int line, int column, bool allowAutoResolve) override;
virtual String GetAddressSourceLocation(intptr address) override;
virtual String GetAddressSymbolName(intptr address, bool demangle) override;
virtual String DisassembleAtRaw(intptr address) override;
virtual String DisassembleAt(intptr address) override;
virtual String FindLineCallAddresses(intptr address) override;
virtual String GetCurrentException() override;
virtual String GetModulesInfo() override;
virtual void SetAliasPath(const StringImpl& origPath, const StringImpl& localPath) override;
virtual void CancelSymSrv() override;
virtual bool HasPendingDebugLoads() override;
virtual int LoadImageForModule(const StringImpl& moduleName, const StringImpl& debugFileName) override;
virtual int LoadDebugInfoForModule(const StringImpl& moduleName) override;
virtual int LoadDebugInfoForModule(const StringImpl& moduleName, const StringImpl& debugFileName) override;
virtual void StopDebugging() override;
virtual void Terminate() override;
virtual void Detach() override;
virtual Profiler* StartProfiling() override;
virtual Profiler* PopProfiler() override; // Profiler requested by target program
virtual void ReportMemory(MemReporter* memReporter) override;
virtual bool IsOnDemandDebugger() override;
};
NS_BF_END

749
IDEHelper/Compiler/CeMachine.cpp
View file

File diff suppressed because it is too large Load diff

210
IDEHelper/Compiler/CeMachine.h
View file

@ -24,6 +24,8 @@ class BeSwitchInst;
class BeGlobalVariable; class BeGlobalVariable;
class CeMachine; class CeMachine;
class CeFunction; class CeFunction;
class CeDebugger;
class CeBreakpoint;
#define CEOP_SIZED(OPNAME) \ #define CEOP_SIZED(OPNAME) \
CeOp_##OPNAME##_8, \ CeOp_##OPNAME##_8, \
@ -69,6 +71,7 @@ enum CeErrorKind
enum CeOp : int16 enum CeOp : int16
{ {
CeOp_InvalidOp, CeOp_InvalidOp,
CeOp_DbgBreak,
CeOp_Ret, CeOp_Ret,
CeOp_SetRetType, CeOp_SetRetType,
CeOp_Jmp, CeOp_Jmp,
@ -204,10 +207,55 @@ enum CeOp : int16
CeOp_COUNT CeOp_COUNT
}; };
enum CeOperandKind
{
CeOperandKind_None,
CeOperandKind_FrameOfs,
CeOperandKind_AllocaAddr,
CeOperandKind_Block,
CeOperandKind_Immediate,
CeOperandKind_ConstStructTableIdx,
CeOperandKind_CallTableIdx
};
class CeOperand
{
public:
CeOperandKind mKind;
union
{
int mFrameOfs;
int mBlockIdx;
int mImmediate;
int mCallTableIdx;
int mStructTableIdx;
BeConstant* mConstant;
};
BeType* mType;
public:
CeOperand()
{
mKind = CeOperandKind_None;
mFrameOfs = 0;
mType = NULL;
}
operator bool() const
{
return mKind != CeOperandKind_None;
}
bool IsImmediate()
{
return mKind == CeOperandKind_Immediate;
}
};
struct CeEmitEntry struct CeEmitEntry
{ {
int mCodePos; int mCodePos;
int mFile; int mScope;
int mLine; int mLine;
int mColumn; int mColumn;
}; };
@ -490,6 +538,40 @@ public:
} }
}; };
class CeDbgVariable
{
public:
String mName;
CeOperand mValue;
BfType* mType;
};
class CeDbgFunctionInfo
{
public:
Array<CeDbgVariable> mVariables;
};
class CeBreakpointBind
{
public:
CeOp mPrevOpCode;
CeBreakpoint* mBreakpoint;
};
struct CeDbgScope
{
public:
String mFilePath;
int mInlinedAt;
public:
CeDbgScope()
{
mInlinedAt = -1;
}
};
class CeFunction class CeFunction
{ {
public: public:
@ -511,7 +593,7 @@ public:
bool mFailed; bool mFailed;
bool mIsVarReturn; bool mIsVarReturn;
Array<uint8> mCode; Array<uint8> mCode;
Array<String> mFiles; Array<CeDbgScope> mDbgScopes;
Array<CeEmitEntry> mEmitTable; Array<CeEmitEntry> mEmitTable;
Array<CeCallEntry> mCallTable; Array<CeCallEntry> mCallTable;
Array<CeStringEntry> mStringTable; Array<CeStringEntry> mStringTable;
@ -519,10 +601,13 @@ public:
Array<CeStaticFieldEntry> mStaticFieldTable; Array<CeStaticFieldEntry> mStaticFieldTable;
Array<BfType*> mTypeTable; Array<BfType*> mTypeTable;
Array<CeFunction*> mInnerFunctions; Array<CeFunction*> mInnerFunctions;
Dictionary<int, CeBreakpointBind> mBreakpoints;
String mGenError; String mGenError;
int mFrameSize; int mFrameSize;
int mMaxReturnSize; int mMaxReturnSize;
int mId; int mId;
int mBreakpointVersion;
CeDbgFunctionInfo* mDbgInfo;
public: public:
CeFunction() CeFunction()
@ -537,11 +622,15 @@ public:
mIsVarReturn = false; mIsVarReturn = false;
mFrameSize = 0; mFrameSize = 0;
mMaxReturnSize = 0; mMaxReturnSize = 0;
mBreakpointVersion = 0;
mId = -1; mId = -1;
mDbgInfo = NULL;
} }
~CeFunction(); ~CeFunction();
void Print(); void Print();
void UnbindBreakpoints();
CeEmitEntry* FindEmitEntry(int loc, int* entryIdx = NULL);
}; };
enum CeEvalFlags enum CeEvalFlags
@ -551,52 +640,8 @@ enum CeEvalFlags
CeEvalFlags_PersistantError = 2, CeEvalFlags_PersistantError = 2,
CeEvalFlags_DeferIfNotOnlyError = 4, CeEvalFlags_DeferIfNotOnlyError = 4,
CeEvalFlags_NoRebuild = 8, CeEvalFlags_NoRebuild = 8,
CeEvalFlags_ForceReturnThis = 0x10 CeEvalFlags_ForceReturnThis = 0x10,
}; CeEvalFlags_DbgCall = 0x20
enum CeOperandKind
{
CeOperandKind_None,
CeOperandKind_FrameOfs,
CeOperandKind_AllocaAddr,
CeOperandKind_Block,
CeOperandKind_Immediate,
CeOperandKind_ConstStructTableIdx,
CeOperandKind_CallTableIdx
};
class CeOperand
{
public:
CeOperandKind mKind;
union
{
int mFrameOfs;
int mBlockIdx;
int mImmediate;
int mCallTableIdx;
int mStructTableIdx;
BeConstant* mConstant;
};
BeType* mType;
public:
CeOperand()
{
mKind = CeOperandKind_None;
mFrameOfs = 0;
mType = NULL;
}
operator bool() const
{
return mKind != CeOperandKind_None;
}
bool IsImmediate()
{
return mKind == CeOperandKind_Immediate;
}
}; };
#define BF_CE_DEFAULT_STACK_SIZE 4*1024*1024 #define BF_CE_DEFAULT_STACK_SIZE 4*1024*1024
@ -609,7 +654,21 @@ public:
enum CeOperandInfoKind enum CeOperandInfoKind
{ {
CEOI_None, CEOI_None,
CEOI_None8 = CEOI_None,
CEOI_None16 = CEOI_None,
CEOI_None32 = CEOI_None,
CEOI_None64 = CEOI_None,
CEOI_NoneF32 = CEOI_None,
CEOI_NoneF64 = CEOI_None,
CEOI_FrameRef, CEOI_FrameRef,
CEOI_FrameRef8,
CEOI_FrameRef16,
CEOI_FrameRef32,
CEOI_FrameRef64,
CEOI_FrameRefF32,
CEOI_FrameRefF64,
CEOI_IMM8, CEOI_IMM8,
CEOI_IMM16, CEOI_IMM16,
CEOI_IMM32, CEOI_IMM32,
@ -631,18 +690,24 @@ enum CeSizeClass
class CeDumpContext class CeDumpContext
{ {
public: public:
Dictionary<int, CeDbgVariable*> mVarMap;
CeFunction* mCeFunction; CeFunction* mCeFunction;
String mStr; String mStr;
uint8* mStart; uint8* mStart;
uint8* mPtr; uint8* mPtr;
uint8* mEnd; uint8* mEnd;
int mJmp;
public: public:
CeDumpContext()
{
mJmp = -1;
}
void DumpOperandInfo(CeOperandInfoKind operandInfoKind); void DumpOperandInfo(CeOperandInfoKind operandInfoKind);
void Next();
void Dump(); void Dump();
}; };
@ -760,6 +825,11 @@ public:
mInstPtr = NULL; mInstPtr = NULL;
mReturnType = NULL; mReturnType = NULL;
} }
int GetInstIdx()
{
return (int)(mInstPtr - &mFunction->mCode[0] - 2);
}
}; };
class CeStaticFieldInfo class CeStaticFieldInfo
@ -909,6 +979,7 @@ public:
BfType* GetBfType(BfIRType irType); BfType* GetBfType(BfIRType irType);
void PrepareConstStructEntry(CeConstStructData& constStructData); void PrepareConstStructEntry(CeConstStructData& constStructData);
bool CheckMemory(addr_ce addr, int32 size); bool CheckMemory(addr_ce addr, int32 size);
uint8* GetMemoryPtr(addr_ce addr, int32 size);
bool GetStringFromAddr(addr_ce strInstAddr, StringImpl& str); bool GetStringFromAddr(addr_ce strInstAddr, StringImpl& str);
bool GetStringFromStringView(addr_ce addr, StringImpl& str); bool GetStringFromStringView(addr_ce addr, StringImpl& str);
bool GetCustomAttribute(BfModule* module, BfIRConstHolder* constHolder, BfCustomAttributes* customAttributes, int attributeIdx, addr_ce resultAddr); bool GetCustomAttribute(BfModule* module, BfIRConstHolder* constHolder, BfCustomAttributes* customAttributes, int attributeIdx, addr_ce resultAddr);
@ -928,12 +999,40 @@ struct CeTypeInfo
int mRevision; int mRevision;
}; };
class CeStepState
{
public:
enum Kind
{
Kind_None,
Kind_StepOver,
Kind_StepOver_Asm,
Kind_StepInfo,
Kind_StepInfo_Asm,
Kind_StepOut,
Kind_StepOut_Asm,
Kind_Jmp
};
Kind mKind;
int mNextInstIdx;
int mStartDepth;
public:
CeStepState()
{
mKind = Kind_None;
mNextInstIdx = -1;
mStartDepth = 0;
}
};
class CeMachine class CeMachine
{ {
public: public:
Dictionary<BfMethodInstance*, CeFunctionInfo*> mFunctions; Dictionary<BfMethodInstance*, CeFunctionInfo*> mFunctions;
Dictionary<String, CeFunctionInfo*> mNamedFunctionMap; Dictionary<String, CeFunctionInfo*> mNamedFunctionMap;
Dictionary<int, CeFunction*> mFunctionIdMap; // Only used for 32-bit Dictionary<int, CeFunction*> mFunctionIdMap; // Only used for 32-bit and debugging
Dictionary<BfType*, CeTypeInfo> mTypeInfoMap; Dictionary<BfType*, CeTypeInfo> mTypeInfoMap;
HashSet<BfMethodInstance*> mMethodInstanceSet; HashSet<BfMethodInstance*> mMethodInstanceSet;
HashSet<BfFieldInstance*> mFieldInstanceSet; HashSet<BfFieldInstance*> mFieldInstanceSet;
@ -959,6 +1058,14 @@ public:
BfReducer* mTempReducer; BfReducer* mTempReducer;
BfPassInstance* mTempPassInstance; BfPassInstance* mTempPassInstance;
CritSect mCritSect;
SyncEvent mDebugEvent;
CeStepState mStepState;
CeDebugger* mDebugger;
bool mDbgPaused;
bool mSpecialCheck;
bool mDbgWantBreak;
public: public:
CeMachine(BfCompiler* compiler); CeMachine(BfCompiler* compiler);
~CeMachine(); ~CeMachine();
@ -967,6 +1074,7 @@ public:
BeContext* GetBeContext(); BeContext* GetBeContext();
BeModule* GetBeModule(); BeModule* GetBeModule();
int GetInstSize(CeFunction* ceFunction, int instIdx);
void DerefMethodInfo(CeFunctionInfo* ceFunctionInfo); void DerefMethodInfo(CeFunctionInfo* ceFunctionInfo);
void RemoveFunc(CeFunction* ceFunction); void RemoveFunc(CeFunction* ceFunction);
void RemoveMethod(BfMethodInstance* methodInstance); void RemoveMethod(BfMethodInstance* methodInstance);

43
IDEHelper/DbgExprEvaluator.h
View file

@ -184,6 +184,49 @@ public:
} }
}; };
struct DwFormatInfo
{
int mCallStackIdx;
bool mHidePointers;
bool mIgnoreDerivedClassInfo;
bool mNoVisualizers;
bool mNoMembers;
bool mRawString;
bool mNoEdit;
DbgTypeKindFlags mTypeKindFlags;
intptr mArrayLength;
intptr mOverrideCount;
intptr mMaxCount;
DwDisplayType mDisplayType;
DbgTypedValue mExplicitThis;
int mTotalSummaryLength;
String mReferenceId;
String mSubjectExpr;
String mExpectedType;
String mNamespaceSearch;
int mExpandItemDepth;
DbgLanguage mLanguage;
DwFormatInfo()
{
mCallStackIdx = -1;
mHidePointers = false;
mIgnoreDerivedClassInfo = false;
mRawString = false;
mNoVisualizers = false;
mNoMembers = false;
mNoEdit = false;
mTypeKindFlags = DbgTypeKindFlag_None;
mArrayLength = -1;
mOverrideCount = -1;
mMaxCount = -1;
mTotalSummaryLength = 0;
mDisplayType = DwDisplayType_NotSpecified;
mExpandItemDepth = 0;
mLanguage = DbgLanguage_Unknown;
}
};
struct DbgMethodArgument struct DbgMethodArgument
{ {
DbgTypedValue mTypedValue; DbgTypedValue mTypedValue;

15
IDEHelper/DebugManager.cpp
View file

@ -11,6 +11,7 @@
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "BeefySysLib/util/BeefPerf.h" #include "BeefySysLib/util/BeefPerf.h"
#include "NetManager.h" #include "NetManager.h"
#include "Compiler/CeDebugger.h"
#ifdef BF_PLATFORM_WINDOWS #ifdef BF_PLATFORM_WINDOWS
#include "DbgMiniDump.h" #include "DbgMiniDump.h"
@ -97,6 +98,12 @@ DebugManager::DebugManager()
DebugManager::~DebugManager() DebugManager::~DebugManager()
{ {
if ((gDebugger != NULL) && (gDebugger->IsOnDemandDebugger()))
{
delete gDebugger;
gDebugger = NULL;
}
delete mNetManager; delete mNetManager;
delete mDebugger64; delete mDebugger64;
delete mDebugger32; delete mDebugger32;
@ -779,6 +786,12 @@ BF_EXPORT bool BF_CALLTYPE Debugger_OpenFile(const char* launchPath, const char*
return true; return true;
} }
BF_EXPORT bool BF_CALLTYPE Debugger_ComptimeAttach(void* bfCompiler)
{
gDebugger = new CeDebugger(gDebugManager, (BfCompiler*)bfCompiler);
return true;
}
BF_EXPORT void BF_CALLTYPE Debugger_SetSymSrvOptions(const char* symCacheDir, const char* symSrvStr, int flags) BF_EXPORT void BF_CALLTYPE Debugger_SetSymSrvOptions(const char* symCacheDir, const char* symSrvStr, int flags)
{ {
Array<String> symServers; Array<String> symServers;
@ -1021,7 +1034,7 @@ BF_EXPORT uintptr BF_CALLTYPE Breakpoint_GetAddress(Breakpoint* wdBreakpoint, Br
{ {
if (outLinkedSibling != NULL) if (outLinkedSibling != NULL)
*outLinkedSibling = wdBreakpoint->mLinkedSibling; *outLinkedSibling = wdBreakpoint->mLinkedSibling;
return wdBreakpoint->GetAddr(); return gDebugger->GetBreakpointAddr(wdBreakpoint);
} }
BF_EXPORT bool BF_CALLTYPE Breakpoint_IsMemoryBreakpointBound(Breakpoint* wdBreakpoint) BF_EXPORT bool BF_CALLTYPE Breakpoint_IsMemoryBreakpointBound(Breakpoint* wdBreakpoint)

8
IDEHelper/Debugger.h
View file

@ -62,6 +62,13 @@ public:
virtual bool IsMemoryBreakpointBound() = 0; virtual bool IsMemoryBreakpointBound() = 0;
}; };
enum DbgTypeKindFlags
{
DbgTypeKindFlag_None = 0,
DbgTypeKindFlag_Int = 1
};
enum DwDisplayType : int8 enum DwDisplayType : int8
{ {
DwDisplayType_NotSpecified, DwDisplayType_NotSpecified,
@ -282,6 +289,7 @@ public:
virtual void SetBreakpointLogging(Breakpoint* wdBreakpoint, const StringImpl& logging, bool breakAfterLogging) = 0; virtual void SetBreakpointLogging(Breakpoint* wdBreakpoint, const StringImpl& logging, bool breakAfterLogging) = 0;
virtual Breakpoint* FindBreakpointAt(intptr address) = 0; virtual Breakpoint* FindBreakpointAt(intptr address) = 0;
virtual Breakpoint* GetActiveBreakpoint() = 0; virtual Breakpoint* GetActiveBreakpoint() = 0;
virtual uintptr GetBreakpointAddr(Breakpoint* breakpoint) { return breakpoint->GetAddr(); }
virtual void BreakAll() = 0; virtual void BreakAll() = 0;
virtual bool TryRunContinue() = 0; virtual bool TryRunContinue() = 0;
virtual void StepInto(bool inAssembly) = 0; virtual void StepInto(bool inAssembly) = 0;

2
IDEHelper/IDEHelper.vcxproj
View file

@ -331,6 +331,7 @@
<ClCompile Include="Compiler\BfTargetTriple.cpp" /> <ClCompile Include="Compiler\BfTargetTriple.cpp" />
<ClCompile Include="Compiler\BfUtil.cpp" /> <ClCompile Include="Compiler\BfUtil.cpp" />
<ClCompile Include="Compiler\BfVarDeclChecker.cpp" /> <ClCompile Include="Compiler\BfVarDeclChecker.cpp" />
<ClCompile Include="Compiler\CeDebugger.cpp" />
<ClCompile Include="Compiler\CeMachine.cpp" /> <ClCompile Include="Compiler\CeMachine.cpp" />
<ClCompile Include="Compiler\MemReporter.cpp" /> <ClCompile Include="Compiler\MemReporter.cpp" />
<ClCompile Include="DbgMiniDump.cpp" /> <ClCompile Include="DbgMiniDump.cpp" />
@ -399,6 +400,7 @@
<ClInclude Include="Compiler\BfCompiler.h" /> <ClInclude Include="Compiler\BfCompiler.h" />
<ClInclude Include="Compiler\BfUtil.h" /> <ClInclude Include="Compiler\BfUtil.h" />
<ClInclude Include="Compiler\BfVarDeclChecker.h" /> <ClInclude Include="Compiler\BfVarDeclChecker.h" />
<ClInclude Include="Compiler\CeDebugger.h" />
<ClInclude Include="Compiler\CeMachine.h" /> <ClInclude Include="Compiler\CeMachine.h" />
<ClInclude Include="third_party\FtsFuzzyMatch.h" /> <ClInclude Include="third_party\FtsFuzzyMatch.h" />
<ClInclude Include="Compiler\MemReporter.h" /> <ClInclude Include="Compiler\MemReporter.h" />

6
IDEHelper/IDEHelper.vcxproj.filters
View file

@ -214,6 +214,9 @@
<ClCompile Include="Compiler\CeMachine.cpp"> <ClCompile Include="Compiler\CeMachine.cpp">
<Filter>Compiler</Filter> <Filter>Compiler</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="Compiler\CeDebugger.cpp">
<Filter>Compiler</Filter>
</ClCompile>
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClInclude Include="Compiler\BfAst.h"> <ClInclude Include="Compiler\BfAst.h">
@ -405,5 +408,8 @@
<ClInclude Include="third_party\FtsFuzzyMatch.h"> <ClInclude Include="third_party\FtsFuzzyMatch.h">
<Filter>third_party</Filter> <Filter>third_party</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="Compiler\CeDebugger.h">
<Filter>Compiler</Filter>
</ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>

1
IDEHelper/WinDebugger.cpp
View file

@ -11026,6 +11026,7 @@ String WinDebugger::GetStackFrameInfo(int stackFrameIdx, intptr* addr, String* o
FrameFlags_HasPendingDebugInfo = 2, FrameFlags_HasPendingDebugInfo = 2,
FrameFlags_CanGetOldSource = 4, FrameFlags_CanGetOldSource = 4,
FrameFlags_WasHotReplaced = 8, FrameFlags_WasHotReplaced = 8,
FrameFlags_HadError = 0x10
}; };
AutoCrit autoCrit(mDebugManager->mCritSect); AutoCrit autoCrit(mDebugManager->mCritSect);

51
IDEHelper/WinDebugger.h
View file

@ -272,55 +272,6 @@ public:
} }
}; };
enum DbgTypeKindFlags
{
DbgTypeKindFlag_None = 0,
DbgTypeKindFlag_Int = 1
};
struct DwFormatInfo
{
int mCallStackIdx;
bool mHidePointers;
bool mIgnoreDerivedClassInfo;
bool mNoVisualizers;
bool mNoMembers;
bool mRawString;
bool mNoEdit;
DbgTypeKindFlags mTypeKindFlags;
intptr mArrayLength;
intptr mOverrideCount;
intptr mMaxCount;
DwDisplayType mDisplayType;
DbgTypedValue mExplicitThis;
int mTotalSummaryLength;
String mReferenceId;
String mSubjectExpr;
String mExpectedType;
String mNamespaceSearch;
int mExpandItemDepth;
DbgLanguage mLanguage;
DwFormatInfo()
{
mCallStackIdx = -1;
mHidePointers = false;
mIgnoreDerivedClassInfo = false;
mRawString = false;
mNoVisualizers = false;
mNoMembers = false;
mNoEdit = false;
mTypeKindFlags = DbgTypeKindFlag_None;
mArrayLength = -1;
mOverrideCount = -1;
mMaxCount = -1;
mTotalSummaryLength = 0;
mDisplayType = DwDisplayType_NotSpecified;
mExpandItemDepth = 0;
mLanguage = DbgLanguage_Unknown;
}
};
class DbgPendingExpr class DbgPendingExpr
{ {
public: public:
@ -411,6 +362,8 @@ public:
} }
}; };
struct DwFormatInfo;
class WinDebugger : public Debugger class WinDebugger : public Debugger
{ {
public: public: