codegen,gc-lowering: post fixup tbaa information (#32321)

Certain metadata (invariant.load, tbaa_const) allows reordering of
memory operations over unknown calls (including safepoint). Before GC
lowering this is legal, because the optimizer sinking a load over a
safepoint will automatically extend the live range of the heap object
(by definition the live range of the heap object before GC lowering
matches the live ranges of any reference to it). However, after GC
lowering, we have fixed the live ranges of the heap objects, and thus it
is no longer legal to sink such memory operations over safepoints (as
the update to the object's live range won't be tracked).

fix #32215

(cherry picked from commit b2304c5)

Author: vtjnash

src/llvm-late-gc-lowering.cpp

@@ -902,26 +902,35 @@ JL_USED_FUNC static void dumpLivenessState(Function &F, State &S) {
     }
 }
 
-// Check if this is a load from an immutable value. The easiest
-// way to do so is to look at the tbaa and see if it derives from
-// jtbaa_immut.
-static bool isLoadFromImmut(LoadInst *LI)
+static bool isTBAA(MDNode *TBAA, std::initializer_list<const char*> const strset)
 {
-    if (LI->getMetadata(LLVMContext::MD_invariant_load))
-        return true;
-    MDNode *TBAA = LI->getMetadata(LLVMContext::MD_tbaa);
     if (!TBAA)
         return false;
     while (TBAA->getNumOperands() > 1) {
         TBAA = cast<MDNode>(TBAA->getOperand(1).get());
         auto str = cast<MDString>(TBAA->getOperand(0))->getString();
-        if (str == "jtbaa_immut" || str == "jtbaa_const") {
-            return true;
+        for (auto str2 : strset) {
+            if (str == str2) {
+                return true;
+            }
         }
     }
     return false;
 }
 
+// Check if this is a load from an immutable value. The easiest
+// way to do so is to look at the tbaa and see if it derives from
+// jtbaa_immut.
+static bool isLoadFromImmut(LoadInst *LI)
+{
+    if (LI->getMetadata(LLVMContext::MD_invariant_load))
+        return true;
+    MDNode *TBAA = LI->getMetadata(LLVMContext::MD_tbaa);
+    if (isTBAA(TBAA, {"jtbaa_immut", "jtbaa_const"}))
+        return true;
+    return false;
+}
+
 // Check if this is a load from an constant global.
 static bool isLoadFromConstGV(LoadInst *LI)
 {
@@ -930,14 +939,8 @@ static bool isLoadFromConstGV(LoadInst *LI)
     if (!isa<GlobalVariable>(LI->getPointerOperand()->stripInBoundsOffsets()))
         return false;
     MDNode *TBAA = LI->getMetadata(LLVMContext::MD_tbaa);
-    if (!TBAA)
-        return false;
-    while (TBAA->getNumOperands() > 1) {
-        TBAA = cast<MDNode>(TBAA->getOperand(1).get());
-        if (cast<MDString>(TBAA->getOperand(0))->getString() == "jtbaa_const") {
-            return true;
-        }
-    }
+    if (isTBAA(TBAA, {"jtbaa_const"}))
+        return true;
     return false;
 }
 
@@ -1720,6 +1723,40 @@ static inline void UpdatePtrNumbering(Value *From, Value *To, State *S)
     }
 }
 
