Constant fold launder of null and undef

[Prazek]

Summary

This might be useful because clang will add
barriers for pointer comparisons.

[davide]

I guess the patch is implemented correctly, but, can you please provide an example of clang emitting such construct?

[Prazek]

In D32423#735352, @davide wrote:

I guess the patch is implemented correctly, but, can you please provide an example of clang emitting such construct?

Check out https://reviews.llvm.org/D32378
Clang will add barriers for some of pointer casts and pointer compares, so it is important to propagate null.
Propagating undef is only to make sure barriers don't limit optimizations like DCE etc.

[davide]

This is fine but please hold committing it until the other half goes in.

test/Transforms/GVN/invariant.group.ll

488–490 ↗

(On Diff #96358)

CHECK-NEXT:

493–495 ↗

(On Diff #96358)

CHECK-NEXT:

[Prazek]

• check-next

[majnemer]

lib/Analysis/InstructionSimplify.cpp

4432–4438 ↗

(On Diff #96400)

This probably belongs in the constant folder.

[Prazek]

lib/Analysis/InstructionSimplify.cpp

4432–4438 ↗

(On Diff #96400)

Do you mean folding barrier(const) -> const?

[majnemer]

lib/Analysis/InstructionSimplify.cpp

4432–4438 ↗

(On Diff #96400)

Not for all constants, just undef and null in address space zero.

[Prazek]

lib/Analysis/InstructionSimplify.cpp

4432–4438 ↗

(On Diff #96400)

I don't understand what you mean. Do you mean to move this code somewhere else?

[davide]

Yes, move to ConstantFold*

[Prazek]

moved to constant folder

[Prazek]

Thanks, I didn't know ConstantFolder exists

[majnemer]

lib/Analysis/ConstantFolding.cpp

1779–1783 ↗

(On Diff #96437)

Isn't this only valid if the address space is zero?

[Prazek]

lib/Analysis/ConstantFolding.cpp

1779–1783 ↗

(On Diff #96437)

True, but can you pass pointer from another addrspace to invariant.group.barrier?

When I try

%X = addrspacecast i8* null to i8 addrspace(1)*
%b2 = call i8* @llvm.invariant.group.barrier(i8* %X)

I get

error: '%X' defined with type 'i8 addrspace(1)*'

I could add this line:

cast<PointerType>(Operands[0]->getType())->getAddressSpace() == 0

but I won't be able to test it in any way if I am not wrong.

[davide]

lib/Analysis/ConstantFolding.cpp

1779–1783 ↗

(On Diff #96437)

Not positive about this, but does it work if you do:

%b2 = call i8* @llvm.invariant.group.barrier(i8* addrspace(4)* @global0)

where

@global0 = addrspace(4) constant i8* null

[Prazek]

lib/Analysis/ConstantFolding.cpp

1779–1783 ↗

(On Diff #96437)

Thanks for help Davide, but it still doesn't work for me. I get the following error:

error: '@llvm.invariant.group.barrier' defined with type 'i8* (i8*)*'
  %b = call i8* @llvm.invariant.group.barrier(i8* addrspace(4)* @global0)
                ^

the code looks like this

@global0 = addrspace(4) constant i8* null

define i8* @differentAddrspace() {
  %b = call i8* @llvm.invariant.group.barrier(i8* addrspace(4)* @global0)
  ret i8* %b
}

declare i8* @llvm.invariant.group.barrier(i8*)

[Prazek]

Rebasing

[amharc]

llvm/test/Transforms/InstCombine/invariant.group.ll

5

nit: simplify (in other places too)

[Prazek]

Fixed typos

[kuhar]

LGTM

llvm/lib/Analysis/ConstantFolding.cpp

bool llvm::canConstantFoldCallTo(ImmutableCallSite CS, const Function *F) {
   case Intrinsic::powi:
   case Intrinsic::bswap:
   case Intrinsic::ctpop:
   case Intrinsic::ctlz:
   case Intrinsic::cttz:
   case Intrinsic::fma:
   case Intrinsic::fmuladd:
   case Intrinsic::copysign:
+  case Intrinsic::launder_invariant_group:
   case Intrinsic::round:
   case Intrinsic::masked_load:
   case Intrinsic::sadd_with_overflow:
   case Intrinsic::uadd_with_overflow:
   case Intrinsic::ssub_with_overflow:
   case Intrinsic::usub_with_overflow:
   case Intrinsic::smul_with_overflow:
   case Intrinsic::umul_with_overflow:
Constant *ConstantFoldScalarCall(StringRef Name, unsigned IntrinsicID, Type *Ty,
                                  ArrayRef<Constant *> Operands,
                                  const TargetLibraryInfo *TLI) {
   if (Operands.size() == 1) {
     if (isa<UndefValue>(Operands[0])) {
       // cosine(arg) is between -1 and 1. cosine(invalid arg) is NaN
       if (IntrinsicID == Intrinsic::cos)
         return Constant::getNullValue(Ty);
       if (IntrinsicID == Intrinsic::bswap ||
-          IntrinsicID == Intrinsic::bitreverse)
+          IntrinsicID == Intrinsic::bitreverse ||
+          IntrinsicID == Intrinsic::launder_invariant_group)
         return Operands[0];
     }
+
+    if (isa<ConstantPointerNull>(Operands[0]) &&
+        Operands[0]->getType()->getPointerAddressSpace() == 0) {
+      // launder(null) == null iff in addrspace 0
+      if (IntrinsicID == Intrinsic::launder_invariant_group)
+        return Operands[0];
+      return nullptr;
+    }
+
     if (auto *Op = dyn_cast<ConstantFP>(Operands[0])) {
       if (IntrinsicID == Intrinsic::convert_to_fp16) {
         APFloat Val(Op->getValueAPF());
 
         bool lost = false;
         Val.convert(APFloat::IEEEhalf(), APFloat::rmNearestTiesToEven, &lost);
 
         return ConstantInt::get(Ty->getContext(), Val.bitcastToAPInt());

llvm/lib/Transforms/Utils/Local.cpp

bool llvm::wouldInstructionBeTriviallyDead(Instruction *I,
   }
 
   if (!I->mayHaveSideEffects())
     return true;
 
   // Special case intrinsics that "may have side effects" but can be deleted
   // when dead.
   if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
-    // Safe to delete llvm.stacksave if dead.
-    if (II->getIntrinsicID() == Intrinsic::stacksave)
+    // Safe to delete llvm.stacksave and launder.invariant.group if dead.
+    if (II->getIntrinsicID() == Intrinsic::stacksave ||
+        II->getIntrinsicID() == Intrinsic::launder_invariant_group)
       return true;
 
     // Lifetime intrinsics are dead when their right-hand is undef.
     if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
         II->getIntrinsicID() == Intrinsic::lifetime_end)
       return isa<UndefValue>(II->getArgOperand(1));
 
     // Assumptions are dead if their condition is trivially true.  Guards on

llvm/test/Transforms/InstCombine/invariant.group.ll

+; RUN: opt -instcombine -S < %s | FileCheck %s
+
+; CHECK-LABEL: define i8* @simplifyNullLaunder()
+define i8* @simplifyNullLaunder() {
+; CHECK-NEXT: ret i8* null
+  %b2 = call i8* @llvm.launder.invariant.group.p0i8(i8* null)
+  ret i8* %b2
+}
+
+; CHECK-LABEL: define i8 addrspace(42)* @dontsimplifyNullLaunderForDifferentAddrspace()
+define i8 addrspace(42)* @dontsimplifyNullLaunderForDifferentAddrspace() {
+; CHECK: %b2 = call i8 addrspace(42)* @llvm.launder.invariant.group.p42i8(i8 addrspace(42)* null)
+; CHECK: ret i8 addrspace(42)* %b2
+  %b2 = call i8 addrspace(42)* @llvm.launder.invariant.group.p42i8(i8 addrspace(42)* null)
+  ret i8 addrspace(42)* %b2
+}
+
+; CHECK-LABEL: define i8* @simplifyUndefLaunder()
+define i8* @simplifyUndefLaunder() {
+; CHECK-NEXT: ret i8* undef
+  %b2 = call i8* @llvm.launder.invariant.group.p0i8(i8* undef)
+  ret i8* %b2
+}
+
+; CHECK-LABEL: define i8 addrspace(42)* @simplifyUndefLaunder2()
+define i8 addrspace(42)* @simplifyUndefLaunder2() {
+; CHECK-NEXT: ret i8 addrspace(42)* undef
+  %b2 = call i8 addrspace(42)* @llvm.launder.invariant.group.p42i8(i8 addrspace(42)* undef)
+  ret i8 addrspace(42)* %b2
+}
+
+
+declare i8* @llvm.launder.invariant.group.p0i8(i8*)
+declare i8 addrspace(42)* @llvm.launder.invariant.group.p42i8(i8 addrspace(42)*)