src\shared\inc\readytoruninstructionset.h = src\shared\inc\readytoruninstructionset.h
src\shared\inc\regdisp.h = src\shared\inc\regdisp.h
src\shared\inc\registrywrapper.h = src\shared\inc\registrywrapper.h
- src\shared\inc\releaseholder.h = src\shared\inc\releaseholder.h
src\shared\inc\resource.h = src\shared\inc\resource.h
src\shared\inc\runtimeinfo.h = src\shared\inc\runtimeinfo.h
src\shared\inc\safemath.h = src\shared\inc\safemath.h
src\shared\native\minipal\utils.h = src\shared\native\minipal\utils.h
EndProjectSection
EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "inc", "inc", "{9E51C821-4095-4250-BD8A-2A29396DB1B4}"
+ ProjectSection(SolutionItems) = preProject
+ src\inc\corcompile.h = src\inc\corcompile.h
+ src\inc\ntimageex.h = src\inc\ntimageex.h
+ src\inc\releaseholder.h = src\inc\releaseholder.h
+ src\inc\stacktrace.h = src\inc\stacktrace.h
+ EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "rt", "rt", "{D2D76252-D225-4B79-9DDB-A36867A4720E}"
+ ProjectSection(SolutionItems) = preProject
+ src\inc\rt\intsafe.h = src\inc\rt\intsafe.h
+ src\inc\rt\oaidl.h = src\inc\rt\oaidl.h
+ src\inc\rt\psapi.h = src\inc\rt\psapi.h
+ src\inc\rt\tchar.h = src\inc\rt\tchar.h
+ src\inc\rt\tlhelp32.h = src\inc\rt\tlhelp32.h
+ src\inc\rt\winapifamily.h = src\inc\rt\winapifamily.h
+ src\inc\rt\winternl.h = src\inc\rt\winternl.h
+ src\inc\rt\winver.h = src\inc\rt\winver.h
+ EndProjectSection
+EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Checked|Any CPU = Checked|Any CPU
{06FB18BC-F4DD-4DB9-A566-551254CD1064} = {795B7A50-1B1F-406E-94E0-F9B35104EF22}
{641F00F0-2693-451B-A96A-13E4E115BF0F} = {7852EDE4-93DF-4DB1-8A86-C521703811AF}
{D9A91544-CDF8-4C68-BAD2-47F4968A8652} = {641F00F0-2693-451B-A96A-13E4E115BF0F}
+ {9E51C821-4095-4250-BD8A-2A29396DB1B4} = {19FAB78C-3351-4911-8F0C-8C6056401740}
+ {D2D76252-D225-4B79-9DDB-A36867A4720E} = {9E51C821-4095-4250-BD8A-2A29396DB1B4}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {46465737-C938-44FC-BE1A-4CE139EBB5E0}
<MicrosoftDotNetCodeAnalysisVersion>10.0.0-beta.24463.4</MicrosoftDotNetCodeAnalysisVersion>
<StyleCopAnalyzersVersion>1.2.0-beta.406</StyleCopAnalyzersVersion>
<MicrosoftDotNetRemoteExecutorVersion>7.0.0-beta.22316.2</MicrosoftDotNetRemoteExecutorVersion>
- <cdbsosversion>10.0.18362</cdbsosversion>
+ <cdbsosversion>10.0.26100.1</cdbsosversion>
<NewtonSoftJsonVersion>13.0.1</NewtonSoftJsonVersion>
<MicrosoftSourceBuildIntermediatesourcebuildreferencepackagesPackageVersion>10.0.0-alpha.1.24467.1</MicrosoftSourceBuildIntermediatesourcebuildreferencepackagesPackageVersion>
<!-- Roslyn and analyzers -->
add_compile_options(/Zl) # omit default library name in .OBJ
add_subdirectory(runcommand)
- if(NOT CLR_CMAKE_TARGET_ARCH_ARM64 AND NOT CLR_CMAKE_TARGET_ARCH_ARM)
+ if(NOT CLR_CMAKE_TARGET_ARCH_ARM)
add_subdirectory(SOS.UnitTests/Debuggees/DesktopClrHost)
- endif(NOT CLR_CMAKE_TARGET_ARCH_ARM64 AND NOT CLR_CMAKE_TARGET_ARCH_ARM)
+ endif(NOT CLR_CMAKE_TARGET_ARCH_ARM)
endif(CLR_CMAKE_HOST_WIN32)
add_compile_definitions(STRESS_LOG_ANALYZER)
return VTable.GetDebuggeeType(Self, out debugClass, out qualifier);
}
- public HResult GetExecutingProcessorType(out IMAGE_FILE_MACHINE type)
+ public HResult GetProcessorType(out IMAGE_FILE_MACHINE type)
{
- return VTable.GetExecutingProcessorType(Self, out type);
+ return VTable.GetProcessorType(Self, out type);
}
public HResult AddCommand(string command, string help, IEnumerable<string> aliases)
{
public readonly delegate* unmanaged[Stdcall]<IntPtr, out OperatingSystem, int> GetOperatingSystem;
public readonly delegate* unmanaged[Stdcall]<IntPtr, out DEBUG_CLASS, out DEBUG_CLASS_QUALIFIER, int> GetDebuggeeType;
- public readonly delegate* unmanaged[Stdcall]<IntPtr, out IMAGE_FILE_MACHINE, int> GetExecutingProcessorType;
+ public readonly delegate* unmanaged[Stdcall]<IntPtr, out IMAGE_FILE_MACHINE, int> GetProcessorType;
public readonly delegate* unmanaged[Stdcall]<IntPtr, byte*, byte*, IntPtr*, int, int> AddCommand;
public readonly delegate* unmanaged[Stdcall]<IntPtr, DEBUG_OUTPUT, byte*, void> OutputString;
public readonly delegate* unmanaged[Stdcall]<IntPtr, ulong, byte*, uint, out int, int> ReadVirtual;
IsDump = true;
}
- hr = debuggerServices.GetExecutingProcessorType(out IMAGE_FILE_MACHINE type);
+ hr = debuggerServices.GetProcessorType(out IMAGE_FILE_MACHINE type);
if (hr == HResult.S_OK)
{
+ Debug.Assert(type is not IMAGE_FILE_MACHINE.ARM64X and not IMAGE_FILE_MACHINE.ARM64EC);
Architecture = type switch
{
IMAGE_FILE_MACHINE.I386 => Architecture.X86,
}
else
{
- throw new PlatformNotSupportedException($"GetExecutingProcessorType() FAILED {hr:X8}");
+ throw new PlatformNotSupportedException($"GetProcessorType() FAILED {hr:X8}");
}
hr = debuggerServices.GetCurrentProcessId(out uint processId);
builder.AddMethod(new GetReturnOffsetDelegate((self, offset) => DebugClient.NotImplemented));
builder.AddMethod(new OutputStackTraceDelegate((self, outputControl, frames, frameSize, flags) => DebugClient.NotImplemented));
builder.AddMethod(new GetDebuggeeTypeDelegate(soshost.GetDebuggeeType));
- builder.AddMethod(new GetActualProcessorTypeDelegate((self, type) => DebugClient.NotImplemented));
+ builder.AddMethod(new GetActualProcessorTypeDelegate(soshost.GetExecutingProcessorType));
builder.AddMethod(new GetExecutingProcessorTypeDelegate(soshost.GetExecutingProcessorType));
builder.AddMethod(new GetNumberPossibleExecutingProcessorTypesDelegate((self, number) => DebugClient.NotImplemented));
builder.AddMethod(new GetPossibleExecutingProcessorTypesDelegate((self, start, count, types) => DebugClient.NotImplemented));
AMD64 = 0x8664, // AMD64 (K8)
M32R = 0x9041, // M32R little-endian
ARM64 = 0xAA64, // ARM64 Little-endian
+ ARM64EC = 0xA641,
+ ARM64X = 0xA64E,
CEE = 0xC0EE,
LOONGARCH64 = 0x6264,
RISCV64 = 0x5064
IntPtr self,
IMAGE_FILE_MACHINE* type)
{
- switch (Target.Architecture)
- {
- case Architecture.X64:
- *type = IMAGE_FILE_MACHINE.AMD64;
- break;
- case Architecture.X86:
- *type = IMAGE_FILE_MACHINE.I386;
- break;
- case Architecture.Arm:
- *type = IMAGE_FILE_MACHINE.ARMNT;
- break;
- case Architecture.Arm64:
- *type = IMAGE_FILE_MACHINE.ARM64;
- break;
- case (Architecture)6 /* Architecture.LoongArch64 */:
- *type = IMAGE_FILE_MACHINE.LOONGARCH64;
- break;
- case (Architecture)9 /* Architecture.RiscV64 */:
- *type = IMAGE_FILE_MACHINE.RISCV64;
- break;
- default:
- *type = IMAGE_FILE_MACHINE.UNKNOWN;
- break;
- }
+ *type = Target.Architecture switch
+ {
+ Architecture.X64 => IMAGE_FILE_MACHINE.AMD64,
+ Architecture.X86 => IMAGE_FILE_MACHINE.I386,
+ Architecture.Arm => IMAGE_FILE_MACHINE.ARMNT,
+ Architecture.Arm64 => IMAGE_FILE_MACHINE.ARM64,
+ (Architecture)6 /* Architecture.LoongArch64 */=> IMAGE_FILE_MACHINE.LOONGARCH64,
+ (Architecture)9 /* Architecture.RiscV64 */=> IMAGE_FILE_MACHINE.RISCV64,
+ _ => IMAGE_FILE_MACHINE.UNKNOWN,
+ };
return HResult.S_OK;
}
<Option>
<SetHostRuntime>$(DotNetRoot)/shared/Microsoft.NETCore.App/$(RuntimeFrameworkVersion)</SetHostRuntime>
</Option>
- <Option>
+ <Option Condition="'$(TargetArchitecture)' != 'arm64'">
<SetHostRuntime>-netfx</SetHostRuntime>
</Option>
</Options>
message(STATUS "CLR_CMAKE_HOST_ARCH_AMD64")
add_definitions(-DSOS_TARGET_AMD64=1)
add_definitions(-D_TARGET_WIN64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_AMD64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
if (CLR_CMAKE_HOST_WIN32)
add_definitions(-DSOS_TARGET_ARM64=1)
endif(CLR_CMAKE_HOST_WIN32)
add_definitions(-DSOS_TARGET_X86=1)
add_definitions(-D_TARGET_X86_=1)
add_definitions(-DTARGET_X86)
- add_definitions(-DDBG_TARGET_X86=1)
- add_definitions(-DDBG_TARGET_32BIT=1)
if (CLR_CMAKE_HOST_WIN32)
add_definitions(-DSOS_TARGET_ARM=1)
endif(CLR_CMAKE_HOST_WIN32)
elseif(CLR_CMAKE_HOST_ARCH_ARM)
message(STATUS "CLR_CMAKE_HOST_ARCH_ARM")
add_definitions(-DSOS_TARGET_ARM=1)
- add_definitions(-D_TARGET_WIN32_=1)
add_definitions(-D_TARGET_ARM_=1)
- add_definitions(-DDBG_TARGET_ARM=1)
- add_definitions(-DDBG_TARGET_32BIT=1)
elseif(CLR_CMAKE_HOST_ARCH_ARM64)
message(STATUS "CLR_CMAKE_HOST_ARCH_ARM64")
add_definitions(-DSOS_TARGET_ARM64=1)
add_definitions(-D_TARGET_WIN64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_ARM64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
elseif(CLR_CMAKE_HOST_ARCH_MIPS64)
add_definitions(-DSOS_TARGET_MIPS64=1)
add_definitions(-D_TARGET_WIN64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_MIPS64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
elseif(CLR_CMAKE_HOST_ARCH_RISCV64)
add_definitions(-DSOS_TARGET_RISCV64=1)
add_definitions(-D_TARGET_WIN64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_RISCV64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
elseif(CLR_CMAKE_HOST_ARCH_LOONGARCH64)
add_definitions(-DSOS_TARGET_LOONGARCH64=1)
add_definitions(-D_TARGET_WIN64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_LOONGARCH64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
endif()
add_definitions(-DSTRIKE)
}
switch (m_processorType)
{
- case IMAGE_FILE_MACHINE_ARM64:
case IMAGE_FILE_MACHINE_AMD64:
+ case IMAGE_FILE_MACHINE_ARM64:
+ case IMAGE_FILE_MACHINE_ARM64X:
+ case IMAGE_FILE_MACHINE_ARM64EC:
case IMAGE_FILE_MACHINE_LOONGARCH64:
case IMAGE_FILE_MACHINE_RISCV64:
m_pointerSize = 8;
#include <clrma.h> // IDL
#include <clrmaservice.h>
#include <dbgtargetcontext.h>
+#include <ntimageex.h>
#include <corhdr.h>
#include <cordebug.h>
#include <xclrdata.h>
#include <runtime.h>
#include <vector>
-#ifndef IMAGE_FILE_MACHINE_RISCV64
-#define IMAGE_FILE_MACHINE_RISCV64 0x5064 // RISCV64
-#endif
-
-#ifndef IMAGE_FILE_MACHINE_LOONGARCH64
-#define IMAGE_FILE_MACHINE_LOONGARCH64 0x6264 // LOONGARCH64
-#endif
-
enum ClrmaGlobalFlags
{
LoggingEnabled = 0x01, // CLRMA logging enabled
}
HRESULT
-DbgEngServices::GetExecutingProcessorType(
+DbgEngServices::GetProcessorType(
PULONG type)
{
- return m_control->GetExecutingProcessorType(type);
+ ULONG executingType;
+ HRESULT hr = m_control->GetExecutingProcessorType(&executingType);
+ if (FAILED(hr))
+ {
+ return hr;
+ }
+ _ASSERTE(executingType != IMAGE_FILE_MACHINE_ARM64X);
+ *type = executingType;
+#if defined(SOS_TARGET_AMD64) || defined(SOS_TARGET_ARM64)
+ if (executingType == IMAGE_FILE_MACHINE_ARM64EC)
+ {
+ *type = IMAGE_FILE_MACHINE_AMD64;
+ }
+#endif // defined(SOS_TARGET_AMD64) || defined(SOS_TARGET_ARM64)
+ return S_OK;
}
HRESULT
PULONG debugClass,
PULONG qualifier);
- HRESULT STDMETHODCALLTYPE GetExecutingProcessorType(
+ HRESULT STDMETHODCALLTYPE GetProcessorType(
PULONG type);
HRESULT STDMETHODCALLTYPE AddCommand(
//
#ifdef _WIN64
- ExtOut("%08x`%08x ", (ULONG)(InstrAddr >> 32), (ULONG)InstrAddr);
+ if (GetHost()->GetHostType() == IHost::HostType::DbgEng)
+ {
+ ExtOut("%08x`%08x ", (ULONG)(InstrAddr >> 32), (ULONG)InstrAddr);
+ }
+ else
+ {
+ ExtOut("%016llx ", InstrAddr);
+ }
#else
ExtOut("%08x ", (ULONG)InstrAddr);
#endif
targetMachine = ARM64Machine::GetInstance();
}
#endif // SOS_TARGET_ARM64
+ _ASSERTE(processorType != IMAGE_FILE_MACHINE_ARM64X);
+#if defined(SOS_TARGET_AMD64) || defined(SOS_TARGET_ARM64)
+ if (processorType == IMAGE_FILE_MACHINE_ARM64EC)
+ {
+#ifdef SOS_TARGET_AMD64
+ targetMachine = AMD64Machine::GetInstance();
+#endif // SOS_TARGET_AMD64
+ }
+#endif // defined(SOS_TARGET_AMD64) || defined(SOS_TARGET_ARM64)
#ifdef SOS_TARGET_RISCV64
if (processorType == IMAGE_FILE_MACHINE_RISCV64)
{
return targetMachine;
}
+const char*
+GetProcessorName(ULONG type)
+{
+ const char* architecture = "unknown";
+ switch (type)
+ {
+ case IMAGE_FILE_MACHINE_AMD64:
+ architecture = "x64";
+ break;
+ case IMAGE_FILE_MACHINE_I386:
+ architecture = "x86";
+ break;
+ case IMAGE_FILE_MACHINE_ARM:
+ architecture = "arm";
+ break;
+ case IMAGE_FILE_MACHINE_THUMB:
+ architecture = "thumb";
+ break;
+ case IMAGE_FILE_MACHINE_ARMNT:
+ architecture = "armnt";
+ break;
+ case IMAGE_FILE_MACHINE_ARM64:
+ architecture = "arm64";
+ break;
+ case IMAGE_FILE_MACHINE_ARM64EC:
+ architecture = "arm64ec";
+ break;
+ case IMAGE_FILE_MACHINE_ARM64X:
+ architecture = "arm64x";
+ break;
+ case IMAGE_FILE_MACHINE_RISCV64:
+ architecture = "riscv64";
+ break;
+ case IMAGE_FILE_MACHINE_LOONGARCH64:
+ architecture = "loongarch64";
+ break;
+ }
+ return architecture;
+}
+
HRESULT
ArchQuery(void)
{
g_targetMachine = GetTargetMachine(processorType);
if (g_targetMachine == NULL)
{
- const char* architecture = "";
- switch (processorType)
+ const char* architecture = GetProcessorName(processorType);
+ const char* message = "";
+#if defined(SOS_TARGET_AMD64) || defined(SOS_TARGET_ARM64)
+ if (processorType == IMAGE_FILE_MACHINE_ARM64EC)
+ {
+ message = "Arm64ec targets require a x64 compatible SOS and debugger.";
+ }
+ else
+#endif
{
- case IMAGE_FILE_MACHINE_AMD64:
- architecture = "x64";
- break;
- case IMAGE_FILE_MACHINE_I386:
- architecture = "x86";
- break;
- case IMAGE_FILE_MACHINE_ARM:
- case IMAGE_FILE_MACHINE_THUMB:
- case IMAGE_FILE_MACHINE_ARMNT:
- architecture = "arm32";
- break;
- case IMAGE_FILE_MACHINE_ARM64:
- architecture = "arm64";
- break;
- case IMAGE_FILE_MACHINE_RISCV64:
- architecture = "riscv64";
- break;
- case IMAGE_FILE_MACHINE_LOONGARCH64:
- architecture = "loongarch64";
- break;
+ message = "A 32 bit target may require a 32 bit debugger or vice versa. In general, try to use the same bitness for the debugger and target process.";
}
- ExtErr("SOS does not support the current target architecture '%s' (0x%04x). A 32 bit target may require a 32 bit debugger or vice versa. In general, try to use the same bitness for the debugger and target process.\n",
- architecture, processorType);
+ ExtErr("SOS does not support the current target architecture '%s' (0x%04x). %s\n", architecture, processorType, message);
return E_FAIL;
}
return S_OK;
// printing CDA values.
#define CDA_TO_UL64(cda) ((ULONG64)(TO_TADDR(cda)))
-#ifndef IMAGE_FILE_MACHINE_RISCV64
-#define IMAGE_FILE_MACHINE_RISCV64 0x5064 // RISCV64
-#endif // !IMAGE_FILE_MACHINE_RISCV64
-
-#ifndef IMAGE_FILE_MACHINE_LOONGARCH64
-#define IMAGE_FILE_MACHINE_LOONGARCH64 0x6264 // LOONGARCH64
-#endif // !IMAGE_FILE_MACHINE_LOONGARCH64
-
typedef struct _TADDR_RANGE
{
TADDR start;
HRESULT
ExtInit(PDEBUG_CLIENT client);
+const char*
+GetProcessorName(ULONG type);
+
HRESULT
ArchQuery(void);
// The main debugger code already has target platform definitions for CONTEXT.
#include <dbgtargetcontext.h>
+#include <ntimageex.h>
#ifndef FEATURE_PAL
#define DT_GDI_HANDLE_BUFFER_SIZE32 34
#define DT_GDI_HANDLE_BUFFER_SIZE64 60
-#ifndef IMAGE_FILE_MACHINE_ARMNT
-#define IMAGE_FILE_MACHINE_ARMNT 0x01c4 // ARM Thumb-2 Little-Endian
-#endif
-
-#ifndef IMAGE_FILE_MACHINE_ARM64
-#define IMAGE_FILE_MACHINE_ARM64 0xAA64 // ARM64 Little-Endian
-#endif
-
#ifdef _TARGET_WIN64_
typedef ULONG DT_GDI_HANDLE_BUFFER[DT_GDI_HANDLE_BUFFER_SIZE64];
#else
pe=PrintException
printexception=PrintException
Printexception=PrintException
+ processor
SaveModule
savemodule=SaveModule
SetHostRuntime
return S_OK;
}
+DECLARE_API(processor)
+{
+ INIT_API_EXT();
+ ULONG executingType;
+ if (SUCCEEDED(g_ExtControl->GetExecutingProcessorType(&executingType)))
+ {
+ ExtOut("Executing processor type: %04x '%s'\n", executingType, GetProcessorName(executingType));
+ }
+ ULONG actualType;
+ if (SUCCEEDED(g_ExtControl->GetActualProcessorType(&actualType)))
+ {
+ ExtOut("Actual processor type: %04x '%s'\n", actualType, GetProcessorName(actualType));
+ }
+ ULONG effectiveType;
+ if (SUCCEEDED(g_ExtControl->GetEffectiveProcessorType(&effectiveType)))
+ {
+ ExtOut("Effective processor type: %04x '%s'\n", effectiveType, GetProcessorName(effectiveType));
+ }
+ return S_OK;
+}
+
#endif // FEATURE_PAL
//
GetExecutingProcessorType(
PULONG type)
{
- return m_lldbservices->GetExecutingProcessorType(type);
+ return m_lldbservices->GetProcessorType(type);
+ }
+
+ HRESULT
+ GetActualProcessorType(
+ PULONG type)
+ {
+ return m_lldbservices->GetProcessorType(type);
}
HRESULT
PULONG debugClass,
PULONG qualifier) = 0;
- virtual HRESULT STDMETHODCALLTYPE GetExecutingProcessorType(
+ virtual HRESULT STDMETHODCALLTYPE GetProcessorType(
PULONG type) = 0;
virtual HRESULT STDMETHODCALLTYPE AddCommand(
// Returns the type of processor used in the
// current processor context.
- virtual HRESULT STDMETHODCALLTYPE GetExecutingProcessorType(
+ virtual HRESULT STDMETHODCALLTYPE GetProcessorType(
PULONG type) = 0;
// Executes the given command string.
set(REQUIRE_LLDBPLUGIN false)
endif()
-if(CLR_CMAKE_HOST_ARCH_AMD64)
- add_definitions(-D_TARGET_AMD64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_AMD64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
- add_definitions(-DBIT64)
-elseif(CLR_CMAKE_HOST_ARCH_I386)
- add_definitions(-D_TARGET_X86_=1)
- add_definitions(-DDBG_TARGET_32BIT=1)
- add_definitions(-DDBG_TARGET_X86=1)
-elseif(CLR_CMAKE_HOST_ARCH_ARM)
- add_definitions(-D_TARGET_ARM_=1)
- add_definitions(-DDBG_TARGET_32BIT=1)
- add_definitions(-DDBG_TARGET_ARM=1)
-elseif(CLR_CMAKE_HOST_ARCH_ARM64)
- add_definitions(-D_TARGET_ARM64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_ARM64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
- add_definitions(-DBIT64)
- SET(REQUIRE_LLDBPLUGIN false)
-elseif(CLR_CMAKE_HOST_ARCH_MIPS64)
- add_definitions(-D_TARGET_MIPS64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_MIPS64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
- add_definitions(-DBIT64)
- SET(REQUIRE_LLDBPLUGIN false)
-elseif(CLR_CMAKE_HOST_ARCH_RISCV64)
- add_definitions(-D_TARGET_RISCV64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_RISCV64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
- add_definitions(-DBIT64)
- SET(REQUIRE_LLDBPLUGIN false)
-elseif(CLR_CMAKE_HOST_ARCH_LOONGARCH64)
- add_definitions(-D_TARGET_LOONGARCH64_=1)
- add_definitions(-DDBG_TARGET_64BIT=1)
- add_definitions(-DDBG_TARGET_LOONGARCH64=1)
- add_definitions(-DDBG_TARGET_WIN64=1)
- add_definitions(-DBIT64)
- SET(REQUIRE_LLDBPLUGIN false)
-endif()
-
if(NOT $ENV{LLVM_HOME} STREQUAL "")
set(LLDB_INCLUDE_DIR "$ENV{LLVM_HOME}/include")
set(LLDB_LIB_DIR "$ENV{LLVM_HOME}/lib")
DT_CONTEXT *dtcontext = (DT_CONTEXT*)context;
lldb::SBFrame frameFound;
-#ifdef DBG_TARGET_AMD64
+#ifdef TARGET_AMD64
DWORD64 spToFind = dtcontext->Rsp;
-#elif DBG_TARGET_X86
+#elif TARGET_X86
DWORD spToFind = dtcontext->Esp;
-#elif DBG_TARGET_ARM
+#elif TARGET_ARM
DWORD spToFind = dtcontext->Sp;
-#elif DBG_TARGET_ARM64
+#elif TARGET_ARM64
DWORD64 spToFind = dtcontext->Sp;
-#elif DBG_TARGET_RISCV64
+#elif TARGET_RISCV64
DWORD64 spToFind = dtcontext->Sp;
-#elif DBG_TARGET_LOONGARCH64
+#elif TARGET_LOONGARCH64
DWORD64 spToFind = dtcontext->Sp;
#else
#error "spToFind undefined for this platform"
}
HRESULT
-LLDBServices::GetExecutingProcessorType(
+LLDBServices::GetProcessorType(
PULONG type)
{
-#ifdef DBG_TARGET_AMD64
+#ifdef TARGET_AMD64
*type = IMAGE_FILE_MACHINE_AMD64;
-#elif DBG_TARGET_ARM
+#elif TARGET_ARM
*type = IMAGE_FILE_MACHINE_ARMNT;
-#elif DBG_TARGET_ARM64
+#elif TARGET_ARM64
*type = IMAGE_FILE_MACHINE_ARM64;
-#elif DBG_TARGET_X86
+#elif TARGET_X86
*type = IMAGE_FILE_MACHINE_I386;
-#elif DBG_TARGET_RISCV64
+#elif TARGET_RISCV64
*type = IMAGE_FILE_MACHINE_RISCV64;
-#elif DBG_TARGET_LOONGARCH64
+#elif TARGET_LOONGARCH64
*type = IMAGE_FILE_MACHINE_LOONGARCH64;
#else
#error "Unsupported target"
/* const */ lldb::SBFrame& frame,
DT_CONTEXT *dtcontext)
{
-#ifdef DBG_TARGET_AMD64
+#ifdef TARGET_AMD64
dtcontext->Rip = frame.GetPC();
dtcontext->Rsp = frame.GetSP();
dtcontext->Rbp = frame.GetFP();
dtcontext->SegEs = GetRegister(frame, "es");
dtcontext->SegFs = GetRegister(frame, "fs");
dtcontext->SegGs = GetRegister(frame, "gs");
-#elif DBG_TARGET_ARM
+#elif TARGET_ARM
dtcontext->Pc = frame.GetPC();
dtcontext->Sp = frame.GetSP();
dtcontext->Lr = GetRegister(frame, "lr");
dtcontext->R10 = GetRegister(frame, "r10");
dtcontext->R11 = GetRegister(frame, "r11");
dtcontext->R12 = GetRegister(frame, "r12");
-#elif DBG_TARGET_ARM64
+#elif TARGET_ARM64
dtcontext->Pc = frame.GetPC();
dtcontext->Sp = frame.GetSP();
dtcontext->Lr = GetRegister(frame, "x30");
dtcontext->X26 = GetRegister(frame, "x26");
dtcontext->X27 = GetRegister(frame, "x27");
dtcontext->X28 = GetRegister(frame, "x28");
-#elif DBG_TARGET_X86
+#elif TARGET_X86
dtcontext->Eip = frame.GetPC();
dtcontext->Esp = frame.GetSP();
dtcontext->Ebp = frame.GetFP();
dtcontext->SegEs = GetRegister(frame, "es");
dtcontext->SegFs = GetRegister(frame, "fs");
dtcontext->SegGs = GetRegister(frame, "gs");
-#elif DBG_TARGET_LOONGARCH64
+#elif TARGET_LOONGARCH64
dtcontext->Pc = frame.GetPC();
dtcontext->Sp = frame.GetSP();
dtcontext->Ra = GetRegister(frame, "ra");
HRESULT STDMETHODCALLTYPE GetPageSize(
PULONG size);
- HRESULT STDMETHODCALLTYPE GetExecutingProcessorType(
+ HRESULT STDMETHODCALLTYPE GetProcessorType(
PULONG type);
HRESULT STDMETHODCALLTYPE Execute(
#include "dbgutil.h"
#include <crtdbg.h>
#include <clrinternal.h> //has the CLR_ID_V4_DESKTOP guid in it
+#include <ntimageex.h>
#include "palclr.h"
-#ifndef IMAGE_FILE_MACHINE_ARMNT
-#define IMAGE_FILE_MACHINE_ARMNT 0x01c4 // ARM Thumb-2 Little-Endian
-#endif
-
-#ifndef IMAGE_FILE_MACHINE_ARM64
-#define IMAGE_FILE_MACHINE_ARM64 0xAA64 // ARM64 Little-Endian
-#endif
-
//*****************************************************************************
// CLRDebuggingImpl implementation (ICLRDebugging)
//*****************************************************************************
#endif
const WCHAR* pDacBaseName = NULL;
- if(m_skuId == CLR_ID_V4_DESKTOP)
+ if (m_skuId == CLR_ID_V4_DESKTOP)
pDacBaseName = CLR_DAC_MODULE_NAME_W;
- else if(m_skuId == CLR_ID_CORECLR || m_skuId == CLR_ID_PHONE_CLR || m_skuId == CLR_ID_ONECORE_CLR)
+ else if (m_skuId == CLR_ID_CORECLR || m_skuId == CLR_ID_PHONE_CLR || m_skuId == CLR_ID_ONECORE_CLR)
pDacBaseName = CORECLR_DAC_MODULE_NAME_W;
else
{
return E_UNEXPECTED;
}
+ _ASSERTE(targetImageFileMachine != IMAGE_FILE_MACHINE_ARM64X && targetImageFileMachine != IMAGE_FILE_MACHINE_ARM64EC);
+
const WCHAR* pTargetArch = NULL;
- if(targetImageFileMachine == IMAGE_FILE_MACHINE_I386)
+ if (targetImageFileMachine == IMAGE_FILE_MACHINE_I386)
{
pTargetArch = W("x86");
}
- else if(targetImageFileMachine == IMAGE_FILE_MACHINE_AMD64)
+ else if (targetImageFileMachine == IMAGE_FILE_MACHINE_AMD64)
{
pTargetArch = W("amd64");
}
- else if(targetImageFileMachine == IMAGE_FILE_MACHINE_ARMNT)
+ else if (targetImageFileMachine == IMAGE_FILE_MACHINE_ARMNT)
{
pTargetArch = W("arm");
}
- else if(targetImageFileMachine == IMAGE_FILE_MACHINE_ARM64)
+ else if (targetImageFileMachine == IMAGE_FILE_MACHINE_ARM64)
{
pTargetArch = W("arm64");
}
+ else if (targetImageFileMachine == IMAGE_FILE_MACHINE_RISCV64)
+ {
+ pTargetArch = W("riscv64");
+ }
+ else if (targetImageFileMachine == IMAGE_FILE_MACHINE_LOONGARCH64)
+ {
+ pTargetArch = W("loongarch64");
+ }
else
{
_ASSERTE(!"Unknown target image file machine type");
}
const WCHAR* pBuildFlavor = W("");
- if(pVersion->dwFileFlags & VS_FF_DEBUG)
+ if (pVersion->dwFileFlags & VS_FF_DEBUG)
{
- if(pVersion->dwFileFlags & VS_FF_SPECIALBUILD)
+ if (pVersion->dwFileFlags & VS_FF_SPECIALBUILD)
pBuildFlavor = W(".dbg");
else
pBuildFlavor = W(".chk");
// validate the output buffer is larger than our estimate above
_ASSERTE(cchBuffer >= minCchBuffer);
- if(!(cchBuffer >= minCchBuffer)) return E_INVALIDARG;
+ if (!(cchBuffer >= minCchBuffer)) return E_INVALIDARG;
swprintf_s(pBuffer, cchBuffer, W("%s_%s_%s_%u.%u.%u.%02u%s.dll"),
pDacBaseName,
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma once
+
+#ifndef IMAGE_FILE_MACHINE_ARMNT
+#define IMAGE_FILE_MACHINE_ARMNT 0x01c4 // ARM Thumb-2 Little-Endian
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_ARM64
+#define IMAGE_FILE_MACHINE_ARM64 0xAA64 // ARM64 Little-Endian
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_ARM64EC
+#define IMAGE_FILE_MACHINE_ARM64EC 0xA641
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_ARM64X
+#define IMAGE_FILE_MACHINE_ARM64X 0xA64E
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_RISCV64
+#define IMAGE_FILE_MACHINE_RISCV64 0x5064 // RISCV64
+#endif
+
+#ifndef IMAGE_FILE_MACHINE_LOONGARCH64
+#define IMAGE_FILE_MACHINE_LOONGARCH64 0x6264 // LOONGARCH64
+#endif
+
using namespace CorUnix;
+#if defined(HOST_ARM64)
+// Flag to check if atomics feature is available on
+// the machine
+bool g_arm64_atomics_present = false;
+#endif
Volatile<INT> init_count = 0;
Volatile<BOOL> shutdown_intent = 0;