From: Oleg Lekarev Date: Fri, 9 Oct 2020 14:18:01 +0000 (+0300) Subject: Error description strings added. Bugfixes: commands step, next X-Git-Tag: submit/tizen/20210120.035625~44^2 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=f61eb1cf6a9214aa85527e9a3cbb5ffd16397bc8;p=sdk%2Ftools%2Fnetcoredbg.git Error description strings added. Bugfixes: commands step, next caused an SIGSEGV if the debugee process was not started. --- diff --git a/src/debug/netcoredbg/cliprotocol.cpp b/src/debug/netcoredbg/cliprotocol.cpp index 952a4c6..2df7055 100644 --- a/src/debug/netcoredbg/cliprotocol.cpp +++ b/src/debug/netcoredbg/cliprotocol.cpp @@ -7,6 +7,7 @@ #include "torelease.h" #include "cliprotocol.h" #include "linenoise.h" +#include "cputil.h" #include #include @@ -63,7 +64,7 @@ void CLIProtocol::EmitBreakpointEvent(BreakpointEvent event) { std::string output; PrintBreakpoint(event.breakpoint, output); - printf("=breakpoint-modified,%s\n", output.c_str()); + printf("breakpoint modified, %s\n", output.c_str()); return; } default: @@ -75,8 +76,9 @@ HRESULT CLIProtocol::StepCommand(const std::vector &args, std::string &output, Debugger::StepType stepType) { + HRESULT Status; DWORD threadId = GetIntArg(args, "--thread", m_debugger->GetLastStoppedThreadId()); - m_debugger->StepCommand(threadId, stepType); + IfFailRet(m_debugger->StepCommand(threadId, stepType)); output = "^running"; return S_OK; } @@ -723,7 +725,7 @@ void CLIProtocol::CommandLoop() if (output.empty()) { printf("%s", redOn.c_str()); - printf("%s Error: 0x%08x\n", token.c_str(), hr); + printf("%s Error: 0x%08x: %s\n", token.c_str(), hr, errormessage(hr)); printf("%s", colorOff.c_str()); } else diff --git a/src/debug/netcoredbg/cputil.cpp b/src/debug/netcoredbg/cputil.cpp index 8584cd0..a51d448 100644 --- a/src/debug/netcoredbg/cputil.cpp +++ b/src/debug/netcoredbg/cputil.cpp @@ -62,3 +62,471 @@ std::vector split_on_tokens(const std::string &str, const char deli return res; } + +#define CASE_OF(CODE, STRERROR) case CODE: str=STRERROR; break; + +const char *errormessage(HRESULT hresult) +{ + const char *str; + + switch (hresult) + { +// From (winerror.h/palrt.h) + CASE_OF(S_OK, "S_OK"); + CASE_OF(S_FALSE, "S_FALSE"); + CASE_OF(E_NOTIMPL, "E_NOTIMPL"); + CASE_OF(E_UNEXPECTED, "E_UNEXPECTED"); + CASE_OF(E_HANDLE, "E_HANDLE"); + CASE_OF(E_ABORT, "E_ABORT"); + CASE_OF(E_FAIL, "E_FAIL"); + CASE_OF(E_PENDING, "E_PENDING"); + CASE_OF(DISP_E_PARAMNOTFOUND, "DISP_E_PARAMNOTFOUND"); + CASE_OF(DISP_E_TYPEMISMATCH, "DISP_E_TYPEMISMATCH"); + CASE_OF(DISP_E_BADVARTYPE, "DISP_E_BADVARTYPE"); + CASE_OF(DISP_E_OVERFLOW, "DISP_E_OVERFLOW"); + CASE_OF(CLASS_E_CLASSNOTAVAILABLE, "CLASS_E_CLASSNOTAVAILABLE"); + CASE_OF(CLASS_E_NOAGGREGATION, "CLASS_E_NOAGGREGATION"); + CASE_OF(CO_E_CLASSSTRING, "CO_E_CLASSSTRING"); + CASE_OF(MK_E_SYNTAX, "MK_E_SYNTAX"); + CASE_OF(STG_E_INVALIDFUNCTION, "STG_E_INVALIDFUNCTION"); + CASE_OF(STG_E_FILENOTFOUND, "STG_E_FILENOTFOUND"); + CASE_OF(STG_E_PATHNOTFOUND, "STG_E_PATHNOTFOUND"); + CASE_OF(STG_E_WRITEFAULT, "STG_E_WRITEFAULT"); + CASE_OF(STG_E_FILEALREADYEXISTS, "STG_E_FILEALREADYEXISTS"); + CASE_OF(STG_E_ABNORMALAPIEXIT, "STG_E_ABNORMALAPIEXIT"); + CASE_OF(NTE_BAD_UID, "NTE_BAD_UID"); + CASE_OF(NTE_BAD_HASH, "NTE_BAD_HASH"); + CASE_OF(NTE_BAD_KEY, "NTE_BAD_KEY"); + CASE_OF(NTE_BAD_LEN, "NTE_BAD_LEN"); + CASE_OF(NTE_BAD_DATA, "NTE_BAD_DATA"); + CASE_OF(NTE_BAD_SIGNATURE, "NTE_BAD_SIGNATURE"); + CASE_OF(NTE_BAD_VER, "NTE_BAD_VER"); + CASE_OF(NTE_BAD_ALGID, "NTE_BAD_ALGID"); + CASE_OF(NTE_BAD_FLAGS, "NTE_BAD_FLAGS"); + CASE_OF(NTE_BAD_TYPE, "NTE_BAD_TYPE"); + CASE_OF(NTE_BAD_KEY_STATE, "NTE_BAD_KEY_STATE"); + CASE_OF(NTE_BAD_HASH_STATE, "NTE_BAD_HASH_STATE"); + CASE_OF(NTE_NO_KEY, "NTE_NO_KEY"); + CASE_OF(NTE_NO_MEMORY, "NTE_NO_MEMORY"); + CASE_OF(NTE_SIGNATURE_FILE_BAD, "NTE_SIGNATURE_FILE_BAD"); + CASE_OF(NTE_FAIL, "NTE_FAIL"); + CASE_OF(CRYPT_E_HASH_VALUE, "CRYPT_E_HASH_VALUE"); + CASE_OF(TYPE_E_SIZETOOBIG, "TYPE_E_SIZETOOBIG"); + CASE_OF(TYPE_E_DUPLICATEID, "TYPE_E_DUPLICATEID"); + CASE_OF(CTL_E_OVERFLOW, "CTL_E_OVERFLOW"); + CASE_OF(CTL_E_OUTOFMEMORY, "CTL_E_OUTOFMEMORY"); + CASE_OF(CTL_E_DIVISIONBYZERO, "CTL_E_DIVISIONBYZERO"); + CASE_OF(CTL_E_OUTOFSTACKSPACE, "CTL_E_OUTOFSTACKSPACE"); + CASE_OF(CTL_E_FILENOTFOUND, "CTL_E_FILENOTFOUND"); + CASE_OF(CTL_E_DEVICEIOERROR, "CTL_E_DEVICEIOERROR"); + CASE_OF(CTL_E_PERMISSIONDENIED, "CTL_E_PERMISSIONDENIED"); + CASE_OF(CTL_E_PATHFILEACCESSERROR, "CTL_E_PATHFILEACCESSERROR"); + CASE_OF(CTL_E_PATHNOTFOUND, "CTL_E_PATHNOTFOUND"); + CASE_OF(INET_E_CANNOT_CONNECT, "INET_E_CANNOT_CONNECT"); + CASE_OF(INET_E_RESOURCE_NOT_FOUND, "INET_E_RESOURCE_NOT_FOUND"); + CASE_OF(INET_E_OBJECT_NOT_FOUND, "INET_E_OBJECT_NOT_FOUND"); + CASE_OF(INET_E_DATA_NOT_AVAILABLE, "INET_E_DATA_NOT_AVAILABLE"); + CASE_OF(INET_E_DOWNLOAD_FAILURE, "INET_E_DOWNLOAD_FAILURE"); + CASE_OF(INET_E_CONNECTION_TIMEOUT, "INET_E_CONNECTION_TIMEOUT"); + CASE_OF(INET_E_UNKNOWN_PROTOCOL, "INET_E_UNKNOWN_PROTOCOL"); + CASE_OF(DBG_PRINTEXCEPTION_C, "DBG_PRINTEXCEPTION_C"); +// From corerror.xml + CASE_OF(CLDB_S_TRUNCATION, "STATUS: Data value was truncated."); + CASE_OF(META_S_DUPLICATE, "Attempt to define an object that already exists in valid scenerios."); + CASE_OF(CORDBG_S_BAD_START_SEQUENCE_POINT, "Attempt to SetIP not at a sequence point sequence point."); + CASE_OF(CORDBG_S_BAD_END_SEQUENCE_POINT, "Attempt to SetIP when not going to a sequence point. If both this and CORDBG_E_BAD_START_SEQUENCE_POINT are true, only CORDBG_E_BAD_START_SEQUENCE_POINT will be reported."); + CASE_OF(CORDBG_S_FUNC_EVAL_HAS_NO_RESULT, "Some Func evals will lack a return value,"); + CASE_OF(CORDBG_S_VALUE_POINTS_TO_VOID, "The Debugging API doesn't support dereferencing void pointers."); + CASE_OF(CORDBG_S_FUNC_EVAL_ABORTED, "The func eval completed, but was aborted."); + CASE_OF(CORDBG_S_AT_END_OF_STACK, "The stack walk has reached the end of the stack. There are no more frames to walk."); + CASE_OF(CORDBG_S_NOT_ALL_BITS_SET, "Not all bits specified were successfully applied"); + CASE_OF(CEE_E_CVTRES_NOT_FOUND, "cvtres.exe not found."); + CASE_OF(COR_E_TYPEUNLOADED, "Type has been unloaded."); + CASE_OF(COR_E_APPDOMAINUNLOADED, "Attempted to access an unloaded appdomain."); + CASE_OF(COR_E_CANNOTUNLOADAPPDOMAIN, "Error while unloading appdomain."); + CASE_OF(MSEE_E_ASSEMBLYLOADINPROGRESS, "Assembly is still being loaded."); + CASE_OF(COR_E_ASSEMBLYEXPECTED, "The module was expected to contain an assembly manifest."); + CASE_OF(COR_E_FIXUPSINEXE, "Attempt to load an unverifiable executable with fixups (IAT with more than 2 sections or a TLS section.)"); + CASE_OF(COR_E_NEWER_RUNTIME, "This assembly is built by a runtime newer than the currently loaded runtime and cannot be loaded."); + CASE_OF(COR_E_MULTIMODULEASSEMBLIESDIALLOWED, "The module cannot be loaded because only single file assemblies are supported."); + CASE_OF(HOST_E_DEADLOCK, "Host detected a deadlock on a blocking operation."); + CASE_OF(HOST_E_INVALIDOPERATION, "Invalid operation."); + CASE_OF(HOST_E_CLRNOTAVAILABLE, "CLR has been disabled due to unrecoverable error."); + CASE_OF(HOST_E_EXITPROCESS_THREADABORT, "Process exited due to ThreadAbort escalation."); + CASE_OF(HOST_E_EXITPROCESS_ADUNLOAD, "Process exited due to AD Unload escalation."); + CASE_OF(HOST_E_EXITPROCESS_TIMEOUT, "Process exited due to Timeout escalation."); + CASE_OF(HOST_E_EXITPROCESS_OUTOFMEMORY, "Process exited due to OutOfMemory escalation."); + CASE_OF(COR_E_MODULE_HASH_CHECK_FAILED, "The check of the module's hash failed."); + CASE_OF(FUSION_E_REF_DEF_MISMATCH, "The located assembly's manifest definition does not match the assembly reference."); + CASE_OF(FUSION_E_INVALID_PRIVATE_ASM_LOCATION, "The private assembly was located outside the appbase directory."); + CASE_OF(FUSION_E_ASM_MODULE_MISSING, "A module specified in the manifest was not found."); + CASE_OF(FUSION_E_PRIVATE_ASM_DISALLOWED, "A strongly-named assembly is required."); + CASE_OF(FUSION_E_SIGNATURE_CHECK_FAILED, "Strong name signature could not be verified. The assembly may have been tampered with, or it was delay signed but not fully signed with the correct private key."); + CASE_OF(FUSION_E_INVALID_NAME, "The given assembly name or codebase was invalid."); + CASE_OF(FUSION_E_CODE_DOWNLOAD_DISABLED, "HTTP download of assemblies has been disabled for this appdomain."); + CASE_OF(FUSION_E_HOST_GAC_ASM_MISMATCH, "Assembly in host store has a different signature than assembly in GAC."); + CASE_OF(FUSION_E_LOADFROM_BLOCKED, "LoadFrom(), LoadFile(), Load(byte[]) and LoadModule() have been disabled by the host."); + CASE_OF(FUSION_E_CACHEFILE_FAILED, "Failed to add file to AppDomain cache."); + CASE_OF(FUSION_E_APP_DOMAIN_LOCKED, "The requested assembly version conflicts with what is already bound in the app domain or specified in the manifest."); + CASE_OF(FUSION_E_CONFIGURATION_ERROR, "The requested assembly name was neither found in the GAC nor in the manifest or the manifest's specified location is wrong."); + CASE_OF(FUSION_E_MANIFEST_PARSE_ERROR, "Unexpected error while parsing the specified manifest."); + CASE_OF(COR_E_LOADING_REFERENCE_ASSEMBLY, "Reference assemblies should not be loaded for execution. They can only be loaded in the Reflection-only loader context."); + CASE_OF(COR_E_NI_AND_RUNTIME_VERSION_MISMATCH, "The native image could not be loaded, because it was generated for use by a different version of the runtime."); + CASE_OF(COR_E_LOADING_WINMD_REFERENCE_ASSEMBLY, "Contract Windows Runtime assemblies cannot be loaded for execution. Make sure your application only contains non-contract Windows Runtime assemblies."); + CASE_OF(COR_E_AMBIGUOUSIMPLEMENTATION, "Ambiguous implementation found."); + CASE_OF(CLDB_E_FILE_BADREAD, "Error occurred during a read."); + CASE_OF(CLDB_E_FILE_BADWRITE, "Error occurred during a write."); + CASE_OF(CLDB_E_FILE_OLDVER, "Old version error."); + CASE_OF(CLDB_E_SMDUPLICATE, "Create of shared memory failed. A memory mapping of the same name already exists."); + CASE_OF(CLDB_E_NO_DATA, "No .CLB data in the memory or stream."); + CASE_OF(CLDB_E_INCOMPATIBLE, "Importing scope is not compatible with the emitting scope."); + CASE_OF(CLDB_E_FILE_CORRUPT, "File is corrupt."); + CASE_OF(CLDB_E_BADUPDATEMODE, "Cannot open a incrementally build scope for full update."); + CASE_OF(CLDB_E_INDEX_NOTFOUND, "Index not found."); + CASE_OF(CLDB_E_RECORD_NOTFOUND, "Record not found on lookup."); + CASE_OF(CLDB_E_RECORD_OUTOFORDER, "Record is emitted out of order."); + CASE_OF(CLDB_E_TOO_BIG, "A blob or string was too big."); + CASE_OF(META_E_INVALID_TOKEN_TYPE, "A token of the wrong type passed to a metadata function."); + CASE_OF(TLBX_E_LIBNOTREGISTERED, "Typelib export: Type library is not registered."); + CASE_OF(META_E_BADMETADATA, "Merge: Inconsistency in meta data import scope."); + CASE_OF(META_E_BAD_SIGNATURE, "Bad binary signature."); + CASE_OF(META_E_BAD_INPUT_PARAMETER, "Bad input parameters."); + CASE_OF(META_E_CANNOTRESOLVETYPEREF, "Cannot resolve typeref."); + CASE_OF(META_E_STRINGSPACE_FULL, "No logical space left to create more user strings."); + CASE_OF(META_E_HAS_UNMARKALL, "Unmark all has been called already."); + CASE_OF(META_E_MUST_CALL_UNMARKALL, "Must call UnmarkAll first before marking."); + CASE_OF(META_E_CA_INVALID_TARGET, "Known custom attribute on invalid target."); + CASE_OF(META_E_CA_INVALID_VALUE, "Known custom attribute had invalid value."); + CASE_OF(META_E_CA_INVALID_BLOB, "Known custom attribute blob has bad format."); + CASE_OF(META_E_CA_REPEATED_ARG, "Known custom attribute blob has repeated named argument."); + CASE_OF(META_E_CA_UNKNOWN_ARGUMENT, "Known custom attribute named argument not recognized."); + CASE_OF(META_E_CA_UNEXPECTED_TYPE, "Known attribute parser found unexpected type."); + CASE_OF(META_E_CA_INVALID_ARGTYPE, "Known attribute parser only handles fields, not properties."); + CASE_OF(META_E_CA_INVALID_ARG_FOR_TYPE, "Known attribute parser found an argument that is invalid for the object it is applied to."); + CASE_OF(META_E_CA_INVALID_UUID, "The format of the UUID was invalid."); + CASE_OF(META_E_CA_INVALID_MARSHALAS_FIELDS, "The MarshalAs attribute has fields set that are not valid for the specified unmanaged type."); + CASE_OF(META_E_CA_NT_FIELDONLY, "The specified unmanaged type is only valid on fields."); + CASE_OF(META_E_CA_NEGATIVE_PARAMINDEX, "The parameter index cannot be negative."); + CASE_OF(META_E_CA_NEGATIVE_CONSTSIZE, "The constant size cannot be negative."); + CASE_OF(META_E_CA_FIXEDSTR_SIZE_REQUIRED, "A fixed string requires a size."); + CASE_OF(META_E_CA_CUSTMARSH_TYPE_REQUIRED, "A custom marshaler requires the custom marshaler type."); + CASE_OF(META_E_NOT_IN_ENC_MODE, "SaveDelta was called without being in EnC mode."); + CASE_OF(META_E_CA_BAD_FRIENDS_ARGS, "InternalsVisibleTo can't have a version, culture, or processor architecture."); + CASE_OF(META_E_CA_FRIENDS_SN_REQUIRED, "Strong-name signed assemblies can only grant friend access to strong name-signed assemblies"); + CASE_OF(VLDTR_E_RID_OUTOFRANGE, "Rid is out of range."); + CASE_OF(VLDTR_E_STRING_INVALID, "String offset is invalid."); + CASE_OF(VLDTR_E_GUID_INVALID, "GUID offset is invalid."); + CASE_OF(VLDTR_E_BLOB_INVALID, "Blob offset if invalid."); + CASE_OF(VLDTR_E_MR_BADCALLINGCONV, "MemberRef has invalid calling convention."); + CASE_OF(VLDTR_E_SIGNULL, "Signature specified is zero-sized."); + CASE_OF(VLDTR_E_MD_BADCALLINGCONV, "Method signature has invalid calling convention."); + CASE_OF(VLDTR_E_MD_THISSTATIC, "Method is marked static but has HASTHIS/EXPLICITTHIS set on the calling convention."); + CASE_OF(VLDTR_E_MD_NOTTHISNOTSTATIC, "Method is not marked static but is not HASTHIS or EXPLICITTHIS."); + CASE_OF(VLDTR_E_MD_NOARGCNT, "Method signature is missing the argument count."); + CASE_OF(VLDTR_E_SIG_MISSELTYPE, "Signature missing element type."); + CASE_OF(VLDTR_E_SIG_MISSTKN, "Signature missing token."); + CASE_OF(VLDTR_E_SIG_TKNBAD, "Signature has bad token."); + CASE_OF(VLDTR_E_SIG_MISSFPTR, "Signature is missing function pointer."); + CASE_OF(VLDTR_E_SIG_MISSFPTRARGCNT, "Signature has function pointer missing argument count."); + CASE_OF(VLDTR_E_SIG_MISSRANK, "Signature is missing rank specification."); + CASE_OF(VLDTR_E_SIG_MISSNSIZE, "Signature is missing count of sized dimensions."); + CASE_OF(VLDTR_E_SIG_MISSSIZE, "Signature is missing size of dimension."); + CASE_OF(VLDTR_E_SIG_MISSNLBND, "Signature is missing count of lower bounds."); + CASE_OF(VLDTR_E_SIG_MISSLBND, "Signature is missing a lower bound."); + CASE_OF(VLDTR_E_SIG_BADELTYPE, "Signature has bad element type."); + CASE_OF(VLDTR_E_TD_ENCLNOTNESTED, "TypeDef not nested has encloser."); + CASE_OF(VLDTR_E_FMD_PINVOKENOTSTATIC, "Field or method is PInvoke but is not marked Static."); + CASE_OF(VLDTR_E_SIG_SENTINMETHODDEF, "E_T_SENTINEL in MethodDef signature."); + CASE_OF(VLDTR_E_SIG_SENTMUSTVARARG, "E_T_SENTINEL <=> VARARG."); + CASE_OF(VLDTR_E_SIG_MULTSENTINELS, "Multiple E_T_SENTINELs."); + CASE_OF(VLDTR_E_SIG_MISSARG, "Signature missing argument."); + CASE_OF(VLDTR_E_SIG_BYREFINFIELD, "Field of ByRef type."); + CASE_OF(CORDBG_E_UNRECOVERABLE_ERROR, "Unrecoverable API error."); + CASE_OF(CORDBG_E_PROCESS_TERMINATED, "Process was terminated."); + CASE_OF(CORDBG_E_PROCESS_NOT_SYNCHRONIZED, "Process not synchronized."); + CASE_OF(CORDBG_E_CLASS_NOT_LOADED, "A class is not loaded."); + CASE_OF(CORDBG_E_IL_VAR_NOT_AVAILABLE, "An IL variable is not available at the current native IP."); + CASE_OF(CORDBG_E_BAD_REFERENCE_VALUE, "A reference value was found to be bad during dereferencing."); + CASE_OF(CORDBG_E_FIELD_NOT_AVAILABLE, "A field in a class is not available, because the runtime optimized it away."); + CASE_OF(CORDBG_E_NON_NATIVE_FRAME, "'Native-frame-only' operation on non-native frame."); + CASE_OF(CORDBG_E_CODE_NOT_AVAILABLE, "The code is currently unavailable."); + CASE_OF(CORDBG_E_FUNCTION_NOT_IL, "Attempt to get a ICorDebugFunction for a function that is not IL."); + CASE_OF(CORDBG_E_CANT_SET_IP_INTO_FINALLY, "SetIP is not possible because SetIP would move EIP from outside of an exception handling finally clause to a point inside of one."); + CASE_OF(CORDBG_E_CANT_SET_IP_OUT_OF_FINALLY, "SetIP is not possible because it would move EIP from within an exception handling finally clause to a point outside of one."); + CASE_OF(CORDBG_E_CANT_SET_IP_INTO_CATCH, "SetIP is not possible, because SetIP would move EIP from outside of an exception handling catch clause to a point inside of one."); + CASE_OF(CORDBG_E_SET_IP_NOT_ALLOWED_ON_NONLEAF_FRAME, "SetIP cannot be done on any frame except the leaf frame."); + CASE_OF(CORDBG_E_SET_IP_IMPOSSIBLE, "SetIP is not allowed."); + CASE_OF(CORDBG_E_FUNC_EVAL_BAD_START_POINT, "Func eval cannot work. Bad starting point."); + CASE_OF(CORDBG_E_INVALID_OBJECT, "This object value is no longer valid."); + CASE_OF(CORDBG_E_FUNC_EVAL_NOT_COMPLETE, "CordbEval::GetResult called before func eval has finished."); + CASE_OF(CORDBG_E_STATIC_VAR_NOT_AVAILABLE, "A static variable is not available because it has not been initialized yet."); + CASE_OF(CORDBG_E_CANT_SETIP_INTO_OR_OUT_OF_FILTER, "SetIP cannot leave or enter a filter."); + CASE_OF(CORDBG_E_CANT_CHANGE_JIT_SETTING_FOR_ZAP_MODULE, "JIT settings for ZAP modules cannot be changed."); + CASE_OF(CORDBG_E_CANT_SET_IP_OUT_OF_FINALLY_ON_WIN64, "SetIP is not possible because it would move EIP from within a finally clause to a point outside of one on this platforms."); + CASE_OF(CORDBG_E_CANT_SET_IP_OUT_OF_CATCH_ON_WIN64, "SetIP is not possible because it would move EIP from within a catch clause to a point outside of one on this platforms."); + CASE_OF(CORDBG_E_CANT_SET_TO_JMC, "Cannot use JMC on this code (likely wrong JIT settings)."); + CASE_OF(CORDBG_E_NO_CONTEXT_FOR_INTERNAL_FRAME, "Internal frame markers have no associated context."); + CASE_OF(CORDBG_E_NOT_CHILD_FRAME, "The current frame is not a child frame."); + CASE_OF(CORDBG_E_NON_MATCHING_CONTEXT, "The provided CONTEXT does not match the specified thread."); + CASE_OF(CORDBG_E_PAST_END_OF_STACK, "The stackwalker is now past the end of stack. No information is available."); + CASE_OF(CORDBG_E_FUNC_EVAL_CANNOT_UPDATE_REGISTER_IN_NONLEAF_FRAME, "Func eval cannot update a variable stored in a register on a non-leaf frame. The most likely cause is that such a variable is passed as a ref/out argument."); + CASE_OF(CORDBG_E_BAD_THREAD_STATE, "The state of the thread is invalid."); + CASE_OF(CORDBG_E_DEBUGGER_ALREADY_ATTACHED, "This process has already been attached."); + CASE_OF(CORDBG_E_SUPERFLOUS_CONTINUE, "Returned from a call to Continue that was not matched with a stopping event."); + CASE_OF(CORDBG_E_SET_VALUE_NOT_ALLOWED_ON_NONLEAF_FRAME, "Cannot perfrom SetValue on non-leaf frames."); + CASE_OF(CORDBG_E_ENC_MODULE_NOT_ENC_ENABLED, "Tried to do Edit and Continue on a module that was not started in Edit and Continue mode."); + CASE_OF(CORDBG_E_SET_IP_NOT_ALLOWED_ON_EXCEPTION, "SetIP cannot be done on any exception."); + CASE_OF(CORDBG_E_VARIABLE_IS_ACTUALLY_LITERAL, "The 'variable' does not exist because it is a literal optimized away by the compiler."); + CASE_OF(CORDBG_E_PROCESS_DETACHED, "Process has been detached."); + CASE_OF(CORDBG_E_ENC_CANT_ADD_FIELD_TO_VALUE_OR_LAYOUT_CLASS, "Adding a field to a value or layout class is prohibited."); + CASE_OF(CORDBG_E_FIELD_NOT_STATIC, "GetStaticFieldValue called on a non-static field."); + CASE_OF(CORDBG_E_FIELD_NOT_INSTANCE, "Returned if someone tries to call GetStaticFieldValue on a non-instance field."); + CASE_OF(CORDBG_E_ENC_JIT_CANT_UPDATE, "The JIT is unable to update the method."); + CASE_OF(CORDBG_E_ENC_INTERNAL_ERROR, "Internal Runtime Error while doing Edit-and-Continue."); + CASE_OF(CORDBG_E_ENC_HANGING_FIELD, "The field was added via Edit and Continue after the class was loaded."); + CASE_OF(CORDBG_E_MODULE_NOT_LOADED, "Module not loaded."); + CASE_OF(CORDBG_E_UNABLE_TO_SET_BREAKPOINT, "Cannot set a breakpoint here."); + CASE_OF(CORDBG_E_DEBUGGING_NOT_POSSIBLE, "Debugging is not possible due to an incompatibility within the CLR implementation."); + CASE_OF(CORDBG_E_KERNEL_DEBUGGER_ENABLED, "A kernel debugger is enabled on the system. User-mode debugging will trap to the kernel debugger."); + CASE_OF(CORDBG_E_KERNEL_DEBUGGER_PRESENT, "A kernel debugger is present on the system. User-mode debugging will trap to the kernel debugger."); + CASE_OF(CORDBG_E_INCOMPATIBLE_PROTOCOL, "The debugger's protocol is incompatible with the debuggee."); + CASE_OF(CORDBG_E_TOO_MANY_PROCESSES, "The debugger can only handle a finite number of debuggees."); + CASE_OF(CORDBG_E_INTEROP_NOT_SUPPORTED, "Interop debugging is not supported."); + CASE_OF(CORDBG_E_NO_REMAP_BREAKPIONT, "Cannot call RemapFunction until have received RemapBreakpoint."); + CASE_OF(CORDBG_E_OBJECT_NEUTERED, "Object is in a zombie state."); + CASE_OF(CORPROF_E_FUNCTION_NOT_COMPILED, "Function not yet compiled."); + CASE_OF(CORPROF_E_DATAINCOMPLETE, "The ID is not fully loaded/defined yet."); + CASE_OF(CORPROF_E_FUNCTION_NOT_IL, "The Method has no associated IL."); + CASE_OF(CORPROF_E_NOT_MANAGED_THREAD, "The thread has never run managed code before."); + CASE_OF(CORPROF_E_CALL_ONLY_FROM_INIT, "The function may only be called during profiler initialization."); + CASE_OF(CORPROF_E_NOT_YET_AVAILABLE, "Requested information is not yet available."); + CASE_OF(CORPROF_E_TYPE_IS_PARAMETERIZED, "The given type is a generic and cannot be used with this method."); + CASE_OF(CORPROF_E_FUNCTION_IS_PARAMETERIZED, "The given function is a generic and cannot be used with this method."); + CASE_OF(CORPROF_E_STACKSNAPSHOT_INVALID_TGT_THREAD, "A profiler tried to walk the stack of an invalid thread"); + CASE_OF(CORPROF_E_STACKSNAPSHOT_UNMANAGED_CTX, "A profiler can not walk a thread that is currently executing unmanaged code"); + CASE_OF(CORPROF_E_STACKSNAPSHOT_UNSAFE, "A stackwalk at this point may cause dead locks or data corruption"); + CASE_OF(CORPROF_E_STACKSNAPSHOT_ABORTED, "Stackwalking callback requested the walk to abort"); + CASE_OF(CORPROF_E_LITERALS_HAVE_NO_ADDRESS, "Returned when asked for the address of a static that is a literal."); + CASE_OF(CORPROF_E_UNSUPPORTED_CALL_SEQUENCE, "A call was made at an unsupported time. Examples include illegally calling a profiling API method asynchronously, calling a method that might trigger a GC at an unsafe time, and calling a method at a time that could cause locks to be taken out of order."); + CASE_OF(CORPROF_E_ASYNCHRONOUS_UNSAFE, "A legal asynchronous call was made at an unsafe time (e.g., CLR locks are held)"); + CASE_OF(CORPROF_E_CLASSID_IS_ARRAY, "The specified ClassID cannot be inspected by this function because it is an array"); + CASE_OF(CORPROF_E_CLASSID_IS_COMPOSITE, "The specified ClassID is a non-array composite type (e.g., ref) and cannot be inspected"); + CASE_OF(CORPROF_E_PROFILER_DETACHING, "The profiler's call into the CLR is disallowed because the profiler is attempting to detach."); + CASE_OF(CORPROF_E_PROFILER_NOT_ATTACHABLE, "The profiler does not support attaching to a live process."); + CASE_OF(CORPROF_E_UNRECOGNIZED_PIPE_MSG_FORMAT, "The message sent on the profiling API attach pipe is in an unrecognized format."); + CASE_OF(CORPROF_E_PROFILER_ALREADY_ACTIVE, "The request to attach a profiler was denied because a profiler is already loaded."); + CASE_OF(CORPROF_E_PROFILEE_INCOMPATIBLE_WITH_TRIGGER, "Unable to request a profiler attach because the target profilee's runtime is of a version incompatible with the current process calling AttachProfiler()."); + CASE_OF(CORPROF_E_IPC_FAILED, "AttachProfiler() encountered an error while communicating on the pipe to the target profilee. This is often caused by a target profilee that is shutting down or killed while AttachProfiler() is reading or writing the pipe."); + CASE_OF(CORPROF_E_PROFILEE_PROCESS_NOT_FOUND, "AttachProfiler() was unable to find a profilee with the specified process ID."); + CASE_OF(CORPROF_E_CALLBACK3_REQUIRED, "Profiler must implement ICorProfilerCallback3 interface for this call to be supported."); + CASE_OF(CORPROF_E_UNSUPPORTED_FOR_ATTACHING_PROFILER, "This call was attempted by a profiler that attached to the process after startup, but this call is only supported by profilers that are loaded into the process on startup."); + CASE_OF(CORPROF_E_IRREVERSIBLE_INSTRUMENTATION_PRESENT, "Detach is impossible because the profiler has either instrumented IL or inserted enter/leave hooks. Detach was not attempted; the profiler is still fully attached."); + CASE_OF(CORPROF_E_RUNTIME_UNINITIALIZED, "The profiler called a function that cannot complete because the CLR is not yet fully initialized. The profiler may try again once the CLR has fully started."); + CASE_OF(CORPROF_E_IMMUTABLE_FLAGS_SET, "Detach is impossible because immutable flags were set by the profiler at startup. Detach was not attempted; the profiler is still fully attached."); + CASE_OF(CORPROF_E_PROFILER_NOT_YET_INITIALIZED, "The profiler called a function that cannot complete because the profiler is not yet fully initialized."); + CASE_OF(CORPROF_E_INCONSISTENT_WITH_FLAGS, "The profiler called a function that first requires additional flags to be set in the event mask. This HRESULT may also indicate that the profiler called a function that first requires that some of the flags currently set in the event mask be reset."); + CASE_OF(CORPROF_E_PROFILER_CANCEL_ACTIVATION, "The profiler has requested that the CLR instance not load the profiler into this process."); + CASE_OF(CORPROF_E_CONCURRENT_GC_NOT_PROFILABLE, "Concurrent GC mode is enabled, which prevents use of COR_PRF_MONITOR_GC"); + CASE_OF(CORPROF_E_DEBUGGING_DISABLED, "This functionality requires CoreCLR debugging to be enabled."); + CASE_OF(CORPROF_E_TIMEOUT_WAITING_FOR_CONCURRENT_GC, "Timed out on waiting for concurrent GC to finish during attach."); + CASE_OF(CORPROF_E_MODULE_IS_DYNAMIC, "The specified module was dynamically generated (e.g., via Reflection.Emit API), and is thus not supported by this API method."); + CASE_OF(CORPROF_E_CALLBACK4_REQUIRED, "Profiler must implement ICorProfilerCallback4 interface for this call to be supported."); + CASE_OF(CORPROF_E_REJIT_NOT_ENABLED, "This call is not supported unless ReJIT is first enabled during initialization by setting COR_PRF_ENABLE_REJIT via SetEventMask."); + CASE_OF(CORPROF_E_FUNCTION_IS_COLLECTIBLE, "The specified function is instantiated into a collectible assembly, and is thus not supported by this API method."); + CASE_OF(CORPROF_E_CALLBACK6_REQUIRED, "Profiler must implement ICorProfilerCallback6 interface for this call to be supported."); + CASE_OF(CORPROF_E_CALLBACK7_REQUIRED, "Profiler must implement ICorProfilerCallback7 interface for this call to be supported."); + CASE_OF(CORPROF_E_REJIT_INLINING_DISABLED, "The runtime's tracking of inlined methods for ReJIT is not enabled."); + CASE_OF(CORDIAGIPC_E_BAD_ENCODING, "The runtime was unable to decode the Header or Payload."); + CASE_OF(CORDIAGIPC_E_UNKNOWN_COMMAND, "The specified CommandSet or CommandId is unknown."); + CASE_OF(CORDIAGIPC_E_UNKNOWN_MAGIC, "The magic version of Diagnostics IPC is unknown."); + CASE_OF(CORDIAGIPC_E_UNKNOWN_ERROR, "An unknown error occurred in the Diagnpostics IPC Server."); + CASE_OF(CORPROF_E_SUSPENSION_IN_PROGRESS, "The runtime cannot be suspened since a suspension is already in progress."); + CASE_OF(SECURITY_E_INCOMPATIBLE_SHARE, "Loading this assembly would produce a different grant set from other instances."); + CASE_OF(SECURITY_E_UNVERIFIABLE, "Unverifiable code failed policy check."); + CASE_OF(SECURITY_E_INCOMPATIBLE_EVIDENCE, "Assembly already loaded without additional security evidence."); + CASE_OF(CORSEC_E_POLICY_EXCEPTION, "PolicyException thrown."); + CASE_OF(CORSEC_E_MIN_GRANT_FAIL, "Failed to grant minimum permission requests."); + CASE_OF(CORSEC_E_NO_EXEC_PERM, "Failed to grant permission to execute."); + CASE_OF(CORSEC_E_XMLSYNTAX, "XML Syntax error."); + CASE_OF(CORSEC_E_INVALID_STRONGNAME, "Strong name validation failed."); + CASE_OF(CORSEC_E_MISSING_STRONGNAME, "Assembly is not strong named."); + CASE_OF(CORSEC_E_INVALID_IMAGE_FORMAT, "Invalid assembly file format."); + CASE_OF(CORSEC_E_INVALID_PUBLICKEY, "Invalid assembly public key."); + CASE_OF(CORSEC_E_SIGNATURE_MISMATCH, "Signature size mismatch."); + CASE_OF(CORSEC_E_CRYPTO, "Failure during Cryptographic operation."); + CASE_OF(CORSEC_E_CRYPTO_UNEX_OPER, "Unexpected Cryptographic operation."); + CASE_OF(CORSECATTR_E_BAD_ACTION, "Invalid security action code."); + CASE_OF(COR_E_EXCEPTION, "General Exception"); + CASE_OF(COR_E_SYSTEM, "System.Exception"); + CASE_OF(COR_E_ARGUMENTOUTOFRANGE, "An argument was out of its legal range."); + CASE_OF(COR_E_ARRAYTYPEMISMATCH, "Attempted to store an object of the wrong type in an array."); + CASE_OF(COR_E_CONTEXTMARSHAL, "Attempted to marshal an object across a context boundary."); + CASE_OF(COR_E_TIMEOUT, "Operation timed out."); + CASE_OF(COR_E_EXECUTIONENGINE, "Internal CLR error."); + CASE_OF(COR_E_FIELDACCESS, "Access to this field is denied."); + CASE_OF(COR_E_INDEXOUTOFRANGE, "Array subscript out of range."); + CASE_OF(COR_E_INVALIDOPERATION, "An operation is not legal in the current state."); + CASE_OF(COR_E_SECURITY, "An error relating to security occurred."); + CASE_OF(COR_E_SERIALIZATION, "An error relating to serialization occurred."); + CASE_OF(COR_E_VERIFICATION, "A verification failure has occurred."); + CASE_OF(COR_E_METHODACCESS, "Access to this method is denied."); + CASE_OF(COR_E_MISSINGFIELD, "Field does not exist."); + CASE_OF(COR_E_MISSINGMEMBER, "Member does not exist."); + CASE_OF(COR_E_MISSINGMETHOD, "Method does not exist."); + CASE_OF(COR_E_MULTICASTNOTSUPPORTED, "Attempt to combine delegates that are not multicast."); + CASE_OF(COR_E_NOTSUPPORTED, "Operation is not supported."); + CASE_OF(COR_E_OVERFLOW, "Arithmetic, casting or conversion operation overflowed or underflowed."); + CASE_OF(COR_E_RANK, "An array has the wrong number of dimensions for a particular operation."); + CASE_OF(COR_E_SYNCHRONIZATIONLOCK, "This operation must be called from a synchronized block."); + CASE_OF(COR_E_THREADINTERRUPTED, "Thread was interrupted from a waiting state."); + CASE_OF(COR_E_MEMBERACCESS, "Access to this member is denied."); + CASE_OF(COR_E_THREADSTATE, "Thread is in an invalid state for this operation."); + CASE_OF(COR_E_THREADSTOP, "Thread is stopping."); + CASE_OF(COR_E_TYPELOAD, "Could not find or load a type."); + CASE_OF(COR_E_ENTRYPOINTNOTFOUND, "Could not find the specified DllImport entrypoint."); + CASE_OF(COR_E_DLLNOTFOUND, "Could not find the specified DllImport Dll."); + CASE_OF(COR_E_THREADSTART, "Indicate that a user thread fails to start."); + CASE_OF(COR_E_INVALIDCOMOBJECT, "An invalid __ComObject has been used."); + CASE_OF(COR_E_NOTFINITENUMBER, "Not a Number."); + CASE_OF(COR_E_DUPLICATEWAITOBJECT, "An object appears more than once in the wait objects array."); + CASE_OF(COR_E_SEMAPHOREFULL, "Reached maximum count for semaphore."); + CASE_OF(COR_E_WAITHANDLECANNOTBEOPENED, "No semaphore of the given name exists."); + CASE_OF(COR_E_ABANDONEDMUTEX, "The wait completed due to an abandoned mutex."); + CASE_OF(COR_E_THREADABORTED, "Thread has aborted."); + CASE_OF(COR_E_INVALIDOLEVARIANTTYPE, "OLE Variant has an invalid type."); + CASE_OF(COR_E_MISSINGMANIFESTRESOURCE, "An expected resource in the assembly manifest was missing."); + CASE_OF(COR_E_SAFEARRAYTYPEMISMATCH, "A mismatch has occurred between the runtime type of the array and the sub type recorded in the metadata."); + CASE_OF(COR_E_TYPEINITIALIZATION, "Uncaught exception during type initialization."); + CASE_OF(COR_E_MARSHALDIRECTIVE, "Invalid marshaling directives."); + CASE_OF(COR_E_MISSINGSATELLITEASSEMBLY, "An expected satellite assembly containing the ultimate fallback resources for a given culture was not found or could not be loaded."); + CASE_OF(COR_E_FORMAT, "The format of one argument does not meet the contract of the method."); + CASE_OF(COR_E_SAFEARRAYRANKMISMATCH, "A mismatch has occurred between the runtime rank of the array and the rank recorded in the metadata."); + CASE_OF(COR_E_PLATFORMNOTSUPPORTED, "Operation is not supported on this platform."); + CASE_OF(COR_E_INVALIDPROGRAM, "Invalid IL or CLR metadata."); + CASE_OF(COR_E_OPERATIONCANCELED, "The operation was cancelled."); + CASE_OF(COR_E_INSUFFICIENTMEMORY, "Not enough memory was available for an operation."); + CASE_OF(COR_E_RUNTIMEWRAPPED, "An object that does not derive from System.Exception has been wrapped in a RuntimeWrappedException."); + CASE_OF(COR_E_DATAMISALIGNED, "A datatype misalignment was detected in a load or store instruction."); + CASE_OF(COR_E_CODECONTRACTFAILED, "A managed code contract (ie, precondition, postcondition, invariant, or assert) failed."); + CASE_OF(COR_E_TYPEACCESS, "Access to this type is denied."); + CASE_OF(COR_E_ACCESSING_CCW, "Fail to access a CCW because the corresponding managed object is already collected."); + CASE_OF(COR_E_KEYNOTFOUND, "The given key was not present in the dictionary."); + CASE_OF(COR_E_INSUFFICIENTEXECUTIONSTACK, "Insufficient stack to continue executing the program safely. This can happen from having too many functions on the call stack or function on the stack using too much stack space."); + CASE_OF(COR_E_APPLICATION, "Application exception"); + CASE_OF(COR_E_INVALIDFILTERCRITERIA, "The given filter criteria does not match the filter content."); + CASE_OF(COR_E_REFLECTIONTYPELOAD, "Could not find or load a specific class that was requested through Reflection."); + CASE_OF(COR_E_TARGET, "Attempt to invoke non-static method with a null Object."); + CASE_OF(COR_E_TARGETINVOCATION, "Uncaught exception thrown by method called through Reflection."); + CASE_OF(COR_E_CUSTOMATTRIBUTEFORMAT, "Custom attribute has invalid format."); + CASE_OF(COR_E_IO, "Error during managed I/O."); + CASE_OF(COR_E_FILELOAD, "Could not find or load a specific file."); + CASE_OF(COR_E_OBJECTDISPOSED, "The object has already been disposed."); + CASE_OF(COR_E_FAILFAST, "Runtime operation halted by call to System.Environment.FailFast()."); + CASE_OF(COR_E_HOSTPROTECTION, "The host has forbidden this operation."); + CASE_OF(COR_E_ILLEGAL_REENTRANCY, "Attempted to call into managed code when executing inside a low level extensibility point."); + CASE_OF(CLR_E_SHIM_RUNTIMELOAD, "Failed to load the runtime."); + CASE_OF(CLR_E_SHIM_LEGACYRUNTIMEALREADYBOUND, "A runtime has already been bound for legacy activation policy use."); + CASE_OF(VER_E_FIELD_SIG, "[field sig]"); + CASE_OF(VER_E_CIRCULAR_VAR_CONSTRAINTS, "Method parent has circular class type parameter constraints."); + CASE_OF(VER_E_CIRCULAR_MVAR_CONSTRAINTS, "Method has circular method type parameter constraints."); + CASE_OF(COR_E_Data, "COR_E_Data"); + CASE_OF(VLDTR_E_SIG_BADVOID, "Illegal 'void' in signature."); + CASE_OF(VLDTR_E_GP_ILLEGAL_VARIANT_MVAR, "GenericParam is a method type parameter and must be non-variant."); + CASE_OF(CORDBG_E_THREAD_NOT_SCHEDULED, "Thread is not scheduled. Thus we may not have OSThreadId, handle, or context."); + CASE_OF(CORDBG_E_HANDLE_HAS_BEEN_DISPOSED, "Handle has been disposed."); + CASE_OF(CORDBG_E_NONINTERCEPTABLE_EXCEPTION, "Cannot intercept this exception."); + CASE_OF(CORDBG_E_INTERCEPT_FRAME_ALREADY_SET, "The intercept frame for this exception has already been set."); + CASE_OF(CORDBG_E_NO_NATIVE_PATCH_AT_ADDR, "There is no native patch at the given address."); + CASE_OF(CORDBG_E_MUST_BE_INTEROP_DEBUGGING, "This API is only allowed when interop debugging."); + CASE_OF(CORDBG_E_NATIVE_PATCH_ALREADY_AT_ADDR, "There is already a native patch at the address."); + CASE_OF(CORDBG_E_TIMEOUT, "A wait timed out, likely an indication of deadlock."); + CASE_OF(CORDBG_E_CANT_CALL_ON_THIS_THREAD, "Cannot use the API on this thread."); + CASE_OF(CORDBG_E_ENC_INFOLESS_METHOD, "Method was not JIT'd in EnC mode."); + CASE_OF(CORDBG_E_ENC_IN_FUNCLET, "Method is in a callable handler/filter. Cannot increase stack."); + CASE_OF(CORDBG_E_ENC_EDIT_NOT_SUPPORTED, "Attempt to perform unsupported edit."); + CASE_OF(CORDBG_E_NOTREADY, "The LS is not in a good spot to perform the requested operation."); + CASE_OF(CORDBG_E_CANNOT_RESOLVE_ASSEMBLY, "We failed to resolve assembly given an AssemblyRef token. Assembly may be not loaded yet or not a valid token."); + CASE_OF(CORDBG_E_MUST_BE_IN_LOAD_MODULE, "Must be in context of LoadModule callback to perform requested operation."); + CASE_OF(CORDBG_E_CANNOT_BE_ON_ATTACH, "Requested operation cannot be performed during an attach operation."); + CASE_OF(CORDBG_E_NGEN_NOT_SUPPORTED, "NGEN must be supported to perform the requested operation."); + CASE_OF(CORDBG_E_ILLEGAL_SHUTDOWN_ORDER, "Trying to shutdown out of order."); + CASE_OF(CORDBG_E_CANNOT_DEBUG_FIBER_PROCESS, "Debugging fiber mode managed process is not supported."); + CASE_OF(CORDBG_E_MUST_BE_IN_CREATE_PROCESS, "Must be in context of CreateProcess callback to perform requested operation."); + CASE_OF(CORDBG_E_DETACH_FAILED_OUTSTANDING_EVALS, "All outstanding func-evals have not completed, detaching is not allowed at this time."); + CASE_OF(CORDBG_E_DETACH_FAILED_OUTSTANDING_STEPPERS, "All outstanding steppers have not been closed, detaching is not allowed at this time."); + CASE_OF(CORDBG_E_CANT_INTEROP_STEP_OUT, "Cannot have an ICorDebugStepper do a native step-out."); + CASE_OF(CORDBG_E_DETACH_FAILED_OUTSTANDING_BREAKPOINTS, "All outstanding breakpoints have not been closed, detaching is not allowed at this time."); + CASE_OF(CORDBG_E_ILLEGAL_IN_STACK_OVERFLOW, "The operation is illegal because of a stack overflow."); + CASE_OF(CORDBG_E_ILLEGAL_AT_GC_UNSAFE_POINT, "The operation failed because it is a GC unsafe point."); + CASE_OF(CORDBG_E_ILLEGAL_IN_PROLOG, "The operation failed because the thread is in the prolog."); + CASE_OF(CORDBG_E_ILLEGAL_IN_NATIVE_CODE, "The operation failed because the thread is in native code."); + CASE_OF(CORDBG_E_ILLEGAL_IN_OPTIMIZED_CODE, "The operation failed because the thread is in optimized code."); + CASE_OF(CORDBG_E_APPDOMAIN_MISMATCH, "A supplied object or type belongs to the wrong AppDomain."); + CASE_OF(CORDBG_E_CONTEXT_UNVAILABLE, "The thread's context is not available."); + CASE_OF(CORDBG_E_UNCOMPATIBLE_PLATFORMS, "The operation failed because debuggee and debugger are on incompatible platforms."); + CASE_OF(CORDBG_E_DEBUGGING_DISABLED, "The operation failed because the debugging has been disabled"); + CASE_OF(CORDBG_E_DETACH_FAILED_ON_ENC, "Detach is illegal after an Edit and Continue on a module."); + CASE_OF(CORDBG_E_CURRENT_EXCEPTION_IS_OUTSIDE_CURRENT_EXECUTION_SCOPE, "Cannot intercept the current exception at the specified frame."); + CASE_OF(CORDBG_E_HELPER_MAY_DEADLOCK, "The debugger helper thread cannot obtain the locks it needs to perform this operation."); + CASE_OF(CORDBG_E_MISSING_METADATA, "The operation failed because the debugger could not get the metadata."); + CASE_OF(CORDBG_E_TARGET_INCONSISTENT, "The debuggee is in a corrupt state."); + CASE_OF(CORDBG_E_DETACH_FAILED_OUTSTANDING_TARGET_RESOURCES, "Detach failed because there are outstanding resources in the target."); + CASE_OF(CORDBG_E_TARGET_READONLY, "The debuggee is read-only."); + CASE_OF(CORDBG_E_MISMATCHED_CORWKS_AND_DACWKS_DLLS, "The version of clr.dll in the target does not match the one mscordacwks.dll was built for."); + CASE_OF(CORDBG_E_MODULE_LOADED_FROM_DISK, "Symbols are not supplied for modules loaded from disk."); + CASE_OF(CORDBG_E_SYMBOLS_NOT_AVAILABLE, "The application did not supply symbols when it loaded or created this module, or they are not yet available."); + CASE_OF(CORDBG_E_DEBUG_COMPONENT_MISSING, "A debug component is not installed."); + CASE_OF(CORDBG_E_LIBRARY_PROVIDER_ERROR, "The ICLRDebuggingLibraryProvider callback returned an error or did not provide a valid handle."); + CASE_OF(CORDBG_E_NOT_CLR, "The module at the base address indicated was not recognized as a CLR"); + CASE_OF(CORDBG_E_MISSING_DATA_TARGET_INTERFACE, "The provided data target does not implement the required interfaces for this version of the runtime"); + CASE_OF(CORDBG_E_UNSUPPORTED_DEBUGGING_MODEL, "This debugging model is unsupported by the specified runtime"); + CASE_OF(CORDBG_E_UNSUPPORTED_FORWARD_COMPAT, "The debugger is not designed to support the version of the CLR the debuggee is using."); + CASE_OF(CORDBG_E_UNSUPPORTED_VERSION_STRUCT, "The version struct has an unrecognized value for wStructVersion"); + CASE_OF(CORDBG_E_READVIRTUAL_FAILURE, "A call into a ReadVirtual implementation returned failure"); + CASE_OF(CORDBG_E_VALUE_POINTS_TO_FUNCTION, "The Debugging API doesn't support dereferencing function pointers."); + CASE_OF(CORDBG_E_CORRUPT_OBJECT, "The address provided does not point to a valid managed object."); + CASE_OF(CORDBG_E_GC_STRUCTURES_INVALID, "The GC heap structures are not in a valid state for traversal."); + CASE_OF(CORDBG_E_INVALID_OPCODE, "The specified IL offset or opcode is not supported for this operation."); + CASE_OF(CORDBG_E_UNSUPPORTED, "The specified action is unsupported by this version of the runtime."); + CASE_OF(CORDBG_E_MISSING_DEBUGGER_EXPORTS, "The debuggee memory space does not have the expected debugging export table."); + CASE_OF(CORDBG_E_DATA_TARGET_ERROR, "Failure when calling a data target method."); + CASE_OF(CORDBG_E_NO_IMAGE_AVAILABLE, "Couldn't find a native image."); + CASE_OF(CORDBG_E_UNSUPPORTED_DELEGATE, "The delegate contains a delegate currently not supported by the API."); + CASE_OF(PEFMT_E_64BIT, "File is PE32+."); + CASE_OF(PEFMT_E_32BIT, "File is PE32"); + CASE_OF(NGEN_E_SYS_ASM_NI_MISSING, "NGen cannot proceed because Mscorlib.dll does not have a native image"); + CASE_OF(CLDB_E_INTERNALERROR, "CLDB_E_INTERNALERROR"); + CASE_OF(CLR_E_BIND_ASSEMBLY_VERSION_TOO_LOW, "The bound assembly has a version that is lower than that of the request."); + CASE_OF(CLR_E_BIND_ASSEMBLY_PUBLIC_KEY_MISMATCH, "The assembly version has a public key token that does not match that of the request."); + CASE_OF(CLR_E_BIND_IMAGE_UNAVAILABLE, "The requested image was not found or is unavailable."); + CASE_OF(CLR_E_BIND_UNRECOGNIZED_IDENTITY_FORMAT, "The provided identity format is not recognized."); + CASE_OF(CLR_E_BIND_ASSEMBLY_NOT_FOUND, "A binding for the specified assembly name was not found."); + CASE_OF(CLR_E_BIND_TYPE_NOT_FOUND, "A binding for the specified type name was not found."); + CASE_OF(CLR_E_BIND_SYS_ASM_NI_MISSING, "Could not use native image because Mscorlib.dll is missing a native image"); + CASE_OF(CLR_E_BIND_NI_SECURITY_FAILURE, "Native image was generated in a different trust level than present at runtime"); + CASE_OF(CLR_E_BIND_NI_DEP_IDENTITY_MISMATCH, "Native image identity mismatch with respect to its dependencies"); + CASE_OF(CLR_E_GC_OOM, "Failfast due to an OOM during a GC"); + CASE_OF(CLR_E_GC_BAD_AFFINITY_CONFIG, "GCHeapAffinitizeMask or GCHeapAffinitizeRanges didn't specify any CPUs the current process is affinitized to."); + CASE_OF(CLR_E_GC_BAD_AFFINITY_CONFIG_FORMAT, "GCHeapAffinitizeRanges configuration string has invalid format."); + CASE_OF(CLR_E_CROSSGEN_NO_IBC_DATA_FOUND, "Cannot compile using the PartialNgen flag because no IBC data was found."); + CASE_OF(COR_E_UNAUTHORIZEDACCESS, "Access is denied."); + CASE_OF(COR_E_ARGUMENT, "An argument does not meet the contract of the method."); + CASE_OF(COR_E_INVALIDCAST, "Indicates a bad cast condition"); + CASE_OF(COR_E_OUTOFMEMORY, "The EE thows this exception when no more memory is avaible to continue execution"); + CASE_OF(COR_E_NULLREFERENCE, "Dereferencing a null reference. In general class libraries should not throw this"); + CASE_OF(COR_E_ARITHMETIC, "Overflow or underflow in mathematical operations."); + CASE_OF(COR_E_PATHTOOLONG, "The specified path was too long."); + CASE_OF(COR_E_FILENOTFOUND, "COR_E_FILENOTFOUND"); + CASE_OF(COR_E_ENDOFSTREAM, "Thrown when the End of file is reached"); + CASE_OF(COR_E_DIRECTORYNOTFOUND, "The specified path couldn't be found."); + CASE_OF(COR_E_STACKOVERFLOW, "Is raised by the EE when the execution stack overflows as it is attempting to ex"); + CASE_OF(COR_E_AMBIGUOUSMATCH, "While late binding to a method via reflection, could not resolve between"); + CASE_OF(COR_E_TARGETPARAMCOUNT, "There was a mismatch between number of arguments provided and the number expected"); + CASE_OF(COR_E_DIVIDEBYZERO, "Attempted to divide a number by zero."); + CASE_OF(COR_E_BADIMAGEFORMAT, "The format of a DLL or executable being loaded is invalid."); + default: + str = "Unknown HRESULT code"; + break; + } + return str; +} diff --git a/src/debug/netcoredbg/cputil.h b/src/debug/netcoredbg/cputil.h index cb46515..a983271 100644 --- a/src/debug/netcoredbg/cputil.h +++ b/src/debug/netcoredbg/cputil.h @@ -5,6 +5,7 @@ #include #include +#include #ifdef _MSC_VER std::string to_utf8(const wchar_t *wstr); @@ -16,3 +17,6 @@ std::u16string to_utf16(const std::string &utf8); std::string to_utf8(char16_t wch); std::vector split_on_tokens(const std::string &str, const char delim); + +const char* errormessage(HRESULT hr); + diff --git a/src/debug/netcoredbg/manageddebugger.cpp b/src/debug/netcoredbg/manageddebugger.cpp index 0781d88..c02ec30 100644 --- a/src/debug/netcoredbg/manageddebugger.cpp +++ b/src/debug/netcoredbg/manageddebugger.cpp @@ -1320,6 +1320,8 @@ HRESULT ManagedDebugger::StepCommand(int threadId, StepType stepType) { LogFuncEntry(); + if (!m_pProcess) + return E_FAIL; HRESULT Status; ToRelease pThread; IfFailRet(m_pProcess->GetThread(threadId, &pThread));