[EarlyCSE][OpaquePtr] Check access type when performing DSE

[aeubanks]

Summary

This will bail out on target specific intrinsics. If those are deemed
important enough for EarlyCSE to handle, we can augment MemIntrinsicInfo
with an access type for TargetTransformInfo::getTgtMemIntrinsic() to
handle.

[nikic]

LGTM

This will bail out on target specific intrinsics. If those are deemed important enough for EarlyCSE to handle, we can augment MemIntrinsicInfo with an access type for TargetTransformInfo::getTgtMemIntrinsic() to handle.

Well, given the lack of test coverage for this case, I daresay it is not important enough...

llvm/lib/Transforms/Scalar/EarlyCSE.cpp

public:
     }
 
     Value *getPointerOperand() const {
       if (IntrID != 0)
         return Info.PtrVal;
       return getLoadStorePointerOperand(Inst);
     }
 
+    Type *getValueType() const {
+      // TODO: handle target-specific intrinsics.
+      if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
+        switch (II->getIntrinsicID()) {
+        case Intrinsic::masked_load:
+          return II->getType();
+        case Intrinsic::masked_store:
+          return II->getArgOperand(0)->getType();
+        default:
+          return nullptr;
+        }
+      }
+      return getLoadStoreType(Inst);
+    }
+
     bool mayReadFromMemory() const {
       if (IntrID != 0)
         return Info.ReadMem;
       return Inst->mayReadFromMemory();
     }
 
     bool mayWriteToMemory() const {
       if (IntrID != 0)

 bool EarlyCSE::overridingStores(const ParseMemoryInst &Earlier,
                                 const ParseMemoryInst &Later) {
   // Can we remove Earlier store because of Later store?
 
   assert(Earlier.isUnordered() && !Earlier.isVolatile() &&
          "Violated invariant");
   if (Earlier.getPointerOperand() != Later.getPointerOperand())
     return false;
+  if (!Earlier.getValueType() || !Later.getValueType() ||
+      Earlier.getValueType() != Later.getValueType())
+    return false;
   if (Earlier.getMatchingId() != Later.getMatchingId())
     return false;
   // At the moment, we don't remove ordered stores, but do remove
   // unordered atomic stores.  There's no special requirement (for
   // unordered atomics) about removing atomic stores only in favor of
   // other atomic stores since we were going to execute the non-atomic
   // one anyway and the atomic one might never have become visible.
   if (!Earlier.isUnordered() || !Later.isUnordered())

llvm/test/Transforms/EarlyCSE/opaque-ptr.ll

 ; CHECK-NEXT:    ret i32 [[SUB]]
 ;
   store i32 %a, ptr %p
   %v2 = load i64, ptr %p
   %v2.c = trunc i64 %v2 to i32
   %sub = sub i32 %a, %v2.c
   ret i32 %sub
 }
+
+define void @dse(ptr %p, i32 %i1, i8 %i2) {
+; CHECK-LABEL: @dse(
+; CHECK-NEXT:    store i32 [[I1:%.*]], ptr [[P:%.*]], align 4
+; CHECK-NEXT:    store i8 [[I2:%.*]], ptr [[P]], align 1
+; CHECK-NEXT:    ret void
+;
+  store i32 %i1, ptr %p
+  store i8 %i2, ptr %p
+  ret void
+}