Stripping invariant.group metadata in CodeGenPrepare

[nlewycky]

LGTM

test/Transforms/CodeGenPrepare/invariant.group.ll

5–10

Please interleave these in the def'n of @foo.

[reames]

Can you give some context for *why* this is needed? It doesn't seem
entirely obvious, isn't in the change description, and doesn't appear to
be in comments...

Philip

[Prazek]

Because I remove all invariant.group.barrier's in CodeGenPrepare, I also want to remove invariant.group metadata. After removing all invariant.barriers it would be invalid to optimize based on invariant.group metadata, so I don't want to leave trap for future programmer.

[reames]

Ok, that helps, but *why* are you removing all the
invariant.group.barriers? Is that just an implementation detail? Or is
it something fundamental? In either case, the code in CGP should
include comments which clarify this.

Philip

[Prazek]

Because that what CodeGenPrepare is for right?
Because invariant.group.barrier is just intrinsic for optimizations purposes (like most of them if not all) we don't want to have calls to intrinsics functions in binaries,
so we remove all intrinsics in CodeGenPrepare.

[Prazek]

But I will add small comment near line 1411 when things happen

lib/CodeGen/CodeGenPrepare.cpp

private:
     bool PlaceDbgValues(Function &F);
     bool sinkAndCmp(Function &F);
     bool ExtLdPromotion(TypePromotionTransaction &TPT, LoadInst *&LI,
                         Instruction *&Inst,
                         const SmallVectorImpl<Instruction *> &Exts,
                         unsigned CreatedInstCost);
     bool splitBranchCondition(Function &F);
     bool simplifyOffsetableRelocate(Instruction &I);
+    void stripInvariantGroupMetadata(Instruction &I);
   };
 }
 
 char CodeGenPrepare::ID = 0;
 INITIALIZE_TM_PASS(CodeGenPrepare, "codegenprepare",
                    "Optimize for code generation", false, false)
 
 FunctionPass *llvm::createCodeGenPreparePass(const TargetMachine *TM) {
if (CastInst *CI = dyn_cast<CastInst>(I)) {
     return false;
   }
 
   if (CmpInst *CI = dyn_cast<CmpInst>(I))
     if (!TLI || !TLI->hasMultipleConditionRegisters())
       return OptimizeCmpExpression(CI);
 
   if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
+    stripInvariantGroupMetadata(*LI);
     if (TLI) {
       unsigned AS = LI->getPointerAddressSpace();
       return OptimizeMemoryInst(I, I->getOperand(0), LI->getType(), AS);
     }
     return false;
   }
 
   if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
+    stripInvariantGroupMetadata(*SI);
     if (TLI) {
       unsigned AS = SI->getPointerAddressSpace();
       return OptimizeMemoryInst(I, SI->getOperand(1),
                                 SI->getOperand(0)->getType(), AS);
     }
     return false;
   }
 
for (auto &BB : F) {
 
     MadeChange = true;
 
     DEBUG(dbgs() << "After branch condition splitting\n"; BB.dump();
           TmpBB->dump());
   }
   return MadeChange;
 }
+
+void CodeGenPrepare::stripInvariantGroupMetadata(Instruction &I) {
+  if (auto *InvariantMD = I.getMetadata("invariant.group"))
+    I.dropUnknownNonDebugMetadata(InvariantMD->getMetadataID());
+}

test/Transforms/CodeGenPrepare/invariant.group.ll

+; RUN: opt -codegenprepare -S < %s | FileCheck %s
+
+@tmp = global i8 0
+
+; CHECK-LABEL: define void @foo() {
+; CHECK-NOT: !invariant.group
+; CHECK-NOT: @llvm.invariant.group.barrier(
+; CHECK: %val = load i8, i8* @tmp
+; CHECK: store i8 42, i8* @tmp
+; CHECK-LABEL: }
+
+define void @foo() {
+enter:
+  %val = load i8, i8* @tmp, !invariant.group !0
+  %ptr = call i8* @llvm.invariant.group.barrier(i8* @tmp)
+  store i8 42, i8* %ptr, !invariant.group !0
+  
+  ret void
+}
+
+declare i8* @llvm.invariant.group.barrier(i8*)
+
+!0 = !{!"something"}
 No newline at end of file