#use static crt
add_definitions(-MT)
- if (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)
+ if (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64 OR CLR_CMAKE_TARGET_ARCH_ARM)
set(CORDBDI_SOURCES_ASM_FILE ${ARCH_SOURCES_DIR}/floatconversion.asm)
endif()
if (CLR_CMAKE_TARGET_ARCH_AMD64)
${CORDBDI_SOURCES}
${CORDBDI_SOURCES_WKS_PREPROCESSED_ASM}
)
+ elseif (CLR_CMAKE_TARGET_ARCH_ARM AND NOT DEFINED CLR_CROSS_COMPONENTS_BUILD)
+ convert_to_absolute_path(CORDBDI_SOURCES_ASM_FILE ${CORDBDI_SOURCES_ASM_FILE})
+
+ # Inserts a custom command in CMake build to preprocess each asm source file
+ get_filename_component(name ${CORDBDI_SOURCES_ASM_FILE} NAME_WE)
+ file(TO_CMAKE_PATH "${CMAKE_CURRENT_BINARY_DIR}/${name}.asm" ASM_PREPROCESSED_FILE)
+ preprocess_def_file(${CORDBDI_SOURCES_ASM_FILE} ${ASM_PREPROCESSED_FILE})
+
+ # On Arm32, compile the preprocessed binary to .obj
+ # We do not pass any defines since we have already done pre-processing above
+ set (ASM_CMDLINE "-o ${CMAKE_CURRENT_BINARY_DIR}/${name}.obj ${ASM_PREPROCESSED_FILE}")
+
+ # Generate the batch file that will invoke the assembler
+ file(TO_CMAKE_PATH "${CMAKE_CURRENT_BINARY_DIR}/runasm_${name}_${CMAKE_BUILD_TYPE}.cmd" ASM_SCRIPT_FILE)
+
+ file(GENERATE OUTPUT "${ASM_SCRIPT_FILE}"
+ CONTENT "\"${CMAKE_ASM_MASM_COMPILER}\" -g ${ASM_INCLUDE_DIRECTORIES} ${ASM_DEFINITIONS} ${ASM_CMDLINE}")
+
+ message("Generated - ${ASM_SCRIPT_FILE}")
+
+ # Need to compile asm file using custom command as include directories are not provided to asm compiler
+ add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${name}.obj
+ COMMAND ${ASM_SCRIPT_FILE}
+ DEPENDS ${ASM_PREPROCESSED_FILE}
+ COMMENT "Assembling ${ASM_PREPROCESSED_FILE} - ${ASM_SCRIPT_FILE}")
+
+ # mark obj as source that does not require compile
+ set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/${name}.obj PROPERTIES EXTERNAL_OBJECT TRUE)
+
+ # Add the generated OBJ in the dependency list so that it gets consumed during linkage
+ set(CORDBDI_SOURCES ${CORDBDI_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/${name}.obj)
endif()
elseif(CLR_CMAKE_PLATFORM_UNIX)
add_compile_options(-fPIC)
- if(CLR_CMAKE_TARGET_ARCH_AMD64)
+ if(CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM)
set(CORDBDI_SOURCES
${CORDBDI_SOURCES}
${ARCH_SOURCES_DIR}/floatconversion.S
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#include <unixasmmacros.inc>
+
+// Arguments
+// input: (in R0) the adress of the ULONGLONG to be converted to a double
+// output: the double corresponding to the ULONGLONG input value
+
+LEAF_ENTRY FPFillR8, .TEXT
+ .thumb
+ vldr D0, [R0]
+ bx lr
+LEAF_END FPFillR8, .TEXT
\ No newline at end of file
--- /dev/null
+; Licensed to the .NET Foundation under one or more agreements.
+; The .NET Foundation licenses this file to you under the MIT license.
+; See the LICENSE file in the project root for more information.
+
+;; ==++==
+;;
+
+;;
+;; ==--==
+#include "ksarm.h"
+
+;; Arguments
+;; input: (in R0) the adress of the ULONGLONG to be converted to a double
+;; output: the double corresponding to the ULONGLONG input value
+
+ LEAF_ENTRY FPFillR8
+ vldr D0, [R0]
+ bx lr
+ LEAF_END
+
+
+;; Must be at very end of file
+ END
int CordbNativeCode::GetCallInstructionLength(BYTE *ip, ULONG32 count)
{
#if defined(DBG_TARGET_ARM)
- return MAX_INSTRUCTION_LENGTH;
+ if (Is32BitInstruction(*(WORD*)ip))
+ return 4;
+ else
+ return 2;
#elif defined(DBG_TARGET_ARM64)
return MAX_INSTRUCTION_LENGTH;
#elif defined(DBG_TARGET_X86)
void CleanupStack();
void MarkStackFramesDirty();
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
#if defined(DBG_TARGET_X86)
// Converts the values in the floating point register area of the context to real number values.
void Get32bitFPRegisters(CONTEXT * pContext);
-#elif defined(DBG_TARGET_AMD64) || defined(DBG_TARGET_ARM64)
+#elif defined(DBG_TARGET_AMD64) || defined(DBG_TARGET_ARM64) || defined(DBG_TARGET_ARM)
// Converts the values in the floating point register area of the context to real number values.
void Get64bitFPRegisters(FPRegister64 * rgContextFPRegisters, int start, int nRegisters);
+
#endif // DBG_TARGET_X86
// Initializes the float state members of this instance of CordbThread. This function gets the context and
// converts the floating point values from their context representation to real number values.
void LoadFloatState();
-#endif //!DBG_TARGET_ARM @ARMTODO
HRESULT SetIP( bool fCanSetIPOnly,
CordbNativeCode * pNativeCode,
// Instead, we mark m_fFramesFresh in CleanupStack() and clear the cache only when it is used next time.
CDynArray<CordbFrame *> m_stackFrames;
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
bool m_fFloatStateValid;
unsigned int m_floatStackTop;
double m_floatValues[DebuggerIPCE_FloatCount];
-#endif // !DBG_TARGET_ARM @ARMTODO
private:
// True for the window after an Exception callback, but before it's been continued.
ICorDebugValue **ppValue);
UINT_PTR * GetAddressOfRegister(CorDebugRegister regNum) const;
CORDB_ADDRESS GetLeftSideAddressOfRegister(CorDebugRegister regNum) const;
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
HRESULT GetLocalFloatingPointValue(DWORD index,
CordbType * pType,
ICorDebugValue **ppValue);
-#endif // !DBG_TARGET_ARM @ARMTODO
CORDB_ADDRESS GetLSStackAddress(ICorDebugInfo::RegNum regNum, signed offset);
m_pAppDomain(NULL),
m_debugState(THREAD_RUN),
m_fFramesFresh(false),
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
m_fFloatStateValid(false),
m_floatStackTop(0),
-#endif // !DBG_TARGET_ARM @ARMTODO
m_fException(false),
m_fCreationEventQueued(false),
m_EnCRemapFunctionIP(NULL),
m_vmLeftSideContext = VMPTR_CONTEXT::NullPtr();
m_vmExcepObjHandle = VMPTR_OBJECTHANDLE::NullPtr();
-#if defined(_DEBUG) && !defined(DBG_TARGET_ARM) // @ARMTODO
+#if defined(_DEBUG)
for (unsigned int i = 0;
i < (sizeof(m_floatValues) / sizeof(m_floatValues[0]));
i++)
_ASSERTE(GetProcess()->ThreadHoldsProcessLock());
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
// invalidate the cached floating point state
m_fFloatStateValid = false;
-#endif // !defined(DBG_TARGET_ARM) @ARMTODO
// This flag is only true between the window when we get an exception callback and
// when we call continue. Since this function is only called when we continue, we
}
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
-#if defined(CROSS_COMPILE) && defined(_TARGET_ARM64_)
+#if defined(CROSS_COMPILE) && (defined(_TARGET_ARM64_) || defined(_TARGET_ARM_))
extern "C" double FPFillR8(void* pFillSlot)
{
_ASSERTE(!"nyi for platform");
return 0;
}
-#elif defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)
+#elif defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_) || defined(_TARGET_ARM_)
extern "C" double FPFillR8(void* pFillSlot);
#endif
m_floatStackTop = floatStackTop;
} // CordbThread::Get32bitFPRegisters
-#elif defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)
+#elif defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_) || defined(_TARGET_ARM_)
// CordbThread::Get64bitFPRegisters
// Converts the values in the floating point register area of the context to real number values. See
Get64bitFPRegisters((FPRegister64*) &(tempContext.Xmm0), 0, 16);
#elif defined(_TARGET_ARM64_)
Get64bitFPRegisters((FPRegister64*) &(tempContext.V), 0, 32);
+#elif defined (_TARGET_ARM_)
+ Get64bitFPRegisters((FPRegister64*) &(tempContext.D), 0, 32);
#else
_ASSERTE(!"nyi for platform");
#endif // !_TARGET_X86_
m_fFloatStateValid = true;
} // CordbThread::LoadFloatState
-#endif // !DBG_TARGET_ARM @ARMTODO
const bool SetIP_fCanSetIPOnly = TRUE;
const bool SetIP_fSetIP = FALSE;
return hr;
}
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
HRESULT CordbNativeFrame::GetLocalFloatingPointValue(DWORD index,
CordbType * pType,
ICorDebugValue **ppValue)
(index <= REGISTER_ARM64_V31)))
return E_INVALIDARG;
index -= REGISTER_ARM64_V0;
+#elif defined(DBG_TARGET_ARM)
+ if (!((index >= REGISTER_ARM_D0) &&
+ (index <= REGISTER_ARM_D31)))
+ return E_INVALIDARG;
+ index -= REGISTER_ARM_D0;
#else
if (!((index >= REGISTER_X86_FPSTACK_0) &&
(index <= REGISTER_X86_FPSTACK_7)))
return hr;
}
-#endif // !DBG_TARGET_ARM @ARMTODO
//---------------------------------------------------------------------------------------
//
HRESULT CordbJITILFrame::GetReturnValueForType(CordbType *pType, ICorDebugValue **ppReturnValue)
{
-#if defined(DBG_TARGET_ARM)
- return E_NOTIMPL;
-#else
#if defined(DBG_TARGET_X86)
const CorDebugRegister floatRegister = REGISTER_AMD64_XMM0;
#elif defined(DBG_TARGET_ARM64)
const CorDebugRegister floatRegister = REGISTER_ARM64_V0;
+#elif defined(DBG_TARGET_ARM)
+ const CorDebugRegister floatRegister = REGISTER_ARM_D0;
#endif
#if defined(DBG_TARGET_X86)
const CorDebugRegister ptrRegister = REGISTER_X86_EAX;
+ const CorDebugRegister ptrHighWordRegister = REGISTER_X86_EDX;
#elif defined(DBG_TARGET_AMD64)
const CorDebugRegister ptrRegister = REGISTER_AMD64_RAX;
#elif defined(DBG_TARGET_ARM64)
const CorDebugRegister ptrRegister = REGISTER_ARM64_X0;
+#elif defined(DBG_TARGET_ARM)
+ const CorDebugRegister ptrRegister = REGISTER_ARM_R0;
+ const CorDebugRegister ptrHighWordRegister = REGISTER_ARM_R1;
+
#endif
CorElementType corReturnType = pType->GetElementType();
case ELEMENT_TYPE_R4:
case ELEMENT_TYPE_R8:
return m_nativeFrame->GetLocalFloatingPointValue(floatRegister, pType, ppReturnValue);
-
-#ifdef DBG_TARGET_X86
+
+#if defined(DBG_TARGET_X86) || defined(DBG_TARGET_ARM)
case ELEMENT_TYPE_I8:
case ELEMENT_TYPE_U8:
- return m_nativeFrame->GetLocalDoubleRegisterValue(REGISTER_X86_EDX, REGISTER_X86_EAX, pType, ppReturnValue);
+ return m_nativeFrame->GetLocalDoubleRegisterValue(ptrHighWordRegister, ptrRegister, pType, ppReturnValue);
#endif
}
-#endif
}
HRESULT CordbJITILFrame::EnumerateLocalVariablesEx(ILCodeKind flags, ICorDebugValueEnum **ppValueEnum)
} // MemRegValueHome::GetEnregisteredValue
-#if !defined(DBG_TARGET_ARM) // @ARMTODO
// ----------------------------------------------------------------------------
// FloatRegValueHome member function implementations
ThrowHR(E_NOTIMPL);
} // FloatRegValueHome::GetEnregisteredValue
-#endif // !DBG_TARGET_ARM @ARMTODO
// ============================================================================
// RemoteValueHome implementation
#define THUMB_CODE 1
#endif
+typedef ULONGLONG FPRegister64;
typedef const BYTE CORDB_ADDRESS_TYPE;
typedef DPTR(CORDB_ADDRESS_TYPE) PTR_CORDB_ADDRESS_TYPE;
DT_NEON128 Q[16];
ULONGLONG D[32];
DWORD S[32];
- } DUMMYUNIONNAME;
+ };
//
// Debug registers
REGISTER_ARM_R11 = ( REGISTER_ARM_R10 + 1 ) ,
REGISTER_ARM_R12 = ( REGISTER_ARM_R11 + 1 ) ,
REGISTER_ARM_LR = ( REGISTER_ARM_R12 + 1 ) ,
+ REGISTER_ARM_D0 = ( REGISTER_ARM_LR + 1 ) ,
+ REGISTER_ARM_D1 = ( REGISTER_ARM_D0 + 1 ) ,
+ REGISTER_ARM_D2 = ( REGISTER_ARM_D1 + 1 ) ,
+ REGISTER_ARM_D3 = ( REGISTER_ARM_D2 + 1 ) ,
+ REGISTER_ARM_D4 = ( REGISTER_ARM_D3 + 1 ) ,
+ REGISTER_ARM_D5 = ( REGISTER_ARM_D4 + 1 ) ,
+ REGISTER_ARM_D6 = ( REGISTER_ARM_D5 + 1 ) ,
+ REGISTER_ARM_D7 = ( REGISTER_ARM_D6 + 1 ) ,
+ REGISTER_ARM_D8 = ( REGISTER_ARM_D7 + 1 ) ,
+ REGISTER_ARM_D9 = ( REGISTER_ARM_D8 + 1 ) ,
+ REGISTER_ARM_D10 = ( REGISTER_ARM_D9 + 1 ) ,
+ REGISTER_ARM_D11 = ( REGISTER_ARM_D10 + 1 ) ,
+ REGISTER_ARM_D12 = ( REGISTER_ARM_D11 + 1 ) ,
+ REGISTER_ARM_D13 = ( REGISTER_ARM_D12 + 1 ) ,
+ REGISTER_ARM_D14 = ( REGISTER_ARM_D13 + 1 ) ,
+ REGISTER_ARM_D15 = ( REGISTER_ARM_D14 + 1 ) ,
+ REGISTER_ARM_D16 = ( REGISTER_ARM_D15 + 1 ) ,
+ REGISTER_ARM_D17 = ( REGISTER_ARM_D16 + 1 ) ,
+ REGISTER_ARM_D18 = ( REGISTER_ARM_D17 + 1 ) ,
+ REGISTER_ARM_D19 = ( REGISTER_ARM_D18 + 1 ) ,
+ REGISTER_ARM_D20 = ( REGISTER_ARM_D19 + 1 ) ,
+ REGISTER_ARM_D21 = ( REGISTER_ARM_D20 + 1 ) ,
+ REGISTER_ARM_D22 = ( REGISTER_ARM_D21 + 1 ) ,
+ REGISTER_ARM_D23 = ( REGISTER_ARM_D22 + 1 ) ,
+ REGISTER_ARM_D24 = ( REGISTER_ARM_D23 + 1 ) ,
+ REGISTER_ARM_D25 = ( REGISTER_ARM_D24 + 1 ) ,
+ REGISTER_ARM_D26 = ( REGISTER_ARM_D25 + 1 ) ,
+ REGISTER_ARM_D27 = ( REGISTER_ARM_D26 + 1 ) ,
+ REGISTER_ARM_D28 = ( REGISTER_ARM_D27 + 1 ) ,
+ REGISTER_ARM_D29 = ( REGISTER_ARM_D28 + 1 ) ,
+ REGISTER_ARM_D30 = ( REGISTER_ARM_D29 + 1 ) ,
+ REGISTER_ARM_D31 = ( REGISTER_ARM_D30 + 1 ) ,
REGISTER_ARM64_PC = 0,
REGISTER_ARM64_SP = ( REGISTER_ARM64_PC + 1 ) ,
REGISTER_ARM64_FP = ( REGISTER_ARM64_SP + 1 ) ,
projects / platform / upstream / dotnet / runtime.git / commitdiff