Inline TLS field access for linux/osx x64/arm64

src/coreclr/jit/compiler.h

@@ -7123,7 +7123,7 @@ class Compiler
         optMethodFlags |= OMF_HAS_GUARDEDDEVIRT;
     }
 
-    bool doesMethodHasTlsFieldAccess()
+    bool methodHasTlsFieldAccess()
     {
         return (optMethodFlags & OMF_HAS_TLS_FIELD) != 0;
     }

src/coreclr/jit/emit.cpp

@@ -10205,6 +10205,8 @@ void emitter::emitRecordCallSite(ULONG                 instrOffset,  /* IN */
 
     if (callSig == nullptr)
     {
+        // For certain calls whose target is non-containable (e.g. tls access targets), `methodHandle`
+        // will be nullptr, because the target is present in a register.
         if ((methodHandle != nullptr) && (Compiler::eeGetHelperNum(methodHandle) == CORINFO_HELP_UNDEF))
         {
             emitComp->eeGetMethodSig(methodHandle, &sigInfo);

src/coreclr/jit/emitarm64.cpp

@@ -3740,11 +3740,13 @@ void emitter::emitIns_R(instruction ins, emitAttr attr, regNumber reg)
             id->idReg1(reg);
             fmt = IF_SR_1A;
             break;
+
         case INS_mrs_tpid0:
             id = emitNewInstrSmall(attr);
             id->idReg1(reg);
             fmt = IF_SR_1A;
             break;
+
         default:
             unreached();
     }

src/coreclr/jit/gentree.cpp

@@ -17488,7 +17488,8 @@ bool GenTree::isContained() const
 // return true if node is contained and an indir
 bool GenTree::isContainedIndir() const
 {
-    return OperIsIndir() && isContained();
+    bool answer = isContained();
+    return OperIsIndir() && answer;
 }
 
 bool GenTree::isIndirAddrMode()

src/coreclr/jit/helperexpansion.cpp

@@ -421,7 +421,7 @@ PhaseStatus Compiler::fgExpandThreadLocalAccess()
 {
     PhaseStatus result = PhaseStatus::MODIFIED_NOTHING;
 
-    if (!doesMethodHasTlsFieldAccess())
+    if (!methodHasTlsFieldAccess())
     {
         // TP: nothing to expand in the current method
         JITDUMP("Nothing to expand.\n")
@@ -486,7 +486,7 @@ bool Compiler::fgExpandThreadLocalAccessForCall(BasicBlock** pBlock, Statement*
         // On Arm, Thread execution blocks are accessed using co-processor registers and instructions such
         // as MRC and MCR are used to access them. We do not support them and so should never optimize the
         // field access using TLS.
-        assert(!"Unsupported scenario of optimizing TLS access on Linux Arm32/x86");
+        noway_assert(!"Unsupported scenario of optimizing TLS access on Linux Arm32/x86");
 #endif
     }
     else
@@ -495,7 +495,7 @@ bool Compiler::fgExpandThreadLocalAccessForCall(BasicBlock** pBlock, Statement*
         // On Arm, Thread execution blocks are accessed using co-processor registers and instructions such
         // as MRC and MCR are used to access them. We do not support them and so should never optimize the
         // field access using TLS.
-        assert(!"Unsupported scenario of optimizing TLS access on Windows Arm32");
+        noway_assert(!"Unsupported scenario of optimizing TLS access on Windows Arm32");
 #endif
     }
 
@@ -512,14 +512,15 @@ bool Compiler::fgExpandThreadLocalAccessForCall(BasicBlock** pBlock, Statement*
     info.compCompHnd->getThreadLocalStaticBlocksInfo(&threadStaticBlocksInfo, isGCThreadStatic);
 
     JITDUMP("getThreadLocalStaticBlocksInfo (%s)\n:", isGCThreadStatic ? "GC" : "Non-GC");
-    JITDUMP("offsetOfThreadLocalStoragePointer= %u\n", threadStaticBlocksInfo.offsetOfThreadLocalStoragePointer);
-    JITDUMP("tlsIndex= %u\n", (ssize_t)threadStaticBlocksInfo.tlsIndex.addr);
-    JITDUMP("tlsGetAddrFtnPtr= %u\n", threadStaticBlocksInfo.tlsGetAddrFtnPtr);
-    JITDUMP("tlsIndexObject= %u\n", (size_t)threadStaticBlocksInfo.tlsIndexObject);
-    JITDUMP("threadVarsSection= %u\n", (size_t)threadStaticBlocksInfo.threadVarsSection);
-    JITDUMP("offsetOfMaxThreadStaticBlocks= %u\n", threadStaticBlocksInfo.offsetOfMaxThreadStaticBlocks);
-    JITDUMP("offsetOfThreadStaticBlocks= %u\n", threadStaticBlocksInfo.offsetOfThreadStaticBlocks);
-    JITDUMP("offsetOfGCDataPointer= %u\n", threadStaticBlocksInfo.offsetOfGCDataPointer);
+    JITDUMP("tlsIndex= %p\n", dspOffset(dspPtr(threadStaticBlocksInfo.tlsIndex.addr)));
+    JITDUMP("tlsGetAddrFtnPtr= %p\n", dspOffset(dspPtr(threadStaticBlocksInfo.tlsGetAddrFtnPtr)));
+    JITDUMP("tlsIndexObject= %p\n", dspOffset(dspPtr(threadStaticBlocksInfo.tlsIndexObject)));
+    JITDUMP("threadVarsSection= %p\n", dspOffset(dspPtr(threadStaticBlocksInfo.threadVarsSection)));
+    JITDUMP("offsetOfThreadLocalStoragePointer= %u\n",
+            dspOffset(threadStaticBlocksInfo.offsetOfThreadLocalStoragePointer));
+    JITDUMP("offsetOfMaxThreadStaticBlocks= %u\n", dspOffset(threadStaticBlocksInfo.offsetOfMaxThreadStaticBlocks));
+    JITDUMP("offsetOfThreadStaticBlocks= %u\n", dspOffset(threadStaticBlocksInfo.offsetOfThreadStaticBlocks));
+    JITDUMP("offsetOfGCDataPointer= %u\n", dspOffset(threadStaticBlocksInfo.offsetOfGCDataPointer));
 
     assert((eeGetHelperNum(call->gtCallMethHnd) == CORINFO_HELP_GETSHARED_NONGCTHREADSTATIC_BASE_NOCTOR_OPTIMIZED) ||
            (eeGetHelperNum(call->gtCallMethHnd) == CORINFO_HELP_GETSHARED_GCTHREADSTATIC_BASE_NOCTOR_OPTIMIZED));
@@ -617,7 +618,7 @@ bool Compiler::fgExpandThreadLocalAccessForCall(BasicBlock** pBlock, Statement*
 
         // This is a call which takes an argument.
         // Populate and set the ABI appropriately.
-        assert(threadVarsSectionVal != 0);
+        assert(opts.altJit || threadVarsSectionVal != 0);
         GenTree* tlsArg = gtNewIconNode(threadVarsSectionVal, TYP_I_IMPL);
         tlsRefCall->gtArgs.InsertAfterThisOrFirst(this, NewCallArg::Primitive(tlsArg));
 
@@ -643,7 +644,7 @@ bool Compiler::fgExpandThreadLocalAccessForCall(BasicBlock** pBlock, Statement*
 
         // This is an indirect call which takes an argument.
         // Populate and set the ABI appropriately.
-        assert(threadStaticBlocksInfo.tlsIndexObject != 0);
+        assert(opts.altJit || threadStaticBlocksInfo.tlsIndexObject != 0);
         GenTree* tlsArg = gtNewIconNode((size_t)threadStaticBlocksInfo.tlsIndexObject, TYP_I_IMPL);
         tlsRefCall->gtArgs.InsertAfterThisOrFirst(this, NewCallArg::Primitive(tlsArg));
 

src/coreclr/jit/lsraarmarch.cpp

@@ -333,6 +333,10 @@ int LinearScan::BuildCall(GenTreeCall* call)
 
     if (call->gtCallType == CT_INDIRECT)
     {
+        // For TLS accesses, we need to find the address of the thread local by doing
+        // an indirect call to the relevant address corresponding to that variable.
+        // As an (early) argument, it takes the address of tlv_get_address
+        // symbol (osx) or the offset of the varible in TCB (linux).
         for (CallArg& arg : call->gtArgs.EarlyArgs())
         {
             CallArgABIInformation& abiInfo = arg.AbiInfo;

src/coreclr/tools/superpmi/superpmi-shared/agnostic.h

@@ -533,10 +533,10 @@ struct Agnostic_GetThreadLocalStaticBlocksInfo
     DWORDLONG                     tlsGetAddrFtnPtr;
     DWORDLONG                     tlsIndexObject;
     DWORDLONG                     threadVarsSection;
-    UINT                          offsetOfThreadLocalStoragePointer;
-    UINT                          offsetOfMaxThreadStaticBlocks;
-    UINT                          offsetOfThreadStaticBlocks;
-    UINT                          offsetOfGCDataPointer;
+    DWORD                         offsetOfThreadLocalStoragePointer;
+    DWORD                         offsetOfMaxThreadStaticBlocks;
+    DWORD                         offsetOfThreadStaticBlocks;
+    DWORD                         offsetOfGCDataPointer;
 };
 
 struct Agnostic_GetThreadLocalFieldInfo

src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp

@@ -3573,13 +3573,12 @@ void MethodContext::recGetThreadLocalStaticBlocksInfo(CORINFO_THREAD_STATIC_BLOC
     Agnostic_GetThreadLocalStaticBlocksInfo value;
     ZeroMemory(&value, sizeof(value));
 
-    value.tlsIndex.handle                       = CastHandle(pInfo->tlsIndex.addr);
-    value.tlsIndex.accessType                   = pInfo->tlsIndex.accessType;
-    value.tlsGetAddrFtnPtr                      = CastHandle(pInfo->tlsGetAddrFtnPtr);
-    value.tlsIndexObject                        = CastHandle(pInfo->tlsIndexObject);
-    value.threadVarsSection                     = CastHandle(pInfo->threadVarsSection);
-    value.offsetOfMaxThreadStaticBlocks         = pInfo->offsetOfMaxThreadStaticBlocks;
+    value.tlsIndex                              = SpmiRecordsHelper::StoreAgnostic_CORINFO_CONST_LOOKUP(&pInfo->tlsIndex);
+    value.tlsGetAddrFtnPtr                      = CastPointer(pInfo->tlsGetAddrFtnPtr);
+    value.tlsIndexObject                        = CastPointer(pInfo->tlsIndexObject);
+    value.threadVarsSection                     = CastPointer(pInfo->threadVarsSection);
     value.offsetOfThreadLocalStoragePointer     = pInfo->offsetOfThreadLocalStoragePointer;
+    value.offsetOfMaxThreadStaticBlocks         = pInfo->offsetOfMaxThreadStaticBlocks;
     value.offsetOfThreadStaticBlocks            = pInfo->offsetOfThreadStaticBlocks;
     value.offsetOfGCDataPointer                 = pInfo->offsetOfGCDataPointer;
 
@@ -3591,15 +3590,14 @@ void MethodContext::recGetThreadLocalStaticBlocksInfo(CORINFO_THREAD_STATIC_BLOC
 
 void MethodContext::dmpGetThreadLocalStaticBlocksInfo(DWORD key, const Agnostic_GetThreadLocalStaticBlocksInfo& value)
 {
-    printf("GetThreadLocalStaticBlocksInfo key %u, value tlsIndex-%016" PRIX64
+    printf("GetThreadLocalStaticBlocksInfo key %u, tlsIndex-%s, "
+           ", tlsGetAddrFtnPtr-%016" PRIX64 ", tlsIndexObject - %016" PRIX64 
+           ", threadVarsSection - %016" PRIX64
            ", offsetOfThreadLocalStoragePointer-%u, offsetOfMaxThreadStaticBlocks-%u"
-           ", offsetOfThreadStaticBlocks-%u, offsetOfGCDataPointer-%u"
-           ", value tlsGetAddrFtnPtr-%016" PRIX64 ", tlsIndexObject-%016" PRIX64
-           ", threadVarsSection-%016" PRIX64 ,
-           key, value.tlsIndex.handle, value.offsetOfThreadLocalStoragePointer,
-           value.offsetOfMaxThreadStaticBlocks, value.offsetOfThreadStaticBlocks,
-           value.offsetOfGCDataPointer, value.tlsGetAddrFtnPtr, value.tlsIndexObject,
-           value.threadVarsSection);
+           ", offsetOfThreadStaticBlocks-%u, offsetOfGCDataPointer-%u",           
+           key, SpmiDumpHelper::DumpAgnostic_CORINFO_CONST_LOOKUP(value.tlsIndex).c_str(), value.tlsGetAddrFtnPtr,
+           value.tlsIndexObject, value.threadVarsSection, value.offsetOfThreadLocalStoragePointer,
+           value.offsetOfMaxThreadStaticBlocks, value.offsetOfThreadStaticBlocks, value.offsetOfGCDataPointer);
 }
 
 void MethodContext::repGetThreadLocalStaticBlocksInfo(CORINFO_THREAD_STATIC_BLOCKS_INFO* pInfo, bool isGCType)
@@ -3609,14 +3607,13 @@ void MethodContext::repGetThreadLocalStaticBlocksInfo(CORINFO_THREAD_STATIC_BLOC
 
     DEBUG_REP(dmpGetThreadLocalStaticBlocksInfo(key, value));
 
-    pInfo->tlsIndex.accessType                  = (InfoAccessType)value.tlsIndex.accessType;
-    pInfo->tlsIndex.addr                        = (void*)value.tlsIndex.handle;
+    pInfo->tlsIndex                             = SpmiRecordsHelper::RestoreCORINFO_CONST_LOOKUP(value.tlsIndex);
     pInfo->tlsGetAddrFtnPtr                     = (void*)value.tlsGetAddrFtnPtr;
     pInfo->tlsIndexObject                       = (void*)value.tlsIndexObject;
     pInfo->threadVarsSection                    = (void*)value.threadVarsSection;
-    pInfo->offsetOfMaxThreadStaticBlocks        = (DWORD)value.offsetOfMaxThreadStaticBlocks;
     pInfo->offsetOfThreadLocalStoragePointer    = value.offsetOfThreadLocalStoragePointer;
-    pInfo->offsetOfThreadStaticBlocks           = (DWORD)value.offsetOfThreadStaticBlocks;
+    pInfo->offsetOfMaxThreadStaticBlocks        = value.offsetOfMaxThreadStaticBlocks;    
+    pInfo->offsetOfThreadStaticBlocks           = value.offsetOfThreadStaticBlocks;
     pInfo->offsetOfGCDataPointer                = value.offsetOfGCDataPointer;
 }
 

src/coreclr/vm/jithelpers.cpp

@@ -1865,7 +1865,7 @@ HCIMPL1(void*, JIT_GetSharedNonGCThreadStaticBaseOptimized, UINT32 staticBlockIn
         if (t_NonGCThreadStaticBlocksSize > 0)
         {
             memcpy(newThreadStaticBlocks, t_ThreadStatics.NonGCThreadStaticBlocks, t_NonGCThreadStaticBlocksSize * sizeof(PTR_BYTE));
-            delete t_ThreadStatics.NonGCThreadStaticBlocks;
+            delete[] t_ThreadStatics.NonGCThreadStaticBlocks;
         }
 
         t_NonGCThreadStaticBlocksSize = newThreadStaticBlocksSize;
@@ -1959,7 +1959,7 @@ HCIMPL1(void*, JIT_GetSharedGCThreadStaticBaseOptimized, UINT32 staticBlockIndex
         if (t_GCThreadStaticBlocksSize > 0)
         {
             memcpy(newThreadStaticBlocks, t_ThreadStatics.GCThreadStaticBlocks, t_GCThreadStaticBlocksSize * sizeof(PTR_BYTE));
-            delete t_ThreadStatics.GCThreadStaticBlocks;
+            delete[] t_ThreadStatics.GCThreadStaticBlocks;
         }
 
         t_GCThreadStaticBlocksSize = newThreadStaticBlocksSize;

src/coreclr/vm/jitinterface.cpp

@@ -1392,7 +1392,7 @@ static void* GetThreadStaticDescriptor(uint8_t* p)
     {
         // The optimization is disabled if coreclr is not compiled in .so format.
         _ASSERTE(false && "Unexpected code sequence");
-        return 0;
+        return nullptr;
     }
 
     // At this point, `p` contains the instruction pointer and is pointing to the above opcodes.
@@ -1593,7 +1593,7 @@ void CEEInfo::getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
                 // For linux/x64, check if compiled coreclr as .so file and not single file.
                 // For single file, the `tls_index` might not be accurate.
                 // Do not perform this optimization in such case.
-                optimizeThreadStaticAccess = GetTlsIndexObjectAddress() != 0;
+                optimizeThreadStaticAccess = GetTlsIndexObjectAddress() != nullptr;
 #endif // TARGET_UNIX && TARGET_AMD64
 
                 if (optimizeThreadStaticAccess)