+#if JL_LLVM_VERSION < 80000
+MDNode *createMutableTBAAAccessTag(MDNode *Tag) {
+  MDNode *BaseType = cast<MDNode>(Tag->getOperand(0));
+  MDNode *AccessType = cast<MDNode>(Tag->getOperand(1));
+  Metadata *OffsetNode = Tag->getOperand(2);
+  uint64_t Offset = mdconst::extract<ConstantInt>(OffsetNode)->getZExtValue();
+
+  bool NewFormat = isa<MDNode>(AccessType->getOperand(0));
+
+  // See if the tag is already mutable.
+  unsigned ImmutabilityFlagOp = NewFormat ? 4 : 3;
+  if (Tag->getNumOperands() <= ImmutabilityFlagOp)
+    return Tag;
+
+  // If Tag is already mutable then return it.
+  Metadata *ImmutabilityFlagNode = Tag->getOperand(ImmutabilityFlagOp);
+  if (!mdconst::extract<ConstantInt>(ImmutabilityFlagNode)->getValue())
+    return Tag;
+
+  // Otherwise, create another node.
+  if (!NewFormat)
+    return MDBuilder(Tag->getContext()).createTBAAStructTagNode(BaseType, AccessType, Offset);
+
+  Metadata *SizeNode = Tag->getOperand(3);
+  uint64_t Size = mdconst::extract<ConstantInt>(SizeNode)->getZExtValue();
+  return MDBuilder(Tag->getContext()).createTBAAAccessTag(BaseType, AccessType, Offset, Size);
+}
+#else
+MDNode *createMutableTBAAAccessTag(MDNode *Tag) {
+    return MDBuilder(Tag->getContext()).createMutableTBAAAccessTag(TBAA);
+}
+#endif
+
+
 bool LateLowerGCFrame::CleanupIR(Function &F, State *S) {
     bool ChangesMade = false;
     // We create one alloca for all the jlcall frames that haven't been processed
@@ -1737,6 +1774,24 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S) {
     SmallVector<CallInst*, 16> write_barriers;
     for (BasicBlock &BB : F) {
         for (auto it = BB.begin(); it != BB.end();) {
+            Instruction *I = &*it;
+            if (isa<LoadInst>(I) || isa<StoreInst>(I)) {
+                // strip all constant alias information, as it might depend on the gc having
+                // preserved a gc root, which stops being true after this pass (#32215)
+                // we'd like to call RewriteStatepointsForGC::stripNonValidData here, but
+                // that function asserts that the GC strategy must be named either "statepoint-example" or "coreclr",
+                // while we don't give a name to our GC in the IR, and C++ scope rules prohibit us from using it,
+                // so instead we reimplement it here badly
+                if (I->getMetadata(LLVMContext::MD_invariant_load))
+                    I->setMetadata(LLVMContext::MD_invariant_load, NULL);
+                if (MDNode *TBAA = I->getMetadata(LLVMContext::MD_tbaa)) {
+                    if (TBAA->getNumOperands() == 4 && isTBAA(TBAA, {"jtbaa_const"})) {
+                        MDNode *MutableTBAA = createMutableTBAAAccessTag(TBAA);
+                        if (MutableTBAA != TBAA)
+                            I->setMetadata(LLVMContext::MD_tbaa, MutableTBAA);
+                    }
+                }
+            }
             auto *CI = dyn_cast<CallInst>(&*it);
             if (!CI) {
                 ++it;
@@ -1805,16 +1860,16 @@ bool LateLowerGCFrame::CleanupIR(Function &F, State *S) {
                 size_t nargs = CI->getNumArgOperands();
                 size_t nframeargs = nargs - (CC == JLCALL_F_CC);
                 SmallVector<Value *, 3> ReplacementArgs;
-                auto it = CI->arg_begin();
+                auto arg_it = CI->arg_begin();
                 if (CC == JLCALL_F_CC) {
-                    assert(it != CI->arg_end());
-                    ReplacementArgs.push_back(*(it++));
+                    assert(arg_it != CI->arg_end());
+                    ReplacementArgs.push_back(*(arg_it++));
                 }
                 maxframeargs = std::max(maxframeargs, nframeargs);
                 int slot = 0;
                 IRBuilder<> Builder (CI);
-                for (; it != CI->arg_end(); ++it) {
-                    Builder.CreateStore(*it, Builder.CreateGEP(T_prjlvalue, Frame,
+                for (; arg_it != CI->arg_end(); ++arg_it) {
+                    Builder.CreateStore(*arg_it, Builder.CreateGEP(T_prjlvalue, Frame,
                         ConstantInt::get(T_int32, slot++)));
                 }
                 ReplacementArgs.push_back(nframeargs == 0 ?