Modify __int64 definition in PAL to match the OS definition (#77056)

* Modify __int64 definition in PAL to match the OS definition

This change modifies the definition of __int64 and thus of many other
types defined on the basis of it to match the OS definitions. This
ensures that we can use these types in interfaces between code in
coreclr and various PALs that are compiled against OS headers.

The key issue was that we were defining __int64 for 64 bit OSes as
long while Unix defines it as long long. The size of those types is the
same on Unix, but they are different and result in different mangling of
C++ names.

* Fix coreclr tests build

* Fix comment on #endif in jit.h

* Reflect PR feedback

* Fix jit source formatting

* Fix FreeBSD build

Author: janvorli

src/coreclr/debug/createdump/crashinfounix.cpp

@@ -376,8 +376,8 @@ CrashInfo::VisitProgramHeader(uint64_t loadbias, uint64_t baseAddress, Phdr* phd
             TRACE("VisitProgramHeader: ehFrameHdrStart %016llx ehFrameHdrSize %08llx\n", ehFrameHdrStart, ehFrameHdrSize);
             InsertMemoryRegion(ehFrameHdrStart, ehFrameHdrSize);
 
-            uint64_t ehFrameStart;
-            uint64_t ehFrameSize;
+            ULONG64 ehFrameStart;
+            ULONG64 ehFrameSize;
             if (PAL_GetUnwindInfoSize(baseAddress, ehFrameHdrStart, ReadMemoryAdapter, &ehFrameStart, &ehFrameSize))
             {
                 TRACE("VisitProgramHeader: ehFrameStart %016llx ehFrameSize %08llx\n", ehFrameStart, ehFrameSize);

src/coreclr/debug/inc/dacdbistructures.inl

@@ -640,8 +640,6 @@ void FieldData::ClearFields()
     m_pFldStaticAddress = NULL;
 }
 
-typedef ULONG_PTR SIZE_T;
-
 inline
 BOOL FieldData::OkToGetOrSetInstanceOffset()
 {

src/coreclr/inc/check.inl

@@ -220,6 +220,14 @@ inline CHECK CheckOverflow(const void *address, UINT64 offset)
     CHECK_OK;
 }
 
+#if defined(HOST_UNIX) && defined(HOST_64BIT)
+inline CHECK CheckOverflow(const void *address, SIZE_T offset)
+{
+    CHECK((UINT64) address + offset >= (UINT64) address);
+
+    CHECK_OK;
+}
+#endif // HOST_UNIX && HOST_BIT64
 
 inline CHECK CheckUnderflow(UINT value1, UINT value2)
 {

src/coreclr/inc/clrtypes.h

@@ -338,6 +338,15 @@ inline UINT64 AlignUp(UINT64 value, UINT alignment)
     return (value+alignment-1)&~(UINT64)(alignment-1);
 }
 
+#if defined(HOST_UNIX) && defined(HOST_64BIT)
+inline SIZE_T AlignUp(SIZE_T value, UINT alignment)
+{
+    STATIC_CONTRACT_LEAF;
+    STATIC_CONTRACT_SUPPORTS_DAC;
+    return (value+alignment-1)&~(SIZE_T)(alignment-1);
+}
+#endif // HOST_UNIX && HOST_BIT64
+
 inline UINT AlignDown(UINT value, UINT alignment)
 {
     STATIC_CONTRACT_LEAF;
@@ -381,6 +390,14 @@ inline UINT AlignmentPad(UINT64 value, UINT alignment)
     return (UINT) (AlignUp(value, alignment) - value);
 }
 
+#if defined(HOST_UNIX) && defined(HOST_64BIT)
+inline UINT AlignmentPad(SIZE_T value, UINT alignment)
+{
+    STATIC_CONTRACT_WRAPPER;
+    return (UINT) (AlignUp(value, alignment) - value);
+}
+#endif // HOST_UNIX && HOST_BIT64
+
 inline UINT AlignmentTrim(UINT value, UINT alignment)
 {
     STATIC_CONTRACT_LEAF;
@@ -406,4 +423,13 @@ inline UINT AlignmentTrim(UINT64 value, UINT alignment)
     return ((UINT)value)&(alignment-1);
 }
 
+#if defined(HOST_UNIX) && defined(HOST_64BIT)
+inline UINT AlignmentTrim(SIZE_T value, UINT alignment)
+{
+    STATIC_CONTRACT_LEAF;
+    STATIC_CONTRACT_SUPPORTS_DAC;
+    return ((UINT)value)&(alignment-1);
+}
+#endif // HOST_UNIX && HOST_BIT64
+
 #endif  // CLRTYPES_H_

src/coreclr/inc/daccess.h

@@ -1027,6 +1027,12 @@ class __DPtrBase : public __TPtrBase
     {
         return DPtrType(DacTAddrOffset(m_addr, val, sizeof(type)));
     }
+#if defined(HOST_UNIX) && defined(HOST_64BIT)
+    DPtrType operator+(unsigned long long val)
+    {
+        return DPtrType(DacTAddrOffset(m_addr, val, sizeof(type)));
+    }
+#endif // HOST_UNIX && HOST_BIT64
     DPtrType operator+(short val)
     {
         return DPtrType(m_addr + val * sizeof(type));

src/coreclr/inc/regdisp.h

@@ -561,7 +561,7 @@ inline size_t * getRegAddr (unsigned regNum, PTR_CONTEXT regs)
     return (PTR_size_t)(PTR_BYTE(regs) + OFFSET_OF_REGISTERS[regNum]);
 #elif defined(TARGET_AMD64)
     _ASSERTE(regNum < 16);
-    return &regs->Rax + regNum;
+    return (size_t *)&regs->Rax + regNum;
 #elif defined(TARGET_ARM)
         _ASSERTE(regNum < 16);
         return (size_t *)&regs->R0 + regNum;

src/coreclr/jit/compiler.hpp

@@ -233,6 +233,13 @@ inline unsigned genLog2(unsigned __int64 value)
 #endif
 }
 
+#if defined(HOST_UNIX) && defined(HOST_64BIT)
+inline unsigned genLog2(size_t value)
+{
+    return genLog2((unsigned __int64)value);
+}
+#endif // HOST_UNIX && HOST_BIT64
+
 /*****************************************************************************
  *
  *  Return the lowest bit that is set in the given register mask.
@@ -1536,7 +1543,8 @@ void GenTree::BashToConst(T value, var_types type /* = TYP_UNDEF */)
 {
     static_assert_no_msg((std::is_same<T, int32_t>::value || std::is_same<T, int64_t>::value ||
                           std::is_same<T, long long>::value || std::is_same<T, float>::value ||
-                          std::is_same<T, double>::value));
+                          std::is_same<T, ssize_t>::value || std::is_same<T, double>::value));
+
     static_assert_no_msg(sizeof(int64_t) == sizeof(long long));
 
     var_types typeOfValue = TYP_UNDEF;

