llvm/test/Transforms/GVN/assume-equal.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes=gvn -S | FileCheck %s

target datalayout = "p1:64:64:64:32"

%struct.A = type { ptr }
@_ZTV1A = available_externally unnamed_addr constant [4 x ptr] [ptr null, ptr @_ZTI1A, ptr @_ZN1A3fooEv, ptr @_ZN1A3barEv], align 8
@_ZTI1A = external constant ptr

; Checks if indirect calls can be replaced with direct
; assuming that %vtable == @_ZTV1A (with alignment).
; Checking const propagation across other BBs

define void @_Z1gb(i1 zeroext %p) {
; CHECK-LABEL: define void @_Z1gb(
; CHECK-SAME: i1 zeroext [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias ptr @_Znwm(i64 8)
; CHECK-NEXT:    tail call void @_ZN1AC1Ev(ptr [[CALL]])
; CHECK-NEXT:    [[VTABLE:%.*]] = load ptr, ptr [[CALL]], align 8
; CHECK-NEXT:    [[CMP_VTABLES:%.*]] = icmp eq ptr [[VTABLE]], getelementptr inbounds ([4 x ptr], ptr @_ZTV1A, i64 0, i64 2)
; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP_VTABLES]])
; CHECK-NEXT:    br i1 [[P]], label %[[IF_THEN:.*]], label %[[IF_ELSE:.*]]
; CHECK:       [[IF_THEN]]:
; CHECK-NEXT:    [[CALL2:%.*]] = tail call i32 @_ZN1A3fooEv(ptr [[CALL]])
; CHECK-NEXT:    br label %[[IF_END:.*]]
; CHECK:       [[IF_ELSE]]:
; CHECK-NEXT:    [[CALL5:%.*]] = tail call i32 @_ZN1A3barEv(ptr [[CALL]])
; CHECK-NEXT:    br label %[[IF_END]]
; CHECK:       [[IF_END]]:
; CHECK-NEXT:    ret void
;
entry:
  %call = tail call noalias ptr @_Znwm(i64 8) #4
  tail call void @_ZN1AC1Ev(ptr %call) #1
  %vtable = load ptr, ptr %call, align 8
  %cmp.vtables = icmp eq ptr %vtable, getelementptr inbounds ([4 x ptr], ptr @_ZTV1A, i64 0, i64 2)
  tail call void @llvm.assume(i1 %cmp.vtables)
  br i1 %p, label %if.then, label %if.else

if.then:                                          ; preds = %entry
  %0 = load ptr, ptr %vtable, align 8

  %call2 = tail call i32 %0(ptr %call) #1

  br label %if.end

if.else:                                          ; preds = %entry
  %vfn47 = getelementptr inbounds ptr, ptr %vtable, i64 1

  %1 = load ptr, ptr %vfn47, align 8

  %call5 = tail call i32 %1(ptr %call) #1
  br label %if.end

if.end:                                           ; preds = %if.else, %if.then
  ret void
}

; Check integration with invariant.group handling
define void @invariantGroupHandling(i1 zeroext %p) {
; CHECK-LABEL: define void @invariantGroupHandling(
; CHECK-SAME: i1 zeroext [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias ptr @_Znwm(i64 8)
; CHECK-NEXT:    tail call void @_ZN1AC1Ev(ptr [[CALL]])
; CHECK-NEXT:    [[VTABLE:%.*]] = load ptr, ptr [[CALL]], align 8, !invariant.group [[META0:![0-9]+]]
; CHECK-NEXT:    [[CMP_VTABLES:%.*]] = icmp eq ptr [[VTABLE]], getelementptr inbounds ([4 x ptr], ptr @_ZTV1A, i64 0, i64 2)
; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP_VTABLES]])
; CHECK-NEXT:    br i1 [[P]], label %[[IF_THEN:.*]], label %[[IF_ELSE:.*]]
; CHECK:       [[IF_THEN]]:
; CHECK-NEXT:    [[CALL2:%.*]] = tail call i32 @_ZN1A3fooEv(ptr [[CALL]])
; CHECK-NEXT:    [[CALLX:%.*]] = tail call i32 @_ZN1A3fooEv(ptr [[CALL]])
; CHECK-NEXT:    [[CALLY:%.*]] = tail call i32 @_ZN1A3fooEv(ptr [[CALL]])
; CHECK-NEXT:    [[UNKNOWN:%.*]] = tail call i32 @_ZN1A3fooEv(ptr [[CALL]])
; CHECK-NEXT:    br label %[[IF_END:.*]]
; CHECK:       [[IF_ELSE]]:
; CHECK-NEXT:    [[CALL5:%.*]] = tail call i32 @_ZN1A3barEv(ptr [[CALL]])
; CHECK-NEXT:    br label %[[IF_END]]
; CHECK:       [[IF_END]]:
; CHECK-NEXT:    ret void
;
entry:
  %call = tail call noalias ptr @_Znwm(i64 8) #4
  tail call void @_ZN1AC1Ev(ptr %call) #1
  %vtable = load ptr, ptr %call, align 8, !invariant.group !0
  %cmp.vtables = icmp eq ptr %vtable, getelementptr inbounds ([4 x ptr], ptr @_ZTV1A, i64 0, i64 2)
  tail call void @llvm.assume(i1 %cmp.vtables)
  br i1 %p, label %if.then, label %if.else

