Run tests on CI (WIP), works locally

src/coreclr/jit/assertionprop.cpp

@@ -3197,8 +3197,7 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree)
 
         case TYP_SIMD32:
         {
-            simd32_t value = vnStore->ConstantValue<simd32_t>(vnCns);
-
+            simd32_t       value  = vnStore->ConstantValue<simd32_t>(vnCns);
             GenTreeVecCon* vecCon = gtNewVconNode(tree->TypeGet());
             vecCon->gtSimd32Val   = value;
 

src/coreclr/jit/emitxarch.cpp

@@ -12828,6 +12828,8 @@ BYTE* emitter::emitOutputCV(BYTE* dst, instrDesc* id, code_t code, CnsVal* addc)
         }
         else
         {
+            // Should not be ever called here?
+
             addr = (BYTE*)emitComp->info.compCompHnd->getFieldAddress(fldh, nullptr);
             if (addr == nullptr)
             {

src/coreclr/jit/importer.cpp

@@ -4387,8 +4387,8 @@ GenTree* Compiler::impImportStaticFieldAccess(CORINFO_RESOLVED_TOKEN* pResolvedT
     FieldSeq::FieldKind fieldKind =
         isSharedStatic ? FieldSeq::FieldKind::SharedStatic : FieldSeq::FieldKind::SimpleStatic;
 
-    bool hasKnownDirectAddress = !opts.IsReadyToRun() && pFieldInfo->fieldLookup.addr != nullptr &&
-                                 pFieldInfo->fieldLookup.accessType == IAT_VALUE;
+    bool hasConstAddr = (pFieldInfo->fieldAccessor == CORINFO_FIELD_STATIC_ADDRESS) ||
+                        (pFieldInfo->fieldAccessor == CORINFO_FIELD_STATIC_RVA_ADDRESS);
 
     FieldSeq* innerFldSeq;
     FieldSeq* outerFldSeq;
@@ -4399,21 +4399,11 @@ GenTree* Compiler::impImportStaticFieldAccess(CORINFO_RESOLVED_TOKEN* pResolvedT
     }
     else
     {
-        bool hasConstAddr = (pFieldInfo->fieldAccessor == CORINFO_FIELD_STATIC_ADDRESS) ||
-                            (pFieldInfo->fieldAccessor == CORINFO_FIELD_STATIC_RVA_ADDRESS);
-
         ssize_t offset;
         if (hasConstAddr)
         {
-            if (hasKnownDirectAddress)
-            {
-                offset = reinterpret_cast<ssize_t>(pFieldInfo->fieldLookup.addr);
-            }
-            else
-            {
-                offset = reinterpret_cast<ssize_t>(info.compCompHnd->getFieldAddress(pResolvedToken->hField));
-            }
-            assert(offset != 0);
+            assert(pFieldInfo->fieldLookup.accessType == IAT_VALUE);
+            offset = reinterpret_cast<ssize_t>(pFieldInfo->fieldLookup.addr);
         }
         else
         {
@@ -4518,12 +4508,11 @@ GenTree* Compiler::impImportStaticFieldAccess(CORINFO_RESOLVED_TOKEN* pResolvedT
         {
             // Do we need the address of a static field?
             //
-            if (!hasKnownDirectAddress && (access & CORINFO_ACCESS_ADDRESS))
+            if (access & CORINFO_ACCESS_ADDRESS)
             {
-                void** pFldAddr = nullptr;
-                void*  fldAddr  = info.compCompHnd->getFieldAddress(pResolvedToken->hField, (void**)&pFldAddr);
+                assert(pFieldInfo->fieldLookup.accessType == IAT_VALUE);
+                void* fldAddr = pFieldInfo->fieldLookup.addr;
                 // We should always be able to access this static's address directly.
-                assert(pFldAddr == nullptr);
 
                 // Create the address node.
                 GenTreeFlags handleKind = isBoxedStatic ? GTF_ICON_STATIC_BOX_PTR : GTF_ICON_STATIC_HDL;
@@ -4535,8 +4524,11 @@ GenTree* Compiler::impImportStaticFieldAccess(CORINFO_RESOLVED_TOKEN* pResolvedT
                     op1->gtFlags |= GTF_ICON_INITCLASS;
                 }
             }
-            else if (hasKnownDirectAddress)
+            else if (hasConstAddr && !isBoxedStatic)
             {
+                assert(pFieldInfo->fieldLookup.addr != nullptr);
+                assert(!isSharedStatic);
+                assert(pFieldInfo->fieldLookup.accessType == IAT_VALUE);
                 assert(!isBoxedStatic);
                 op1 = gtNewIconHandleNode((size_t)pFieldInfo->fieldLookup.addr, GTF_ICON_STATIC_HDL, innerFldSeq);
                 INDEBUG(op1->AsIntCon()->gtTargetHandle = reinterpret_cast<size_t>(pResolvedToken->hField));
@@ -4577,7 +4569,6 @@ GenTree* Compiler::impImportStaticFieldAccess(CORINFO_RESOLVED_TOKEN* pResolvedT
 
     if (isBoxedStatic)
     {
-        assert(!hasKnownDirectAddress);
         op1 = gtNewOperNode(GT_IND, TYP_REF, op1);
         op1->gtFlags |= (GTF_IND_INVARIANT | GTF_IND_NONFAULTING | GTF_IND_NONNULL);
 

src/coreclr/jit/morph.cpp

@@ -5297,6 +5297,8 @@ GenTree* Compiler::fgMorphField(GenTree* tree, MorphAddrContext* mac)
         }
         else
         {
+            // TODO: delete the boxed-static part (move to importer)
+
             // Normal static field reference
             //
             // If we can we access the static's address directly
@@ -5315,6 +5317,7 @@ GenTree* Compiler::fgMorphField(GenTree* tree, MorphAddrContext* mac)
             bool isBoxedStatic = gtIsStaticFieldPtrToBoxedStruct(tree->TypeGet(), symHnd);
             if (!isBoxedStatic)
             {
+                assert(!"unreachable!");
                 // Only simple statics get importred as GT_FIELDs.
                 fieldSeq = GetFieldSeqStore()->Create(symHnd, reinterpret_cast<size_t>(fldAddr),
                                                       FieldSeq::FieldKind::SimpleStatic);

src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs

@@ -1499,6 +1499,10 @@ private void getFieldInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_MET
                     // TODO: Handle the case when the RVA is in the TLS range
                     fieldAccessor = CORINFO_FIELD_ACCESSOR.CORINFO_FIELD_STATIC_RVA_ADDRESS;
 
+                    ISymbolNode node = _compilation.GetFieldRvaData(field);
+                    pResult->fieldLookup.addr = (void*)ObjectToHandle(node);
+                    pResult->fieldLookup.accessType = node.RepresentsIndirectionCell ? InfoAccessType.IAT_PVALUE : InfoAccessType.IAT_VALUE;
+
                     // We are not going through a helper. The constructor has to be triggered explicitly.
                     if (!IsClassPreInited(field.OwningType))
                     {

src/coreclr/tools/aot/ILCompiler.RyuJit/JitInterface/CorInfoImpl.RyuJit.cs

@@ -2061,6 +2061,10 @@ private void getFieldInfo(ref CORINFO_RESOLVED_TOKEN pResolvedToken, CORINFO_MET
                     // TODO: Handle the case when the RVA is in the TLS range
                     fieldAccessor = CORINFO_FIELD_ACCESSOR.CORINFO_FIELD_STATIC_RVA_ADDRESS;
 
+                    ISymbolNode node = _compilation.GetFieldRvaData(field);
+                    pResult->fieldLookup.addr = (void*)ObjectToHandle(node);
+                    pResult->fieldLookup.accessType = node.RepresentsIndirectionCell ? InfoAccessType.IAT_PVALUE : InfoAccessType.IAT_VALUE;
+
                     // We are not going through a helper. The constructor has to be triggered explicitly.
                     if (_compilation.HasLazyStaticConstructor(field.OwningType))
                     {

src/coreclr/vm/jitinterface.cpp

@@ -1535,16 +1535,17 @@ void CEEInfo::getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
                 // Provide helper to use if the JIT is not able to emit the TLS access
                 // as intrinsic
                 pResult->helper = CORINFO_HELP_GETSTATICFIELDADDR_TLS;
-
                 pResult->offset = module->GetFieldTlsOffset(pResult->offset);
             }
             else
             {
                 fieldAccessor = CORINFO_FIELD_STATIC_RVA_ADDRESS;
+                pResult->fieldLookup.addr = pField->GetStaticAddressHandle(NULL);
+                pResult->fieldLookup.accessType = IAT_VALUE;
             }
 
             // We are not going through a helper. The constructor has to be triggered explicitly.
-            if (!pFieldMT->IsClassPreInited())
+            if (!pFieldMT->IsClassInited())
                 fieldFlags |= CORINFO_FLG_FIELD_INITCLASS;
         }
         else
@@ -1553,20 +1554,7 @@ void CEEInfo::getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
             CORINFO_FIELD_ACCESSOR intrinsicAccessor;
 
             if (pField->GetFieldType() == ELEMENT_TYPE_VALUETYPE)
-            {
-                GCX_COOP();
-                Object* frozenBoxedStatic = OBJECTREFToObject(getFrozenBoxedStatic(pField));
-                if (frozenBoxedStatic != nullptr)
-                {
-                    // Skip pMT of the frozen object holding struct
-                    pResult->fieldLookup.addr = (uint8_t*)frozenBoxedStatic + sizeof(void*);
-                    pResult->fieldLookup.accessType = InfoAccessType::IAT_VALUE;
-                }
-                else
-                {
-                    fieldFlags |= CORINFO_FLG_FIELD_STATIC_IN_HEAP;
-                }
-            }
+                fieldFlags |= CORINFO_FLG_FIELD_STATIC_IN_HEAP;
 
             if (pFieldMT->IsSharedByGenericInstantiations())
             {
@@ -1597,9 +1585,33 @@ void CEEInfo::getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
             {
                 fieldAccessor = CORINFO_FIELD_STATIC_ADDRESS;
 
+                // Allocate space for the local class if necessary, but don't trigger
+                // class construction.
+                DomainLocalModule* pLocalModule = pFieldMT->GetDomainLocalModule();
+                pLocalModule->PopulateClass(pFieldMT);
+
                 // We are not going through a helper. The constructor has to be triggered explicitly.
-                if (!pFieldMT->IsClassPreInited())
+                if (!pFieldMT->IsClassInited())
                     fieldFlags |= CORINFO_FLG_FIELD_INITCLASS;
+
+                GCX_COOP();
+
+                pResult->fieldLookup.addr = pField->GetStaticAddressHandle((void*)pField->GetBase());
+                pResult->fieldLookup.accessType = IAT_VALUE;
+
+                if ((fieldFlags & (CORINFO_FLG_FIELD_STATIC_IN_HEAP | CORINFO_FLG_FIELD_INITCLASS)) == CORINFO_FLG_FIELD_STATIC_IN_HEAP)
+                {
+                    Object* frozenObj = *(Object**)pResult->fieldLookup.addr;
+
+                    // ContainsPointers here is unnecessary but it's cheaper than IsInFrozenSegment
+                    // for structs containing gc handles
+                    if (frozenObj != nullptr && !frozenObj->GetMethodTable()->ContainsPointers() &&
+                        GCHeapUtilities::GetGCHeap()->IsInFrozenSegment(frozenObj))
+                    {
+                        pResult->fieldLookup.addr = frozenObj->GetData();
+                        fieldFlags &= ~CORINFO_FLG_FIELD_STATIC_IN_HEAP;
+                    }
+                }
             }
         }