Preallocate JIT notification table on VM side (since ICLRDataTarget2->AllocVirtual isn't implemented under lldb) and implement WriteVirtual on debugger side to allow DAC to write entries.
Used the special set breakpoint on exception throw lldb command to catch the special exception the VM throws when some
thing is jitted. The debugger side finds the exception record by searching for the RtlpRaiseException function on the stack
when the bp is hit. It also assumes that the local variable is called ExceptionRecord.
Fix all the file path separators to use the platform independent defines.
Ifdef all the "/d" options in the supported commands because the / char isn't supported as a command line option and /d is always the DML option that isn't supported either.
Fix problem Prem run into running sos after the process stops.
/* [in] */ ULONG32 request,
/* [optional][out] */ ULONG32 *done)
{
- return E_NOTIMPL;
+ if (g_ExtData == NULL)
+ {
+ return E_UNEXPECTED;
+ }
+ return g_ExtData->WriteVirtual(address, (PVOID)buffer, request, done);
}
HRESULT STDMETHODCALLTYPE
TADDR IP = 0;
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
CMDOption option[] =
{ // name, vptr, type, hasValue
{"-verify", &bVerify, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE}
+#endif
};
CMDValue arg[] =
{ // vptr, type
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
CMDOption option[] =
{ // name, vptr, type, hasValue
{"-MD", &bDumpMDTable, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE}
+#endif
};
CMDValue arg[] =
{ // vptr, type
{"-length", &flags.Length, COSIZE_T, TRUE},
{"-details", &flags.bDetail, COBOOL, FALSE},
{"-nofields", &flags.bNoFieldsForElement, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
{ // name, vptr, type, hasValue
{"-nofields", &bNoFields, COBOOL, FALSE},
{"-refs", &bRefs, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
{"-lines", &bLineNumbers, COBOOL, FALSE},
{"-l", &bLineNumbers, COBOOL, FALSE},
{"-ccw", &bCCW, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE}
+#endif
};
CMDValue arg[] =
{ // vptr, type
return Status;
}
-#ifndef FEATURE_PAL
-
/**********************************************************************\
* Routine Description: *
* *
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE}
+#endif
};
CMDValue arg[] =
{ // vptr, type
return PrintVC(p_MT, p_Object);
}
+#ifndef FEATURE_PAL
+
#ifdef FEATURE_COMINTEROP
DECLARE_API(DumpRCW)
{"-max", &mMaxSize, COHEX, TRUE}, // max size of objects to display
{"-live", &mLive, COHEX, FALSE}, // only print live objects
{"-dead", &mDead, COHEX, FALSE}, // only print dead objects
+#ifndef FEATURE_PAL
{"/d", &mDML, COBOOL, FALSE}, // Debugger Markup Language
+#endif
};
CMDValue arg[] =
CMDOption option[] =
{ // name, vptr, type, hasValue
{"-mt", &bMethodTables, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE}
+#endif
};
CMDValue arg[] =
{ // vptr, type
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
{ // name, vptr, type, hasValue
{"-special", &bPrintSpecialThreads, COBOOL, FALSE},
{"-live", &bPrintLiveThreadsOnly, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
if (!GetCMDOption(args, option, _countof(option), NULL, 0, NULL))
{
return Status;
} // WatsonBuckets()
+#endif // FEATURE_PAL
struct PendingBreakpoint
{
}
PendingBreakpoint *pNext;
- PendingBreakpoint() : pNext(NULL), ilOffset(0), lineNumber(0), methodToken(0)
+ PendingBreakpoint() : lineNumber(0), ilOffset(0), methodToken(0), pNext(NULL)
{
szModuleName[0] = L'\0';
szFunctionName[0] = L'\0';
wcscpy_s(wszNameBuffer, _countof(wszNameBuffer), W("UNKNOWN"));
}
+#ifndef FEATURE_PAL
sprintf_s(buffer, _countof(buffer), "bp %p", (void*) (size_t) addr);
+#else
+ sprintf_s(buffer, _countof(buffer), "breakpoint set --address 0x%p", (void*) (size_t) addr);
+#endif
ExtOut("Setting breakpoint: %s [%S]\n", buffer, wszNameBuffer);
- g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer ,0);
+ g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
if ( curLimit < MaxBPsCached )
alreadyPlacedBPs[curLimit++] = addr;
}
}
+#ifndef FEATURE_PAL
void SaveBreakpoints(FILE* pFile)
{
PendingBreakpoint *pCur = m_breakpoints;
pCur = pCur->pNext;
}
}
+#endif
void ClearBreakpoint(size_t breakPointToClear)
{
//get a pointer to just the filename (the portion after the last backslash)
WCHAR* pModuleFilename = wszNameBuffer;
- WCHAR* pSlash = wcschr(pModuleFilename, L'\\');
+ WCHAR* pSlash = wcschr(pModuleFilename, DIRECTORY_SEPARATOR_CHAR_W);
while(pSlash != NULL)
{
pModuleFilename = pSlash+1;
- pSlash = wcschr(pModuleFilename, L'\\');
+ pSlash = wcschr(pModuleFilename, DIRECTORY_SEPARATOR_CHAR_W);
}
ImageInfo ii;
DacpGetModuleAddress dgma;
if (SUCCEEDED(dgma.Request(pMod)))
{
-#ifndef FEATURE_PAL
g_bpoints.Update(TO_TADDR(dgma.ModulePtr), FALSE);
-#endif
}
else
{
DacpGetModuleAddress dgma;
if (SUCCEEDED(dgma.Request(mod)))
{
-#ifndef FEATURE_PAL
g_bpoints.Update(TO_TADDR(dgma.ModulePtr), TRUE);
-#endif
}
if(!g_fAllowJitOptimization)
DacpGetModuleAddress dgma;
if (SUCCEEDED(dgma.Request(mod)))
{
-#ifndef FEATURE_PAL
g_bpoints.RemovePendingForModule(TO_TADDR(dgma.ModulePtr));
-#endif
}
m_dbgStatus = DEBUG_STATUS_GO_HANDLED;
{
ULONG Type, ProcessId, ThreadId;
ULONG ExtraInformationUsed;
- HRESULT Status = g_ExtControl->GetLastEventInformation( &Type,
- &ProcessId,
- &ThreadId,
- pdle,
- sizeof(DEBUG_LAST_EVENT_INFO_EXCEPTION),
- &ExtraInformationUsed,
- NULL,
- 0,
- NULL);
+ HRESULT Status = g_ExtControl->GetLastEventInformation(
+ &Type,
+ &ProcessId,
+ &ThreadId,
+ pdle,
+ sizeof(DEBUG_LAST_EVENT_INFO_EXCEPTION),
+ &ExtraInformationUsed,
+ NULL,
+ 0,
+ NULL);
if (Status != S_OK || Type != DEBUG_EVENT_EXCEPTION)
{
}
return TRUE;
- }
+}
HRESULT HandleCLRNotificationEvent()
{
- HRESULT Status = E_FAIL;
/*
* Did we get module load notification? If so, check if any in our pending list
* need to be registered for jit notification.
if (!CheckCLRNotificationEvent(&dle))
{
ExtOut("Expecting first chance CLRN exception\n");
- return Status;
+ return E_FAIL;
}
// Notification only needs to live for the lifetime of the call below, so it's a non-static
// local.
- if (g_clrData->TranslateExceptionRecordToNotification(&dle.ExceptionRecord, &Notification) != S_OK)
+ HRESULT Status = g_clrData->TranslateExceptionRecordToNotification(&dle.ExceptionRecord, &Notification);
+ if (Status != S_OK)
{
ExtOut("Error processing exception notification\n");
return Status;
case DEBUG_STATUS_GO:
case DEBUG_STATUS_GO_HANDLED:
case DEBUG_STATUS_GO_NOT_HANDLED:
+#ifndef FEATURE_PAL
g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, "g", 0);
+#else
+ g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, "process continue", 0);
+#endif
break;
default:
break;
}
}
- return Status;
+ return S_OK;
}
-
DECLARE_API(HandleCLRN)
{
INIT_API();
return HandleCLRNotificationEvent();
}
-#ifndef FEATURE_PAL
DECLARE_API(bpmd)
{
INIT_API_NOEE();
}
else if (MethodDescData.bIsDynamic)
{
+#ifndef FEATURE_PAL
// Dynamic methods don't have JIT notifications. This is something we must
// fix in the next release. Until then, you have a cumbersome user experience.
ExtOut("This DynamicMethodDesc is not yet JITTED. Placing memory breakpoint at %p\n",
(void*) (size_t) MethodDescData.AddressOfNativeCodeSlot,
(void*) (size_t) MethodDescData.AddressOfNativeCodeSlot);
- Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer ,0);
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
if (FAILED(Status))
{
ExtOut("Unable to set breakpoint with IDebugControl::Execute: %x\n",Status);
ExtOut("Attempted to run: %s\n", buffer);
}
+#else
+ ExtErr("This DynamicMethodDesc is not yet JITTED %p\n", MethodDescData.AddressOfNativeCodeSlot);
+#endif // FEATURE_PAL
}
else
{
if (bNeedNotificationExceptions)
{
ExtOut("Adding pending breakpoints...\n");
+#ifndef FEATURE_PAL
sprintf_s(buffer, _countof(buffer), "sxe -c \"!HandleCLRN\" clrn");
- Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer ,0);
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
+#else
+ sprintf_s(buffer, _countof(buffer), "breakpoint set -E c++ -h false -w true");
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
+ if (Status == S_OK)
+ {
+ sprintf_s(buffer, _countof(buffer), "breakpoint command add -o \"sos HandleCLRN\"");
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
+ }
+#endif // FEATURE_PAL
}
return Status;
}
-#endif
+
+#ifndef FEATURE_PAL
/**********************************************************************\
* Routine Description: *
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
FileNameForModule(dwAddr, FileName);
// We'd like a short form for this output
- LPWSTR pszFilename = wcsrchr (FileName, L'\\');
+ LPWSTR pszFilename = wcsrchr (FileName, DIRECTORY_SEPARATOR_CHAR_W);
if (pszFilename == NULL)
{
pszFilename = FileName;
CMDOption option[] =
{ // name, vptr, type, hasValue
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
FileNameForModule (dwAddr, FileName);
// We'd like a short form for this output
- LPWSTR pszFilename = wcsrchr (FileName, L'\\');
+ LPWSTR pszFilename = wcsrchr (FileName, DIRECTORY_SEPARATOR_CHAR_W);
if (pszFilename == NULL)
{
pszFilename = FileName;
sprintf_s(buffer,_countof (buffer),
"r$t%d=%x",
preg, codeType);
- Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer ,0);
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
if (FAILED(Status))
{
ExtOut("Error setting register $t%d\n", preg);
sprintf_s(buffer,_countof (buffer),
"r$t%d=0",
preg);
- Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer ,0);
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
if (FAILED(Status))
{
ExtOut("Error initialized register $t%d to zero\n", preg);
EXCEPTION_COMPLUS
);
- Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer ,0);
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
if (FAILED(Status))
{
ExtOut("Error setting breakpoint: %s\n", buffer);
sprintf_s(buffer,_countof (buffer),
"r$t%d=1",
preg);
- Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer ,0);
+ Status = g_ExtControl->Execute(DEBUG_EXECUTE_NOT_LOGGED, buffer, 0);
if (FAILED(Status))
{
ExtOut("Failed to execute the following command: %s\n", buffer);
{"-n", &bSuppressLines, COBOOL, FALSE},
{"-i", &bICorDebug, COBOOL, FALSE},
{"-gc", &bGC, COBOOL, FALSE},
+#ifndef FEATURE_PAL
{"/d", &dml, COBOOL, FALSE},
+#endif
};
CMDValue arg[] =
{ // vptr, type
if (len == 0 || len == cFqPath)
return FALSE;
- WCHAR *pLastSep = wcsrchr(fqPath, L'\\');
+ WCHAR *pLastSep = wcsrchr(fqPath, DIRECTORY_SEPARATOR_CHAR_W);
if (pLastSep == NULL || pLastSep+1 >= fqPath+cFqPath)
return FALSE;
const char *ptr2 = str2 + strlen(str2)-1;
while (ptr2 >= str2)
{
+#ifndef FEATURE_PAL
if (tolower(*ptr1) != tolower(*ptr2))
+#else
+ if (*ptr1 != *ptr2)
+#endif
+ {
return FALSE;
- ptr2 --;
- ptr1 --;
+ }
+ ptr2--;
+ ptr1--;
}
- if (ptr1 >= str1 && *ptr1 != '\\' && *ptr1 != ':')
+ if (ptr1 >= str1 && *ptr1 != DIRECTORY_SEPARATOR_CHAR_A && *ptr1 != ':')
+ {
return FALSE;
+ }
return TRUE;
}
return FALSE;
}
+#ifndef FEATURE_PAL
if (tolower(*fusionName) != tolower(*mName))
+#else
+ if (*fusionName != *mName)
+#endif
{
return FALSE;
}
{
CHAR ModuleName[MAX_PATH+1];
- if (g_ExtSymbols->GetModuleNames (Index, base,
- NULL, 0, NULL,
- ModuleName, MAX_PATH, NULL,
- NULL, 0, NULL) == S_OK)
+ if (g_ExtSymbols->GetModuleNames(Index, base, NULL, 0, NULL, ModuleName,
+ MAX_PATH, NULL, NULL, 0, NULL) == S_OK)
{
+#ifndef FEATURE_PAL
if (_stricmp (ModuleName, mName) == 0)
+#else
+ if (strcmp (ModuleName, mName) == 0)
+#endif
{
return TRUE;
}
fileName[m] = '\0';
if ((mName == NULL) ||
- IsSameModuleName (fileName, mName) ||
+ IsSameModuleName(fileName, mName) ||
DebuggerModuleNamesMatch(ModuleData.File, mName) ||
- IsFusionLoadedModule (fileName, mName))
+ IsFusionLoadedModule(fileName, mName))
{
AddToModuleList(moduleList, *numModule, maxList,
(DWORD_PTR)ModuleAddr);
}
else
{
+#ifndef FEATURE_PAL
if (IsDMLEnabled())
DMLOut("Not JITTED yet. Use <exec cmd=\"!bpmd -md %p\">!bpmd -md %p</exec> to break on run.\n",
- SOS_PTR(md), SOS_PTR(md));
+ SOS_PTR(md), SOS_PTR(md));
else
ExtOut("Not JITTED yet. Use !bpmd -md %p to break on run.\n", SOS_PTR(md));
+#else
+ ExtOut("Not JITTED yet. Use 'sos bpmd -md %p' to break on run.\n", SOS_PTR(md));
+#endif
}
}
else
}
}
+#ifndef FEATURE_PAL
if (ptr[0] != '-' && ptr[0] != '/') {
+#else
+ if (ptr[0] != '-') {
+#endif
if (maxArg == 0) {
ExtOut ("Incorrect argument: %s\n", ptr);
return FALSE;
Output::g_bSuppressOutput--;
}
-// Do not support source line numbers on PAL platforms
-#ifndef FEATURE_PAL
-
//
// Code to support mapping RVAs to managed code line numbers.
//
}
-#endif
-
-
// Based on a native offset, passed in the first argument this function
// identifies the corresponding source file name and line number.
HRESULT
return SafeReadMemory(m_moduleBaseAddress + relativeVirtualAddress, data, cbData, pcbData) ? S_OK : E_FAIL;
}
-
+#endif // FEATURE_PAL
HRESULT SymbolReader::LoadSymbols(IMetaDataImport * pMD, ICorDebugModule * pModule)
{
+#ifndef FEATURE_PAL
HRESULT Status = S_OK;
if(m_pSymReader != NULL) return S_OK;
IfFailRet(pModule->GetName(_countof(moduleName), &len, moduleName));
return LoadSymbols(pMD, baseAddress, moduleName, isInMemory);
+#else
+ return E_FAIL;
+#endif // FEATURE_PAL
}
HRESULT SymbolReader::LoadSymbols(IMetaDataImport * pMD, ULONG64 baseAddress, __in_z WCHAR* pModuleName, BOOL isInMemory)
{
+#ifndef FEATURE_PAL
HRESULT Status = S_OK;
if(m_pSymReader != NULL) return S_OK;
m_pSymReader = NULL;
}
return Status;
+#else
+ return E_FAIL;
+#endif // FEATURE_PAL
}
HRESULT SymbolReader::GetNamedLocalVariable(ISymUnmanagedScope * pScope, ICorDebugILFrame * pILFrame, mdMethodDef methodToken, ULONG localIndex, __inout_ecount(paramNameLen) WCHAR* paramName, ULONG paramNameLen, ICorDebugValue** ppValue)
if(pScope == NULL)
{
+#ifndef FEATURE_PAL
ToRelease<ISymUnmanagedMethod> pSymMethod;
IfFailRet(m_pSymReader->GetMethod(methodToken, &pSymMethod));
IfFailRet(pSymMethod->GetRootScope(&pScope));
return GetNamedLocalVariable(pScope, pILFrame, methodToken, localIndex, paramName, paramNameLen, ppValue);
+#else
+ return E_FAIL;
+#endif // FEATURE_PAL
}
else
{
}
return E_FAIL;
}
+
HRESULT SymbolReader::GetNamedLocalVariable(ICorDebugFrame * pFrame, ULONG localIndex, __inout_ecount(paramNameLen) WCHAR* paramName, ULONG paramNameLen, ICorDebugValue** ppValue)
{
HRESULT Status = S_OK;
return GetNamedLocalVariable(NULL, pILFrame, methodDef, localIndex, paramName, paramNameLen, ppValue);
}
+
HRESULT SymbolReader::ResolveSequencePoint(__in_z WCHAR* pFilename, ULONG32 lineNumber, mdMethodDef* pToken, ULONG32* pIlOffset)
{
+#ifndef FEATURE_PAL
HRESULT Status = S_OK;
ULONG32 cDocs = 0;
ULONG32 cDocsNeeded = 0;
}
return S_OK;
}
+#endif // FEATURE_PAL
return E_FAIL;
}
-
-#endif
-
WString GetFrameFromAddress(TADDR frameAddr, IXCLRDataStackWalk *pStackWalk)
{
TADDR vtAddr;
volatile ULONG m_refCount;
};
+#endif // !FEATURE_PAL
+
class SymbolReader
{
private:
+#ifndef FEATURE_PAL
ISymUnmanagedReader* m_pSymReader;
+#endif
private:
HRESULT GetNamedLocalVariable(ISymUnmanagedScope * pScope, ICorDebugILFrame * pILFrame, mdMethodDef methodToken, ULONG localIndex, __inout_ecount(paramNameLen) WCHAR* paramName, ULONG paramNameLen, ICorDebugValue** ppValue);
public:
+#ifndef FEATURE_PAL
SymbolReader() : m_pSymReader (NULL) {}
~SymbolReader()
{
m_pSymReader = NULL;
}
}
+#else
+ SymbolReader() {}
+ ~SymbolReader() {}
+#endif
HRESULT LoadSymbols(IMetaDataImport * pMD, ICorDebugModule * pModule);
HRESULT LoadSymbols(IMetaDataImport * pMD, ULONG64 baseAddress, __in_z WCHAR* pModuleName, BOOL isInMemory);
HRESULT SymbolReader::ResolveSequencePoint(__in_z WCHAR* pFilename, ULONG32 lineNumber, mdMethodDef* pToken, ULONG32* pIlOffset);
};
-#endif // !FEATURE_PAL
-
HRESULT
GetLineByOffset(
__in ULONG64 IP,
m_returnObject(returnObject),
m_coreclrDirectory(coreclrDirectory)
{
+ returnObject.SetStatus(lldb::eReturnStatusSuccessFinishResult);
}
DebugClient::~DebugClient()
return S_OK;
}
+HRESULT
+DebugClient::Execute(
+ ULONG outputControl,
+ PCSTR command,
+ ULONG flags)
+{
+ lldb::SBCommandInterpreter interpreter = m_debugger.GetCommandInterpreter();
+
+ lldb::SBCommandReturnObject result;
+ lldb::ReturnStatus status = interpreter.HandleCommand(command, result);
+
+ return status <= lldb::eReturnStatusSuccessContinuingResult ? S_OK : E_FAIL;
+}
+
+// PAL raise exception function and exception record pointer variable name
+// See coreclr\src\pal\src\exception\seh-unwind.cpp for the details.
+#define FUNCTION_NAME "RtlpRaiseException"
+#define VARIABLE_NAME "ExceptionRecord"
+
+HRESULT
+DebugClient::GetLastEventInformation(
+ PULONG type,
+ PULONG processId,
+ PULONG threadId,
+ PVOID extraInformation,
+ ULONG extraInformationSize,
+ PULONG extraInformationUsed,
+ PSTR description,
+ ULONG descriptionSize,
+ PULONG descriptionUsed)
+{
+ if (extraInformationSize < sizeof(DEBUG_LAST_EVENT_INFO_EXCEPTION) ||
+ type == NULL || processId == NULL || threadId == NULL || extraInformationUsed == NULL)
+ {
+ return E_FAIL;
+ }
+
+ *type = DEBUG_EVENT_EXCEPTION;
+ *processId = 0;
+ *threadId = 0;
+ *extraInformationUsed = sizeof(DEBUG_LAST_EVENT_INFO_EXCEPTION);
+
+ DEBUG_LAST_EVENT_INFO_EXCEPTION *pdle = (DEBUG_LAST_EVENT_INFO_EXCEPTION *)extraInformation;
+ pdle->FirstChance = 1;
+
+ lldb::SBProcess process = GetCurrentProcess();
+ if (!process.IsValid())
+ {
+ return E_FAIL;
+ }
+ lldb::SBThread thread = process.GetSelectedThread();
+ if (!thread.IsValid())
+ {
+ return E_FAIL;
+ }
+
+ // Enumerate each stack frame at the special "throw"
+ // breakpoint and find the raise exception function
+ // with the exception record parameter.
+ int numFrames = thread.GetNumFrames();
+ for (int i = 0; i < numFrames; i++)
+ {
+ lldb::SBFrame frame = thread.GetFrameAtIndex(i);
+ if (!frame.IsValid())
+ {
+ break;
+ }
+
+ const char *functionName = frame.GetFunctionName();
+ if (functionName == NULL || strncmp(functionName, FUNCTION_NAME, sizeof(FUNCTION_NAME) - 1) != 0)
+ {
+ continue;
+ }
+
+ lldb::SBValue exValue = frame.FindVariable(VARIABLE_NAME);
+ if (!exValue.IsValid())
+ {
+ break;
+ }
+
+ lldb::SBError error;
+ ULONG64 pExceptionRecord = exValue.GetValueAsUnsigned(error);
+ if (error.Fail())
+ {
+ break;
+ }
+
+ process.ReadMemory(pExceptionRecord, &pdle->ExceptionRecord, sizeof(pdle->ExceptionRecord), error);
+ if (error.Fail())
+ {
+ break;
+ }
+
+ return S_OK;
+ }
+
+ return E_FAIL;
+}
+
// Internal output string function
void
DebugClient::OutputString(
ULONG mask,
PCSTR str)
{
+ if (mask == DEBUG_OUTPUT_ERROR)
+ {
+ m_returnObject.SetStatus(lldb::eReturnStatusFailed);
+ }
// Can not use AppendMessage or AppendWarning because they add a newline. SetError
// can not be used for DEBUG_OUTPUT_ERROR mask because it caches the error strings
// seperately from the normal output so error/normal texts are not intermixed
ULONG bufferSize,
PULONG bytesWritten)
{
+ lldb::SBError error;
+ size_t written = 0;
+
+ lldb::SBProcess process = GetCurrentProcess();
+ if (!process.IsValid())
+ {
+ goto exit;
+ }
+
+ written = process.WriteMemory(offset, buffer, bufferSize, error);
+
+exit:
if (bytesWritten)
{
- *bytesWritten = 0;
+ *bytesWritten = written;
}
- return E_NOTIMPL;
+ return error.Success() ? S_OK : E_FAIL;
}
//----------------------------------------------------------------------------
PULONG size);
HRESULT GetExecutingProcessorType(
- PULONG Type);
+ PULONG type);
+
+ HRESULT Execute(
+ ULONG outputControl,
+ PCSTR command,
+ ULONG flags);
+
+ HRESULT GetLastEventInformation(
+ PULONG type,
+ PULONG processId,
+ PULONG threadId,
+ PVOID extraInformation,
+ ULONG extraInformationSize,
+ PULONG extraInformationUsed,
+ PSTR description,
+ ULONG descriptionSize,
+ PULONG descriptionUsed);
//----------------------------------------------------------------------------
// IDebugDataSpaces
// current processor context.
virtual HRESULT GetExecutingProcessorType(
PULONG type) = 0;
+
+ // Executes the given command string.
+ // If the string has multiple commands
+ // Execute will not return until all
+ // of them have been executed. If this
+ // requires waiting for the debuggee to
+ // execute an internal wait will be done
+ // so Execute can take an arbitrary amount
+ // of time.
+ virtual HRESULT Execute(
+ ULONG outputControl,
+ PCSTR command,
+ ULONG flags) = 0;
+
+ // Retrieves information about the last event that occurred.
+ // EventType is one of the event callback mask bits.
+ // ExtraInformation contains additional event-specific
+ // information. Not all events have additional information.
+ virtual HRESULT GetLastEventInformation(
+ PULONG type,
+ PULONG processId,
+ PULONG threadId,
+ PVOID extraInformation,
+ ULONG extraInformationSize,
+ PULONG extraInformationUsed,
+ PSTR description,
+ ULONG descriptionSize,
+ PULONG descriptionUsed) = 0;
};
typedef class IDebugControl2* PDEBUG_CONTROL2;
+
// Output mask bits.
// Normal output.
#define DEBUG_OUTPUT_NORMAL 0x00000001
// Symbol messages, such as for !sym noisy.
#define DEBUG_OUTPUT_SYMBOLS 0x00000200
+// Execute and ExecuteCommandFile flags.
+// These flags only apply to the command
+// text itself; output from the executed
+// command is controlled by the output
+// control parameter.
+// Default execution. Command is logged
+// but not output.
+#define DEBUG_EXECUTE_DEFAULT 0x00000000
+// Echo commands during execution. In
+// ExecuteCommandFile also echoes the prompt
+// for each line of the file.
+#define DEBUG_EXECUTE_ECHO 0x00000001
+// Do not log or output commands during execution.
+// Overridden by DEBUG_EXECUTE_ECHO.
+#define DEBUG_EXECUTE_NOT_LOGGED 0x00000002
+// If this flag is not set an empty string
+// to Execute will repeat the last Execute
+// string.
+#define DEBUG_EXECUTE_NO_REPEAT 0x00000004
+
// Classes of debuggee. Each class
// has different qualifiers for specific
// kinds of debuggees.
#define IMAGE_FILE_MACHINE_I386 0x014c // Intel 386.
#define IMAGE_FILE_MACHINE_AMD64 0x8664 // AMD64 (K8)
+// Execution status codes used for waiting,
+// for returning current status and for
+// event method return values.
+#define DEBUG_STATUS_NO_CHANGE 0
+#define DEBUG_STATUS_GO 1
+#define DEBUG_STATUS_GO_HANDLED 2
+#define DEBUG_STATUS_GO_NOT_HANDLED 3
+#define DEBUG_STATUS_STEP_OVER 4
+#define DEBUG_STATUS_STEP_INTO 5
+#define DEBUG_STATUS_BREAK 6
+#define DEBUG_STATUS_NO_DEBUGGEE 7
+#define DEBUG_STATUS_STEP_BRANCH 8
+#define DEBUG_STATUS_IGNORE_EVENT 9
+#define DEBUG_STATUS_RESTART_REQUESTED 10
+#define DEBUG_STATUS_REVERSE_GO 11
+#define DEBUG_STATUS_REVERSE_STEP_BRANCH 12
+#define DEBUG_STATUS_REVERSE_STEP_OVER 13
+#define DEBUG_STATUS_REVERSE_STEP_INTO 14
+#define DEBUG_STATUS_OUT_OF_SYNC 15
+#define DEBUG_STATUS_WAIT_INPUT 16
+#define DEBUG_STATUS_TIMEOUT 17
+
+#define DEBUG_STATUS_MASK 0x1f
+
+#define DEBUG_EVENT_EXCEPTION 0x00000002
+
+#ifdef DEFINE_EXCEPTION_RECORD
+
+#define EXCEPTION_MAXIMUM_PARAMETERS 15
+
+// This copy of the "64" bit record has been modified
+// by removing the alignment field to make it the same
+// as the _EXCEPTION_RECORD used in the pal defined in
+// pal.h.
+typedef struct _EXCEPTION_RECORD64 {
+ DWORD ExceptionCode;
+ DWORD ExceptionFlags;
+ DWORD64 ExceptionRecord;
+ DWORD64 ExceptionAddress;
+ DWORD NumberParameters;
+ DWORD64 ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
+} EXCEPTION_RECORD64, *PEXCEPTION_RECORD64;
+
+#endif // DEFINE_EXCEPTION_RECORD
+
+typedef struct _DEBUG_LAST_EVENT_INFO_EXCEPTION
+{
+ EXCEPTION_RECORD64 ExceptionRecord;
+ ULONG FirstChance;
+} DEBUG_LAST_EVENT_INFO_EXCEPTION, *PDEBUG_LAST_EVENT_INFO_EXCEPTION;
+
//----------------------------------------------------------------------------
// IDebugDataSpaces
//----------------------------------------------------------------------------
#include "sosplugin.h"
#include <dlfcn.h>
+#include <string.h>
#include <string>
class sosCommand : public lldb::SBCommandPluginInterface
}
else
{
- std::string directoryString;
- directoryString.append(directory);
- directoryString.append("/");
- directoryString.copy(m_coreclrDirectory, MAX_PATH, 0);
+ strcpy(m_coreclrDirectory, directory);
+ strcat(m_coreclrDirectory, "/");
// Load the DAC module first explicitly because SOS and DBI
// have implicit references to the DAC's PAL.
#include <lldb/API/LLDB.h>
#include "mstypes.h"
+#define DEFINE_EXCEPTION_RECORD
#include <dbgeng.h>
#include "debugclient.h"
FormatMessageW
FreeEnvironmentStringsW
GetACP
+GetCLRRuntimeHost
GetConsoleCP
GetConsoleOutputCP
GetCurrentDirectoryW
OpenEventW
OpenMutexW
OpenSemaphoreW
+PAL_InitializeCoreCLR
PAL_Random
PAL_RegisterModule
PAL_UnregisterModule
#define PORTABILITY_ASSERT(message) _ASSERTE(false && message)
#endif
-
+#define DIRECTORY_SEPARATOR_CHAR_A '\\'
#define DIRECTORY_SEPARATOR_CHAR_W W('\\')
#define DIRECTORY_SEPARATOR_STR_W W("\\")
#define _ReturnAddress() __builtin_return_address(0)
#ifdef PLATFORM_UNIX
+#define DIRECTORY_SEPARATOR_CHAR_A '/'
#define DIRECTORY_SEPARATOR_CHAR_W W('/')
#define DIRECTORY_SEPARATOR_STR_W W("/")
#define PATH_SEPARATOR_CHAR_W W(':')
#else // PLATFORM_UNIX
+#define DIRECTORY_SEPARATOR_CHAR_A '\\'
#define DIRECTORY_SEPARATOR_CHAR_W W('\\')
#define DIRECTORY_SEPARATOR_STR_W W("\\")
#define PATH_SEPARATOR_CHAR_W W(';')
#error don't know how to unwind on this platform
#endif
+/*++
+Function:
+ RtlpRaiseException
+
+Parameters:
+ ExceptionRecord - the Windows exception record to throw
+
+Note:
+ The name of this function and the name of the ExceptionRecord
+ parameter is used in the sos lldb plugin code to read the exception
+ record. See coreclr\src\ToolBox\SOS\lldbplugin\debugclient.cpp.
+--*/
PAL_NORETURN
static void RtlpRaiseException(EXCEPTION_RECORD *ExceptionRecord)
{
#if defined(FEATURE_PAL) && !defined(CROSSGEN_COMPILE)
DacGlobals::Initialize();
+ InitializeJITNotificationTable();
#endif
PAL_TRY(COINITIEE *, pfFlags, &fFlags)
GPTR_DECL(JITNotification,g_pNotificationTable);
GVAL_DECL(ULONG32, g_dacNotificationFlags);
+#if defined(FEATURE_PAL) && !defined(DACCESS_COMPILE)
+
+inline void
+InitializeJITNotificationTable()
+{
+ g_pNotificationTable = new (nothrow) JITNotification[1001];
+}
+
+#endif // FEATURE_PAL && !DACCESS_COMPILE
+
class JITNotifications
{
public:
projects / platform / upstream / coreclr.git / commitdiff