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

CHECK-NEXT:

493–495

CHECK-NEXT:

[Prazek]

• check-next

[majnemer]

lib/Analysis/InstructionSimplify.cpp

4432–4438

This probably belongs in the constant folder.

[Prazek]

lib/Analysis/InstructionSimplify.cpp

4432–4438

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

[majnemer]

lib/Analysis/InstructionSimplify.cpp

4432–4438

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

[Prazek]

lib/Analysis/InstructionSimplify.cpp

4432–4438

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

4 ↗

(On Diff #145366)

nit: simplify (in other places too)

[Prazek]

Fixed typos

[kuhar]

LGTM

lib/Analysis/InstructionSimplify.cpp

if (NumOperands == 1) {
     }
 
     switch (IID) {
     case Intrinsic::fabs: {
       if (SignBitMustBeZero(*ArgBegin, Q.TLI))
         return *ArgBegin;
       return nullptr;
     }
+    case Intrinsic::invariant_group_barrier: {
+      // invariant.group.barrier(null) -> null
+      // invariant.group.barrier(undef) -> undef
+      if (isa<UndefValue>(*ArgBegin) || isa<ConstantPointerNull>(*ArgBegin))
+        return *ArgBegin;
+      return nullptr;
+    }
     default:
       return nullptr;
     }
   }
 
   // Binary Ops
   if (NumOperands == 2) {
     Value *LHS = *ArgBegin;

test/Transforms/GVN/invariant.group.ll

define void @dontSimplifyBarrier(i8* %p) {
   %b2 = call i8* @llvm.invariant.group.barrier(i8* %b1)
   call void @foo(i8* %b2)
   %b3 = call i8* @llvm.invariant.group.barrier(i8* %b1)
   call void @foo(i8* %b3)
   call void @foo(i8* %b3)
   ret void
 }
 
+; CHECK-LABEL: define i8* @siplifyNullBarrier()
+define i8* @siplifyNullBarrier() {
+; CHECK: ret i8* null
+  %b2 = call i8* @llvm.invariant.group.barrier(i8* null)
+  ret i8* %b2
+}
+
+; CHECK-LABEL: define i8* @siplifyUndefBarrier()
+define i8* @siplifyUndefBarrier() {
+; CHECK: ret i8* undef
+  %b2 = call i8* @llvm.invariant.group.barrier(i8* undef)
+  ret i8* %b2
+}
+
 
 declare void @foo(i8*)
 declare void @foo2(i8*, i8)
 declare void @bar(i8)
 declare i8* @getPointer(i8*)
 declare void @_ZN1A3fooEv(%struct.A*)
 declare void @_ZN1AC1Ev(%struct.A*)
 declare void @fooBit(i1*, i1)