if.then:                                          ; preds = %entry
  %0 = load ptr, ptr %vtable, align 8

  %call2 = tail call i32 %0(ptr %call) #1
  %vtable1 = load ptr, ptr %call, align 8, !invariant.group !0
  %call1 = load ptr, ptr %vtable1, align 8
  %callx = tail call i32 %call1(ptr %call) #1

  %vtable2 = load ptr, ptr %call, align 8, !invariant.group !0
  %call4 = load ptr, ptr %vtable2, align 8
  %cally = tail call i32 %call4(ptr %call) #1

  %vtable3 = load ptr, ptr %call, align 8, !invariant.group !0
  %vfun = load ptr, ptr %vtable3, align 8
  %unknown = tail call i32 %vfun(ptr %call) #1

  br label %if.end

if.else:                                          ; preds = %entry
  %vfn47 = getelementptr inbounds ptr, ptr %vtable, i64 1

  %1 = load ptr, ptr %vfn47, align 8

  %call5 = tail call i32 %1(ptr %call) #1
  br label %if.end

if.end:                                           ; preds = %if.else, %if.then
  ret void
}


; Checking const propagation in the same BB

define i32 @main() {
; CHECK-LABEL: define i32 @main() {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias ptr @_Znwm(i64 8)
; CHECK-NEXT:    tail call void @_ZN1AC1Ev(ptr [[CALL]])
; CHECK-NEXT:    [[VTABLE:%.*]] = load ptr, ptr [[CALL]], align 8
; CHECK-NEXT:    [[CMP_VTABLES:%.*]] = icmp eq ptr [[VTABLE]], getelementptr inbounds ([4 x ptr], ptr @_ZTV1A, i64 0, i64 2)
; CHECK-NEXT:    tail call void @llvm.assume(i1 [[CMP_VTABLES]])
; CHECK-NEXT:    [[CALL2:%.*]] = tail call i32 @_ZN1A3fooEv(ptr [[CALL]])
; CHECK-NEXT:    ret i32 0
;
entry:
  %call = tail call noalias ptr @_Znwm(i64 8)
  tail call void @_ZN1AC1Ev(ptr %call)
  %vtable = load ptr, ptr %call, align 8
  %cmp.vtables = icmp eq ptr %vtable, getelementptr inbounds ([4 x ptr], ptr @_ZTV1A, i64 0, i64 2)
  tail call void @llvm.assume(i1 %cmp.vtables)

  %0 = load ptr, ptr %vtable, align 8

  %call2 = tail call i32 %0(ptr %call)
  ret i32 0
}

; This tests checks const propatation with fcmp instruction.

define float @_Z1gf(float %p) {
; CHECK-LABEL: define float @_Z1gf(
; CHECK-SAME: float [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[P_ADDR:%.*]] = alloca float, align 4
; CHECK-NEXT:    [[F:%.*]] = alloca float, align 4
; CHECK-NEXT:    store float [[P]], ptr [[P_ADDR]], align 4
; CHECK-NEXT:    store float 3.000000e+00, ptr [[F]], align 4
; CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq float 3.000000e+00, [[P]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    ret float 3.000000e+00
;
entry:
  %p.addr = alloca float, align 4
  %f = alloca float, align 4
  store float %p, ptr %p.addr, align 4

  store float 3.000000e+00, ptr %f, align 4
  %0 = load float, ptr %p.addr, align 4
  %1 = load float, ptr %f, align 4
  %cmp = fcmp oeq float %1, %0 ; note const on lhs
  call void @llvm.assume(i1 %cmp)

  ret float %0
}


define float @_Z1hf(float %p) {
; CHECK-LABEL: define float @_Z1hf(
; CHECK-SAME: float [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[P_ADDR:%.*]] = alloca float, align 4
; CHECK-NEXT:    store float [[P]], ptr [[P_ADDR]], align 4
; CHECK-NEXT:    [[CMP:%.*]] = fcmp nnan ueq float [[P]], 3.000000e+00
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    ret float 3.000000e+00
;
entry:
  %p.addr = alloca float, align 4
  store float %p, ptr %p.addr, align 4

  %0 = load float, ptr %p.addr, align 4
  %cmp = fcmp nnan ueq float %0, 3.000000e+00
  call void @llvm.assume(i1 %cmp)

  ret float %0
}

define float @_Z1if(float %p) {
; CHECK-LABEL: define float @_Z1if(
; CHECK-SAME: float [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[P_ADDR:%.*]] = alloca float, align 4
; CHECK-NEXT:    store float [[P]], ptr [[P_ADDR]], align 4
; CHECK-NEXT:    [[CMP:%.*]] = fcmp ueq float [[P]], 3.000000e+00
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    ret float [[P]]
;
entry:
  %p.addr = alloca float, align 4
  store float %p, ptr %p.addr, align 4

  %0 = load float, ptr %p.addr, align 4
  %cmp = fcmp ueq float %0, 3.000000e+00 ; no nnan flag - can't propagate
  call void @llvm.assume(i1 %cmp)

  ret float %0
}

; This test checks if constant propagation works for multiple node edges
define i32 @_Z1ii(i32 %p) {
; CHECK-LABEL: define i32 @_Z1ii(
; CHECK-SAME: i32 [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[P]], 42
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    br i1 true, label %[[COMMON:.*]], label %[[COMMON]]
; CHECK:       [[COMMON]]:
; CHECK-NEXT:    br i1 true, label %[[COMMON]], label %[[COMMON]]
; CHECK:       [[EXIT:.*:]]
; CHECK-NEXT:    ret i32 42
;
entry:
  %cmp = icmp eq i32 %p, 42
  call void @llvm.assume(i1 %cmp)

  br i1 %cmp, label %common, label %common
common:
  call void @llvm.assume(i1 true)
  br i1 %cmp, label %common, label %common

exit:
  ret i32 %p
}

define i32 @_Z1ij(i32 %p) {
; CHECK-LABEL: define i32 @_Z1ij(
; CHECK-SAME: i32 [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[P]], 42
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    br i1 true, label %[[BB2:.*]], label %[[BB2]]
; CHECK:       [[BB2]]:
; CHECK-NEXT:    br i1 true, label %[[BB2]], label %[[BB2]]
; CHECK:       [[BB0:.*:]]
; CHECK-NEXT:    ret i32 42
;
entry:
  %cmp = icmp eq i32 %p, 42
  call void @llvm.assume(i1 %cmp)

  br i1 %cmp, label %bb2, label %bb2
bb2:
  %cmp2 = icmp eq i32 %p, 42
  call void @llvm.assume(i1 %cmp2)

  br i1 %cmp, label %bb2, label %bb2

  ret i32 %p
}

define i32 @_Z1ik(i32 %p) {
; CHECK-LABEL: define i32 @_Z1ik(
; CHECK-SAME: i32 [[P:%.*]]) {
; CHECK-NEXT:  [[ENTRY:.*:]]
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[P]], 42
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    br i1 true, label %[[BB2:.*]], label %[[BB3:.*]]
; CHECK:       [[BB2]]:
; CHECK-NEXT:    store i8 poison, ptr null, align 1
; CHECK-NEXT:    ret i32 15
; CHECK:       [[BB3]]:
; CHECK-NEXT:    ret i32 17
;
entry:
  %cmp = icmp eq i32 %p, 42
  call void @llvm.assume(i1 %cmp)

  br i1 %cmp, label %bb2, label %bb3
bb2:
  %cmp3 = icmp eq i32 %p, 43
  call void @llvm.assume(i1 %cmp3)
  ret i32 15
bb3:
  ret i32 17
}

; This test checks if GVN can do the constant propagation correctly
; when there are multiple uses of the same assume value in the
; basic block that has a loop back-edge pointing to itself.
;
define i32 @_Z1il(i32 %val, i1 %k) {
; CHECK-LABEL: define i32 @_Z1il(
; CHECK-SAME: i32 [[VAL:%.*]], i1 [[K:%.*]]) {
; CHECK-NEXT:    br label %[[NEXT:.*]]
; CHECK:       [[NEXT]]:
; CHECK-NEXT:    tail call void @llvm.assume(i1 [[K]])
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[VAL]], 50
; CHECK-NEXT:    br i1 [[CMP]], label %[[NEXT]], label %[[MEH:.*]]
; CHECK:       [[MEH]]:
; CHECK-NEXT:    ret i32 0
;
  br label %next

next:
  tail call void @llvm.assume(i1 %k)
  tail call void @llvm.assume(i1 %k)
  %cmp = icmp eq i32 %val, 50
  br i1 %cmp, label %next, label %meh

meh:
  ret i32 0
}

; This test checks if GVN can prevent the constant propagation correctly
; in the successor blocks that are not dominated by the basic block
; with the assume instruction.
;
define i1 @_z1im(i32 %val, i1 %k, i1 %j) {
; CHECK-LABEL: define i1 @_z1im(
; CHECK-SAME: i32 [[VAL:%.*]], i1 [[K:%.*]], i1 [[J:%.*]]) {
; CHECK-NEXT:    br i1 [[J]], label %[[NEXT:.*]], label %[[MEH:.*]]
; CHECK:       [[NEXT]]:
; CHECK-NEXT:    tail call void @llvm.assume(i1 [[K]])
; CHECK-NEXT:    br label %[[MEH]]
; CHECK:       [[MEH]]:
; CHECK-NEXT:    ret i1 [[K]]
;
  br i1 %j, label %next, label %meh

next:
  tail call void @llvm.assume(i1 %k)
  tail call void @llvm.assume(i1 %k)
  br label %meh

meh:
  ret i1 %k
}

define i8 @assume_ptr_eq_different_prov_matters(ptr %p, ptr %p2) {
; CHECK-LABEL: define i8 @assume_ptr_eq_different_prov_matters(
; CHECK-SAME: ptr [[P:%.*]], ptr [[P2:%.*]]) {
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[V:%.*]] = load i8, ptr [[P2]], align 1
; CHECK-NEXT:    ret i8 [[V]]
;
  %cmp = icmp eq ptr %p, %p2
  call void @llvm.assume(i1 %cmp)
  %v = load i8, ptr %p2
  ret i8 %v
}

define i1 @assume_ptr_eq_different_prov_does_not_matter_icmp(ptr %p, ptr %p2) {
; CHECK-LABEL: define i1 @assume_ptr_eq_different_prov_does_not_matter_icmp(
; CHECK-SAME: ptr [[P:%.*]], ptr [[P2:%.*]]) {
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[C:%.*]] = icmp eq ptr [[P]], null
; CHECK-NEXT:    ret i1 [[C]]
;
  %cmp = icmp eq ptr %p, %p2
  call void @llvm.assume(i1 %cmp)
  %c = icmp eq ptr %p2, null
  ret i1 %c
}

define i1 @assume_ptr_eq_different_prov_does_not_matter_icmp_addrsize(ptr addrspace(1) %p, ptr addrspace(1) %p2) {
; CHECK-LABEL: define i1 @assume_ptr_eq_different_prov_does_not_matter_icmp_addrsize(
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], ptr addrspace(1) [[P2:%.*]]) {
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(1) [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[C:%.*]] = icmp eq ptr addrspace(1) [[P]], null
; CHECK-NEXT:    ret i1 [[C]]
;
  %cmp = icmp eq ptr addrspace(1) %p, %p2
  call void @llvm.assume(i1 %cmp)
  %c = icmp eq ptr addrspace(1) %p2, null
  ret i1 %c
}

; This is not correct, as it may change the provenance exposed by ptrtoint.
; We still allow it for now.
define i64 @assume_ptr_eq_different_prov_does_not_matter_ptrtoint(ptr %p, ptr %p2) {
; CHECK-LABEL: define i64 @assume_ptr_eq_different_prov_does_not_matter_ptrtoint(
; CHECK-SAME: ptr [[P:%.*]], ptr [[P2:%.*]]) {
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[INT:%.*]] = ptrtoint ptr [[P]] to i64
; CHECK-NEXT:    ret i64 [[INT]]
;
  %cmp = icmp eq ptr %p, %p2
  call void @llvm.assume(i1 %cmp)
  %int = ptrtoint ptr %p2 to i64
  ret i64 %int
}

; If the pointer and address size does not match, we can't replace a pointer
; with different provenance in ptrtoint, as the non-address bits may not match.
define i64 @assume_ptr_eq_different_prov_matters_ptrtoint_addrsize(ptr addrspace(1) %p, ptr addrspace(1) %p2) {
; CHECK-LABEL: define i64 @assume_ptr_eq_different_prov_matters_ptrtoint_addrsize(
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], ptr addrspace(1) [[P2:%.*]]) {
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(1) [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[INT:%.*]] = ptrtoint ptr addrspace(1) [[P2]] to i64
; CHECK-NEXT:    ret i64 [[INT]]
;
  %cmp = icmp eq ptr addrspace(1) %p, %p2
  call void @llvm.assume(i1 %cmp)
  %int = ptrtoint ptr addrspace(1) %p2 to i64
  ret i64 %int
}

define i64 @assume_ptr_eq_different_prov_does_not_matter_ptrtoaddr(ptr %p, ptr %p2) {
; CHECK-LABEL: define i64 @assume_ptr_eq_different_prov_does_not_matter_ptrtoaddr(
; CHECK-SAME: ptr [[P:%.*]], ptr [[P2:%.*]]) {
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[INT:%.*]] = ptrtoaddr ptr [[P]] to i64
; CHECK-NEXT:    ret i64 [[INT]]
;
  %cmp = icmp eq ptr %p, %p2
  call void @llvm.assume(i1 %cmp)
  %int = ptrtoaddr ptr %p2 to i64
  ret i64 %int
}

define i32 @assume_ptr_eq_different_prov_does_not_matter_ptrtoaddr_addrsize(ptr addrspace(1) %p, ptr addrspace(1) %p2) {
; CHECK-LABEL: define i32 @assume_ptr_eq_different_prov_does_not_matter_ptrtoaddr_addrsize(
; CHECK-SAME: ptr addrspace(1) [[P:%.*]], ptr addrspace(1) [[P2:%.*]]) {
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr addrspace(1) [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[INT:%.*]] = ptrtoaddr ptr addrspace(1) [[P]] to i32
; CHECK-NEXT:    ret i32 [[INT]]
;
  %cmp = icmp eq ptr addrspace(1) %p, %p2
  call void @llvm.assume(i1 %cmp)
  %int = ptrtoaddr ptr addrspace(1) %p2 to i32
  ret i32 %int
}

define i8 @assume_ptr_eq_same_prov(ptr %p, i64 %x) {
; CHECK-LABEL: define i8 @assume_ptr_eq_same_prov(
; CHECK-SAME: ptr [[P:%.*]], i64 [[X:%.*]]) {
; CHECK-NEXT:    [[P2:%.*]] = getelementptr i8, ptr [[P]], i64 [[X]]
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[P]], [[P2]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    [[V:%.*]] = load i8, ptr [[P]], align 1
; CHECK-NEXT:    ret i8 [[V]]
;
  %p2 = getelementptr i8, ptr %p, i64 %x
  %cmp = icmp eq ptr %p, %p2
  call void @llvm.assume(i1 %cmp)
  %v = load i8, ptr %p2
  ret i8 %v
}

define ptr @test_strip_invariant(ptr %x) {
; CHECK-LABEL: define ptr @test_strip_invariant(
; CHECK-SAME: ptr [[X:%.*]]) {
; CHECK-NEXT:    [[X_STRIP:%.*]] = call ptr @llvm.strip.invariant.group.p0(ptr [[X]])
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[X]], [[X_STRIP]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    ret ptr [[X_STRIP]]
;
  %x.strip = call ptr @llvm.strip.invariant.group(ptr %x)
  %cmp = icmp eq ptr %x, %x.strip
  call void @llvm.assume(i1 %cmp)
  ret ptr %x.strip
}

define ptr @test_launder_invariant(ptr %x) {
; CHECK-LABEL: define ptr @test_launder_invariant(
; CHECK-SAME: ptr [[X:%.*]]) {
; CHECK-NEXT:    [[X_LAUNDER:%.*]] = call ptr @llvm.launder.invariant.group.p0(ptr [[X]])
; CHECK-NEXT:    [[CMP:%.*]] = icmp eq ptr [[X]], [[X_LAUNDER]]
; CHECK-NEXT:    call void @llvm.assume(i1 [[CMP]])
; CHECK-NEXT:    ret ptr [[X_LAUNDER]]
;
  %x.launder = call ptr @llvm.launder.invariant.group(ptr %x)
  %cmp = icmp eq ptr %x, %x.launder
  call void @llvm.assume(i1 %cmp)
  ret ptr %x.launder
}

declare noalias ptr @_Znwm(i64)
declare void @_ZN1AC1Ev(ptr)
declare void @llvm.assume(i1)
declare i32 @_ZN1A3fooEv(ptr)
declare i32 @_ZN1A3barEv(ptr)

!0 = !{!"struct A"}
;.
; CHECK: [[META0]] = !{!"struct A"}
;.