src/coreclr/jit/gentree.h

@@ -3287,7 +3287,8 @@ inline void GenTreeIntConCommon::SetIntegralValue(int64_t value)
 template <typename T>
 inline void GenTreeIntConCommon::SetValueTruncating(T value)
 {
-    static_assert_no_msg((std::is_same<T, int32_t>::value || std::is_same<T, int64_t>::value));
+    static_assert_no_msg(
+        (std::is_same<T, int32_t>::value || std::is_same<T, int64_t>::value || std::is_same<T, ssize_t>::value));
 
     if (TypeIs(TYP_LONG))
     {

src/coreclr/jit/jit.h

@@ -219,6 +219,8 @@
 #error Unsupported or unset target architecture
 #endif
 
+typedef ptrdiff_t ssize_t;
+
 // Include the AMD64 unwind codes when appropriate.
 #if defined(TARGET_AMD64)
 #include "win64unwind.h"
@@ -349,8 +351,6 @@ typedef int NATIVE_OFFSET;
 // this is used for native code sizes.
 typedef unsigned UNATIVE_OFFSET;
 
-typedef ptrdiff_t ssize_t;
-
 // Type used for weights (e.g. block and edge weights)
 typedef double weight_t;
 
@@ -630,9 +630,16 @@ inline unsigned int unsigned_abs(int x)
 
 #ifdef TARGET_64BIT
 inline size_t unsigned_abs(ssize_t x)
+{
+    return ((size_t)abs((__int64)x));
+}
+
+#ifdef HOST_UNIX
+inline size_t unsigned_abs(__int64 x)
 {
     return ((size_t)abs(x));
 }
+#endif // HOST_UNIX
 #endif // TARGET_64BIT
 
 /*****************************************************************************/

src/coreclr/jit/register.h

@@ -68,10 +68,10 @@ REGALIAS(EDI, RDI)
 
 #ifdef TARGET_AMD64
 #define XMMBASE 16
-#define XMMMASK(x) (__int64(1) << ((x)+XMMBASE))
+#define XMMMASK(x) ((__int64)(1) << ((x)+XMMBASE))
 #else // !TARGET_AMD64
 #define XMMBASE 8
-#define XMMMASK(x) (__int32(1) << ((x)+XMMBASE))
+#define XMMMASK(x) ((__int32)(1) << ((x)+XMMBASE))
 #endif // !TARGET_AMD64
 
 REGDEF(XMM0,    0+XMMBASE,  XMMMASK(0),   "mm0"  )