This is an archive of the discontinued LLVM Phabricator instance.

Differential D82688

[NewPM][BasicAA] basicaa -> basic-aa in Transforms/{New,}GVN
ClosedPublic

Authored by aeubanks on Jun 26 2020, 3:13 PM.

Details

Reviewers
ychen
asbirlea
Commits
rG059994f2190f: [NewPM][BasicAA] basicaa -> basic-aa in Transforms/{New,}GVN
Summary

Following https://reviews.llvm.org/D82607.

Diff Detail

Event Timeline

aeubanks created this revision.Jun 26 2020, 3:13 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 26 2020, 3:13 PM
Herald added subscribers: llvm-commits, asbirlea. · View Herald Transcript
asbirlea accepted this revision.Jun 26 2020, 3:50 PM

Thanks you!

This revision is now accepted and ready to land.Jun 26 2020, 3:50 PM
Harbormaster failed remote builds in B61994: Diff 273847!Jun 26 2020, 4:13 PM
Closed by commit rG059994f2190f: [NewPM][BasicAA] basicaa -> basic-aa in Transforms/{New,}GVN (authored by aeubanks). · Explain WhyJun 26 2020, 8:34 PM
This revision was automatically updated to reflect the committed changes.
MaskRay added a subscriber: MaskRay.Jun 26 2020, 8:43 PM

Hi, your git commit contains extra Phabricator tags. You can drop Reviewers: Subscribers: Tags: and the text Summary: from the git commit with the following script:

arcfilter () {
        arc amend
        git log -1 --pretty=%B | awk '/Reviewers:|Subscribers:/{p=1} /Reviewed By:|Differential Revision:/{p=0} !p && !/^Summary:$/ {sub(/^Summary: /,"");print}' | git commit --amend --date=now -F -
}

Reviewed By: is considered important by some people. Please keep the tag. (I have updated my script to use --date=now (setting author date to committer date))

https://reviews.llvm.org/D80978 contains a git pre-push hook to automate this.

Revision Contents

PathSize
llvm/
test/
Transforms/
GVN/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
PRE/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
NewGVN/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines

Diff 273881

llvm/test/Transforms/GVN/2007-07-25-InfiniteLoop.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
%struct.INT2 = type { i32, i32 } %struct.INT2 = type { i32, i32 }
@blkshifts = external global %struct.INT2* ; <%struct.INT2**> [#uses=2] @blkshifts = external global %struct.INT2* ; <%struct.INT2**> [#uses=2]
define i32 @xcompact() { define i32 @xcompact() {
entry: entry:
store %struct.INT2* null, %struct.INT2** @blkshifts, align 4 store %struct.INT2* null, %struct.INT2** @blkshifts, align 4
br label %bb br label %bb
bb: ; preds = %bb, %entry bb: ; preds = %bb, %entry
%tmp10 = load %struct.INT2*, %struct.INT2** @blkshifts, align 4 ; <%struct.INT2*> [#uses=0] %tmp10 = load %struct.INT2*, %struct.INT2** @blkshifts, align 4 ; <%struct.INT2*> [#uses=0]
; CHECK-NOT: %tmp10 ; CHECK-NOT: %tmp10
br label %bb br label %bb
} }

llvm/test/Transforms/GVN/2007-07-26-InterlockingLoops.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
@last = external global [65 x i32*] @last = external global [65 x i32*]
define i32 @NextRootMove(i32 %wtm, i32 %x, i32 %y, i32 %z) { define i32 @NextRootMove(i32 %wtm, i32 %x, i32 %y, i32 %z) {
entry: entry:
%A = alloca i32* %A = alloca i32*
%tmp17618 = load i32*, i32** getelementptr ([65 x i32*], [65 x i32*]* @last, i32 0, i32 1), align 4 %tmp17618 = load i32*, i32** getelementptr ([65 x i32*], [65 x i32*]* @last, i32 0, i32 1), align 4
store i32* %tmp17618, i32** %A store i32* %tmp17618, i32** %A
Show All 31 Lines

llvm/test/Transforms/GVN/2007-07-31-NoDomInherit.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
%struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* } %struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* }
@debug = external constant i32 ; <i32*> [#uses=0] @debug = external constant i32 ; <i32*> [#uses=0]
@counters = external constant i32 ; <i32*> [#uses=1] @counters = external constant i32 ; <i32*> [#uses=1]
@trialx = external global [17 x i32] ; <[17 x i32]*> [#uses=1] @trialx = external global [17 x i32] ; <[17 x i32]*> [#uses=1]
@dummy1 = external global [7 x i32] ; <[7 x i32]*> [#uses=0] @dummy1 = external global [7 x i32] ; <[7 x i32]*> [#uses=0]
@dummy2 = external global [4 x i32] ; <[4 x i32]*> [#uses=0] @dummy2 = external global [4 x i32] ; <[4 x i32]*> [#uses=0]
@unacceptable = external global i32 ; <i32*> [#uses=0] @unacceptable = external global i32 ; <i32*> [#uses=0]
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/2007-07-31-RedundantPhi.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
@img_width = external global i16 ; <i16*> [#uses=2] @img_width = external global i16 ; <i16*> [#uses=2]
define i32 @smpUMHEXBipredIntegerPelBlockMotionSearch(i16* %cur_pic, i16 signext %ref, i32 %list, i32 %pic_pix_x, i32 %pic_pix_y, i32 %blocktype, i16 signext %pred_mv_x1, i16 signext %pred_mv_y1, i16 signext %pred_mv_x2, i16 signext %pred_mv_y2, i16* %mv_x, i16* %mv_y, i16* %s_mv_x, i16* %s_mv_y, i32 %search_range, i32 %min_mcost, i32 %lambda_factor) { define i32 @smpUMHEXBipredIntegerPelBlockMotionSearch(i16* %cur_pic, i16 signext %ref, i32 %list, i32 %pic_pix_x, i32 %pic_pix_y, i32 %blocktype, i16 signext %pred_mv_x1, i16 signext %pred_mv_y1, i16 signext %pred_mv_x2, i16 signext %pred_mv_y2, i16* %mv_x, i16* %mv_y, i16* %s_mv_x, i16* %s_mv_y, i32 %search_range, i32 %min_mcost, i32 %lambda_factor) {
cond_next143: ; preds = %entry cond_next143: ; preds = %entry
store i16 0, i16* @img_width, align 2 store i16 0, i16* @img_width, align 2
br i1 false, label %cond_next449, label %cond_false434 br i1 false, label %cond_next449, label %cond_false434
Show All 14 Lines

llvm/test/Transforms/GVN/2008-07-02-Unreachable.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
; PR2503 ; PR2503
@g_3 = external global i8 ; <i8*> [#uses=2] @g_3 = external global i8 ; <i8*> [#uses=2]
define i8 @func_1(i32 %x, i32 %y) nounwind { define i8 @func_1(i32 %x, i32 %y) nounwind {
entry: entry:
%A = alloca i8 %A = alloca i8
%cmp = icmp eq i32 %x, %y %cmp = icmp eq i32 %x, %y
Show All 27 Lines

llvm/test/Transforms/GVN/2010-03-31-RedundantPHIs.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK-NOT: phi ; CHECK-NOT: phi
define i8* @cat(i8* %s1, ...) nounwind { define i8* @cat(i8* %s1, ...) nounwind {
entry: entry:
br i1 undef, label %bb, label %bb3 br i1 undef, label %bb, label %bb3
Show All 33 Lines

llvm/test/Transforms/GVN/2010-11-13-Simplify.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
declare i32 @foo(i32) readnone declare i32 @foo(i32) readnone
define i1 @bar() { define i1 @bar() {
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
%a = call i32 @foo (i32 0) readnone %a = call i32 @foo (i32 0) readnone
%b = call i32 @foo (i32 0) readnone %b = call i32 @foo (i32 0) readnone
%c = and i32 %a, %b %c = and i32 %a, %b
%x = call i32 @foo (i32 %a) readnone %x = call i32 @foo (i32 %a) readnone
%y = call i32 @foo (i32 %c) readnone %y = call i32 @foo (i32 %c) readnone
%z = icmp eq i32 %x, %y %z = icmp eq i32 %x, %y
ret i1 %z ret i1 %z
; CHECK: ret i1 true ; CHECK: ret i1 true
} }

llvm/test/Transforms/GVN/2011-09-07-TypeIdFor.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
%struct.__fundamental_type_info_pseudo = type { %struct.__type_info_pseudo } %struct.__fundamental_type_info_pseudo = type { %struct.__type_info_pseudo }
%struct.__type_info_pseudo = type { i8*, i8* } %struct.__type_info_pseudo = type { i8*, i8* }
@_ZTIi = external constant %struct.__fundamental_type_info_pseudo @_ZTIi = external constant %struct.__fundamental_type_info_pseudo
@_ZTIb = external constant %struct.__fundamental_type_info_pseudo @_ZTIb = external constant %struct.__fundamental_type_info_pseudo
declare void @_Z4barv() declare void @_Z4barv()
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/2016-08-30-MaskedScatterGather.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> ) declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> )
declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>) declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>)
; This test ensures that masked scatter and gather operations, which take vectors of pointers, ; This test ensures that masked scatter and gather operations, which take vectors of pointers,
; do not have pointer aliasing ignored when being processed. ; do not have pointer aliasing ignored when being processed.
; No scatter/gather calls should end up eliminated ; No scatter/gather calls should end up eliminated
; CHECK: llvm.masked.gather ; CHECK: llvm.masked.gather
Show All 33 Lines

llvm/test/Transforms/GVN/MemdepMiscompile.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; rdar://12801584 ; rdar://12801584
; Value of %shouldExit can be changed by RunInMode. ; Value of %shouldExit can be changed by RunInMode.
; Make sure we do not replace load %shouldExit in while.cond.backedge ; Make sure we do not replace load %shouldExit in while.cond.backedge
; with a phi node where the value from while.body is 0. ; with a phi node where the value from while.body is 0.
define i32 @test() nounwind ssp { define i32 @test() nounwind ssp {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/2011-06-01-NonLocalMemdepMiscompile.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
; This test is checking that (a) this doesn't crash, and (b) we don't ; This test is checking that (a) this doesn't crash, and (b) we don't
; conclude the value of %tmp17 is available in bb1.bb15_crit_edge. ; conclude the value of %tmp17 is available in bb1.bb15_crit_edge.
; rdar://9429882 ; rdar://9429882
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
define i1 @rb_intern(i8 *%foo) nounwind ssp { define i1 @rb_intern(i8 *%foo) nounwind ssp {
; CHECK-LABEL: @rb_intern( ; CHECK-LABEL: @rb_intern(
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/atomic.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
@x = common global i32 0, align 4 @x = common global i32 0, align 4
@y = common global i32 0, align 4 @y = common global i32 0, align 4
; GVN across unordered store (allowed) ; GVN across unordered store (allowed)
▲ Show 20 Lines • Show All 494 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/invariant-load.ll

; Test if the !invariant.load metadata is maintained by GVN. ; Test if the !invariant.load metadata is maintained by GVN.
; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
define i32 @test1(i32* nocapture %p, i8* nocapture %q) { define i32 @test1(i32* nocapture %p, i8* nocapture %q) {
; CHECK-LABEL: test1 ; CHECK-LABEL: test1
; CHECK: %x = load i32, i32* %p, align 4, !invariant.load !0 ; CHECK: %x = load i32, i32* %p, align 4, !invariant.load !0
; CHECK-NOT: %y = load ; CHECK-NOT: %y = load
entry: entry:
%x = load i32, i32* %p, align 4, !invariant.load !0 %x = load i32, i32* %p, align 4, !invariant.load !0
%conv = trunc i32 %x to i8 %conv = trunc i32 %x to i8
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/load-pre-licm.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
target triple = "i386-apple-darwin11.0.0" target triple = "i386-apple-darwin11.0.0"
@sortlist = external global [5001 x i32], align 4 @sortlist = external global [5001 x i32], align 4
define void @Bubble() nounwind noinline { define void @Bubble() nounwind noinline {
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: %tmp7.pre = load i32 ; CHECK-NEXT: %tmp7.pre = load i32
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/load-pre-nonlocal.ll

; RUN: opt -S -o - -basicaa -domtree -gvn %s | FileCheck %s ; RUN: opt -S -o - -basic-aa -domtree -gvn %s | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
%struct.S1 = type { i32, i32 } %struct.S1 = type { i32, i32 }
@a2 = common global i32* null, align 8 @a2 = common global i32* null, align 8
@a = common global i32* null, align 8 @a = common global i32* null, align 8
@s1 = common global %struct.S1 zeroinitializer, align 8 @s1 = common global %struct.S1 zeroinitializer, align 8
▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/lpre-call-wrap-2.ll

; RUN: opt -S -basicaa -gvn -enable-load-pre < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn -enable-load-pre < %s | FileCheck %s
; ;
; The partially redundant load in bb1 should be hoisted to "bb". This comes ; The partially redundant load in bb1 should be hoisted to "bb". This comes
; from this C code (GCC PR 23455): ; from this C code (GCC PR 23455):
; unsigned outcnt; extern void flush_outbuf(void); ; unsigned outcnt; extern void flush_outbuf(void);
; void bi_windup(unsigned char *outbuf, unsigned char bi_buf) { ; void bi_windup(unsigned char *outbuf, unsigned char bi_buf) {
; outbuf[outcnt] = bi_buf; ; outbuf[outcnt] = bi_buf;
; if (outcnt == 16384) ; if (outcnt == 16384)
; flush_outbuf(); ; flush_outbuf();
Show All 31 Lines

llvm/test/Transforms/GVN/PRE/phi-translate.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: entry.end_crit_edge: ; CHECK: entry.end_crit_edge:
; CHECK: %[[INDEX:[a-z0-9.]+]] = sext i32 %x to i64{{.*}} !dbg [[ZERO_LOC:![0-9]+]] ; CHECK: %[[INDEX:[a-z0-9.]+]] = sext i32 %x to i64{{.*}} !dbg [[ZERO_LOC:![0-9]+]]
; CHECK: %[[ADDRESS:[a-z0-9.]+]] = getelementptr [100 x i32], [100 x i32]* @G, i64 0, i64 %[[INDEX]]{{.*}} !dbg [[ZERO_LOC]] ; CHECK: %[[ADDRESS:[a-z0-9.]+]] = getelementptr [100 x i32], [100 x i32]* @G, i64 0, i64 %[[INDEX]]{{.*}} !dbg [[ZERO_LOC]]
; CHECK: %n.pre = load i32, i32* %[[ADDRESS]], align 4, !dbg [[N_LOC:![0-9]+]] ; CHECK: %n.pre = load i32, i32* %[[ADDRESS]], align 4, !dbg [[N_LOC:![0-9]+]]
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-gep-load.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -enable-load-pre -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=gvn -enable-load-pre -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s
target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
define double @foo(i32 %stat, i32 %i, double** %p) { define double @foo(i32 %stat, i32 %i, double** %p) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-load-guards.ll

; RUN: opt < %s -basicaa -gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -enable-load-pre -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
declare void @llvm.experimental.guard(i1, ...) declare void @llvm.experimental.guard(i1, ...)
; This is a motivating example on why we prohibit hoisting through guards. ; This is a motivating example on why we prohibit hoisting through guards.
; In the bottom block, we check that the index is within bounds and only access ; In the bottom block, we check that the index is within bounds and only access
; the element in this case and deoptimize otherwise. If we hoist the load to a ; the element in this case and deoptimize otherwise. If we hoist the load to a
; place above the guard, it will may lead to out-of-bound array access. ; place above the guard, it will may lead to out-of-bound array access.
▲ Show 20 Lines • Show All 137 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/pre-load-in-loop.ll

; RUN: opt < %s -basicaa -gvn -enable-load-in-loop-pre=false -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -enable-load-in-loop-pre=false -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
;void test1(int N, double *G) { ;void test1(int N, double *G) {
; int j; ; int j;
; for (j = 0; j < N - 1; j++) ; for (j = 0; j < N - 1; j++)
; G[j] = G[j] + G[j+1]; ; G[j] = G[j] + G[j+1];
;} ;}
Show All 36 Lines

llvm/test/Transforms/GVN/PRE/pre-load.ll

; RUN: opt < %s -basicaa -gvn -enable-load-pre -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -enable-load-pre -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes="gvn<load-pre>" -enable-load-pre=false -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
define i32 @test1(i32* %p, i1 %C) { define i32 @test1(i32* %p, i1 %C) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
block1: block1:
br i1 %C, label %block2, label %block3 br i1 %C, label %block2, label %block3
▲ Show 20 Lines • Show All 582 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/preserve-tbaa.ll

; RUN: opt -tbaa -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -tbaa -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; GVN should preserve the TBAA tag on loads when doing PRE. ; GVN should preserve the TBAA tag on loads when doing PRE.
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK: %tmp33.pre = load i16, i16* %P, align 2, !tbaa !0 ; CHECK: %tmp33.pre = load i16, i16* %P, align 2, !tbaa !0
; CHECK: br label %for.body ; CHECK: br label %for.body
Show All 22 Lines

llvm/test/Transforms/GVN/PRE/rle-addrspace-cast.ll

; RUN: opt < %s -data-layout="e-p:32:32:32-p1:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basicaa -gvn -S -die | FileCheck %s ; RUN: opt < %s -data-layout="e-p:32:32:32-p1:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -S -die | FileCheck %s
define i8 @coerce_offset0_addrspacecast(i32 %V, i32* %P) { define i8 @coerce_offset0_addrspacecast(i32 %V, i32* %P) {
store i32 %V, i32* %P store i32 %V, i32* %P
%P2 = addrspacecast i32* %P to i8 addrspace(1)* %P2 = addrspacecast i32* %P to i8 addrspace(1)*
%P3 = getelementptr i8, i8 addrspace(1)* %P2, i32 2 %P3 = getelementptr i8, i8 addrspace(1)* %P2, i32 2
%A = load i8, i8 addrspace(1)* %P3 %A = load i8, i8 addrspace(1)* %P3
ret i8 %A ret i8 %A
; CHECK-LABEL: @coerce_offset0_addrspacecast( ; CHECK-LABEL: @coerce_offset0_addrspacecast(
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: ret i8 ; CHECK: ret i8
} }

llvm/test/Transforms/GVN/PRE/rle-semidominated.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
define i32 @main(i32* %p, i32 %x, i32 %y) { define i32 @main(i32* %p, i32 %x, i32 %y) {
block1: block1:
%z = load i32, i32* %p %z = load i32, i32* %p
%cmp = icmp eq i32 %x, %y %cmp = icmp eq i32 %x, %y
br i1 %cmp, label %block2, label %block3 br i1 %cmp, label %block2, label %block3
block2: block2:
Show All 27 Lines

llvm/test/Transforms/GVN/PRE/rle.ll

; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basicaa -gvn -S -die | FileCheck %s ; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -gvn -S -die | FileCheck %s
; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basicaa -gvn -S -die | FileCheck %s ; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basic-aa -gvn -S -die | FileCheck %s
;; Trivial RLE test. ;; Trivial RLE test.
define i32 @test0(i32 %V, i32* %P) { define i32 @test0(i32 %V, i32* %P) {
store i32 %V, i32* %P store i32 %V, i32* %P
%A = load i32, i32* %P %A = load i32, i32* %P
ret i32 %A ret i32 %A
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
▲ Show 20 Lines • Show All 809 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/PRE/volatile.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Tests that check our handling of volatile instructions encountered ; Tests that check our handling of volatile instructions encountered
; when scanning for dependencies ; when scanning for dependencies
; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
; Check that we can bypass a volatile load when searching ; Check that we can bypass a volatile load when searching
; for dependencies of a non-volatile load ; for dependencies of a non-volatile load
define i32 @test1(i32* nocapture %p, i32* nocapture %q) { define i32 @test1(i32* nocapture %p, i32* nocapture %q) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP0:%.*]] = load volatile i32, i32* [[Q:%.*]] ; CHECK-NEXT: [[TMP0:%.*]] = load volatile i32, i32* [[Q:%.*]]
; CHECK-NEXT: ret i32 0 ; CHECK-NEXT: ret i32 0
▲ Show 20 Lines • Show All 205 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/basic-undef-test.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
; ModuleID = 'test3.ll' ; ModuleID = 'test3.ll'
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define i32 @main(i32 *%foo) { define i32 @main(i32 *%foo) {
entry: entry:
; CHECK: load i32, i32* %foo, align 4 ; CHECK: load i32, i32* %foo, align 4
%0 = load i32, i32* %foo, align 4 %0 = load i32, i32* %foo, align 4
store i32 5, i32* undef, align 4 store i32 5, i32* undef, align 4
; CHECK-NOT: load i32, i32* %foo, align 4 ; CHECK-NOT: load i32, i32* %foo, align 4
%1 = load i32, i32* %foo, align 4 %1 = load i32, i32* %foo, align 4
; CHECK: add i32 %0, %0 ; CHECK: add i32 %0, %0
%2 = add i32 %0, %1 %2 = add i32 %0, %1
ret i32 %2 ret i32 %2
} }

llvm/test/Transforms/GVN/calloc-load-removal.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
; RUN: opt -S -basicaa -gvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS ; RUN: opt -S -basic-aa -gvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
; Check that loads from calloc are recognized as being zero. ; Check that loads from calloc are recognized as being zero.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @test1() { define i32 @test1() {
%1 = tail call noalias i8* @calloc(i64 1, i64 4) %1 = tail call noalias i8* @calloc(i64 1, i64 4)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
Show All 15 Lines

llvm/test/Transforms/GVN/calls-nonlocal.ll

; Two occurrences of strlen should be zapped. ; Two occurrences of strlen should be zapped.
; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9" target triple = "i386-apple-darwin9"
define i32 @test(i32 %g, i8* %P) nounwind { define i32 @test(i32 %g, i8* %P) nounwind {
entry: entry:
%tmp2 = call i32 @strlen( i8* %P ) nounwind readonly ; <i32> [#uses=1] %tmp2 = call i32 @strlen( i8* %P ) nounwind readonly ; <i32> [#uses=1]
%tmp3 = icmp eq i32 %tmp2, 100 ; <i1> [#uses=1] %tmp3 = icmp eq i32 %tmp2, 100 ; <i1> [#uses=1]
%tmp34 = zext i1 %tmp3 to i8 ; <i8> [#uses=1] %tmp34 = zext i1 %tmp3 to i8 ; <i8> [#uses=1]
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/calls-readonly.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
; Should delete the second call to strlen even though the intervening strchr call exists. ; Should delete the second call to strlen even though the intervening strchr call exists.
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8* @test(i8* %P, i8* %Q, i32 %x, i32 %y) nounwind readonly { define i8* @test(i8* %P, i8* %Q, i32 %x, i32 %y) nounwind readonly {
entry: entry:
%0 = tail call i32 @strlen(i8* %P) ; <i32> [#uses=2] %0 = tail call i32 @strlen(i8* %P) ; <i32> [#uses=2]
Show All 36 Lines

llvm/test/Transforms/GVN/cond_br.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
@y = external global i32 @y = external global i32
@z = external global i32 @z = external global i32
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @foo(i32 %x) { define void @foo(i32 %x) {
; CHECK: @foo(i32 %x) ; CHECK: @foo(i32 %x)
; CHECK: %.pre = load i32, i32* @y ; CHECK: %.pre = load i32, i32* @y
; CHECK: call void @bar(i32 %.pre) ; CHECK: call void @bar(i32 %.pre)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/cond_br2.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
%"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] } %"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] }
%"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" } %"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" }
%"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" } %"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" }
%"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" } %"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" }
%"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" } %"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" }
%"union.llvm::SmallVectorBase::U" = type { x86_fp80 } %"union.llvm::SmallVectorBase::U" = type { x86_fp80 }
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/condprop.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
@a = external global i32 ; <i32*> [#uses=7] @a = external global i32 ; <i32*> [#uses=7]
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
define i32 @test1() nounwind { define i32 @test1() nounwind {
entry: entry:
%0 = load i32, i32* @a, align 4 %0 = load i32, i32* @a, align 4
%1 = icmp eq i32 %0, 4 %1 = icmp eq i32 %0, 4
▲ Show 20 Lines • Show All 362 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/fence.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
@a = external constant i32 @a = external constant i32
; We can value forward across the fence since we can (semantically) ; We can value forward across the fence since we can (semantically)
; reorder the following load before the fence. ; reorder the following load before the fence.
define i32 @test(i32* %addr.i) { define i32 @test(i32* %addr.i) {
; CHECK-LABEL: @test ; CHECK-LABEL: @test
; CHECK: store ; CHECK: store
; CHECK: fence ; CHECK: fence
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/funclet.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc" target triple = "i686-pc-windows-msvc"
%eh.ThrowInfo = type { i32, i8*, i8*, i8* } %eh.ThrowInfo = type { i32, i8*, i8*, i8* }
%struct.A = type { i32* } %struct.A = type { i32* }
@"_TI1?AUA@@" = external constant %eh.ThrowInfo @"_TI1?AUA@@" = external constant %eh.ThrowInfo
Show All 35 Lines

llvm/test/Transforms/GVN/lifetime-simple.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8 @test(i8* %P) nounwind { define i8 @test(i8* %P) nounwind {
; CHECK: lifetime.start ; CHECK: lifetime.start
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: lifetime.end ; CHECK: lifetime.end
Show All 11 Lines

llvm/test/Transforms/GVN/load-constant-mem.ll

; RUN: opt < %s -basicaa -gvn -instcombine -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -instcombine -S | FileCheck %s
; PR4189 ; PR4189
@G = external constant [4 x i32] @G = external constant [4 x i32]
define i32 @test(i8* %p, i32 %i) nounwind { define i32 @test(i8* %p, i32 %i) nounwind {
entry: entry:
%P = getelementptr [4 x i32], [4 x i32]* @G, i32 0, i32 %i %P = getelementptr [4 x i32], [4 x i32]* @G, i32 0, i32 %i
%A = load i32, i32* %P %A = load i32, i32* %P
store i8 4, i8* %p store i8 4, i8* %p
Show All 10 Lines

llvm/test/Transforms/GVN/malloc-load-removal.ll

; RUN: opt -S -basicaa -gvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -gvn < %s | FileCheck %s
; RUN: opt -S -basicaa -gvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS ; RUN: opt -S -basic-aa -gvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
; PR13694 ; PR13694
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
declare i8* @malloc(i64) nounwind declare i8* @malloc(i64) nounwind
define noalias i8* @test1() nounwind uwtable ssp { define noalias i8* @test1() nounwind uwtable ssp {
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/noalias.ll

; RUN: opt -scoped-noalias -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -scoped-noalias -basic-aa -gvn -S < %s | FileCheck %s
define i32 @test1(i32* %p, i32* %q) { define i32 @test1(i32* %p, i32* %q) {
; CHECK-LABEL: @test1(i32* %p, i32* %q) ; CHECK-LABEL: @test1(i32* %p, i32* %q)
; CHECK: load i32, i32* %p ; CHECK: load i32, i32* %p
; CHECK-NOT: noalias ; CHECK-NOT: noalias
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = load i32, i32* %p, !noalias !0 %a = load i32, i32* %p, !noalias !0
%b = load i32, i32* %p %b = load i32, i32* %p
Show All 34 Lines

llvm/test/Transforms/GVN/non-local-offset.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; GVN should ignore the store to p[1] to see that the load from p[0] is ; GVN should ignore the store to p[1] to see that the load from p[0] is
; fully redundant. ; fully redundant.
; CHECK-LABEL: @yes( ; CHECK-LABEL: @yes(
; CHECK: if.then: ; CHECK: if.then:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/nonescaping-malloc.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basicaa -gvn -stats -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -stats -disable-output 2>&1 | FileCheck %s
; rdar://7363102 ; rdar://7363102
; CHECK: Number of loads deleted ; CHECK: Number of loads deleted
; GVN should be able to eliminate load %tmp22.i, because it is redundant with ; GVN should be able to eliminate load %tmp22.i, because it is redundant with
; load %tmp8.i. This requires being able to prove that %tmp7.i doesn't ; load %tmp8.i. This requires being able to prove that %tmp7.i doesn't
; alias the malloc'd value %tmp.i20.i.i, which it can do since %tmp7.i ; alias the malloc'd value %tmp.i20.i.i, which it can do since %tmp7.i
; is derived from %tmp5.i which is computed from a load, and %tmp.i20.i.i ; is derived from %tmp5.i which is computed from a load, and %tmp.i20.i.i
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/null-aliases-nothing.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
%t = type { i32 } %t = type { i32 }
declare void @test1f(i8*) declare void @test1f(i8*)
define void @test1(%t* noalias %stuff ) { define void @test1(%t* noalias %stuff ) {
%p = getelementptr inbounds %t, %t* %stuff, i32 0, i32 0 %p = getelementptr inbounds %t, %t* %stuff, i32 0, i32 0
%before = load i32, i32* %p %before = load i32, i32* %p
Show All 11 Lines

llvm/test/Transforms/GVN/phi-translate-partial-alias.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64"
; GVN shouldn't PRE the load around the loop backedge because it's ; GVN shouldn't PRE the load around the loop backedge because it's
; not actually redundant around the loop backedge, despite appearances ; not actually redundant around the loop backedge, despite appearances
; if phi-translation is ignored. ; if phi-translation is ignored.
; CHECK: define void @test0(i8* %begin) ; CHECK: define void @test0(i8* %begin)
Show All 18 Lines

llvm/test/Transforms/GVN/pr10820.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
target datalayout = target datalayout =
"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64" "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@g = external global i31 @g = external global i31
define void @main() nounwind uwtable { define void @main() nounwind uwtable {
Show All 9 Lines

llvm/test/Transforms/GVN/pr17852.ll

; RUN: opt < %s -basicaa -gvn ; RUN: opt < %s -basic-aa -gvn
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
%struct.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 } %struct.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 }
define void @fn1(%struct.S0* byval align 8 %p1) { define void @fn1(%struct.S0* byval align 8 %p1) {
br label %for.cond br label %for.cond
for.cond: ; preds = %1, %0 for.cond: ; preds = %1, %0
br label %for.end br label %for.end
%f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2 %f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2
%f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7 %f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/pr24397.ll

; RUN: opt -basicaa -gvn -disable-output < %s ; RUN: opt -basic-aa -gvn -disable-output < %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i64 @foo(i64** %arrayidx) { define i64 @foo(i64** %arrayidx) {
entry: entry:
%p = load i64*, i64** %arrayidx, align 8 %p = load i64*, i64** %arrayidx, align 8
%cmpnull = icmp eq i64* %p, null %cmpnull = icmp eq i64* %p, null
br label %BB2 br label %BB2
Show All 9 Lines

llvm/test/Transforms/GVN/pre-new-inst.ll

; RUN: opt -basicaa -gvn -S %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S %s | FileCheck %s
%MyStruct = type { i32, i32 } %MyStruct = type { i32, i32 }
define i8 @foo(i64 %in, i8* %arr) { define i8 @foo(i64 %in, i8* %arr) {
%addr = alloca %MyStruct %addr = alloca %MyStruct
%dead = trunc i64 %in to i32 %dead = trunc i64 %in to i32
br i1 undef, label %next, label %tmp br i1 undef, label %next, label %tmp
tmp: tmp:
Show All 20 Lines

llvm/test/Transforms/GVN/range.ll

; RUN: opt -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -gvn -S < %s | FileCheck %s
define i32 @test1(i32* %p) { define i32 @test1(i32* %p) {
; CHECK-LABEL: @test1(i32* %p) ; CHECK-LABEL: @test1(i32* %p)
; CHECK: %a = load i32, i32* %p, align 4, !range ![[RANGE0:[0-9]+]] ; CHECK: %a = load i32, i32* %p, align 4, !range ![[RANGE0:[0-9]+]]
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = load i32, i32* %p, !range !0 %a = load i32, i32* %p, !range !0
%b = load i32, i32* %p, !range !0 %b = load i32, i32* %p, !range !0
%c = add i32 %a, %b %c = add i32 %a, %b
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/rle-must-alias.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
; GVN should eliminate the fully redundant %9 GEP which ; GVN should eliminate the fully redundant %9 GEP which
; allows DEAD to be removed. This is PR3198. ; allows DEAD to be removed. This is PR3198.
; The %7 and %4 loads combine to make %DEAD unneeded. ; The %7 and %4 loads combine to make %DEAD unneeded.
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
@H = common global [100 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=3] @H = common global [100 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=3]
Show All 38 Lines

llvm/test/Transforms/GVN/rle-nonlocal.ll

; RUN: opt < %s -basicaa -gvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -gvn -S | FileCheck %s
define i32 @main(i32** %p, i32 %x, i32 %y) { define i32 @main(i32** %p, i32 %x, i32 %y) {
block1: block1:
%cmp = icmp eq i32 %x, %y %cmp = icmp eq i32 %x, %y
br i1 %cmp , label %block2, label %block3 br i1 %cmp , label %block2, label %block3
block2: block2:
%a = load i32*, i32** %p %a = load i32*, i32** %p
Show All 16 Lines

llvm/test/Transforms/GVN/tbaa.ll

; RUN: opt -tbaa -basicaa -gvn -S < %s | FileCheck %s ; RUN: opt -tbaa -basic-aa -gvn -S < %s | FileCheck %s
define i32 @test1(i8* %p, i8* %q) { define i32 @test1(i8* %p, i8* %q) {
; CHECK-LABEL: @test1(i8* %p, i8* %q) ; CHECK-LABEL: @test1(i8* %p, i8* %q)
; CHECK: call i32 @foo(i8* %p) ; CHECK: call i32 @foo(i8* %p)
; CHECK-NOT: tbaa ; CHECK-NOT: tbaa
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = call i32 @foo(i8* %p), !tbaa !0 %a = call i32 @foo(i8* %p), !tbaa !0
%b = call i32 @foo(i8* %p) %b = call i32 @foo(i8* %p)
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/Transforms/GVN/vscale.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -S < %s -basicaa -gvn -dce | FileCheck %s ; RUN: opt -S < %s -basic-aa -gvn -dce | FileCheck %s
; Analyze Load from clobbering Load. ; Analyze Load from clobbering Load.
define <vscale x 4 x i32> @load_store_clobber_load(<vscale x 4 x i32> *%p) { define <vscale x 4 x i32> @load_store_clobber_load(<vscale x 4 x i32> *%p) {
; CHECK-LABEL: @load_store_clobber_load( ; CHECK-LABEL: @load_store_clobber_load(
; CHECK-NEXT: [[LOAD1:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[P:%.*]], align 16 ; CHECK-NEXT: [[LOAD1:%.*]] = load <vscale x 4 x i32>, <vscale x 4 x i32>* [[P:%.*]], align 16
; CHECK-NEXT: store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* undef, align 16 ; CHECK-NEXT: store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* undef, align 16
; CHECK-NEXT: [[ADD:%.*]] = add <vscale x 4 x i32> [[LOAD1]], [[LOAD1]] ; CHECK-NEXT: [[ADD:%.*]] = add <vscale x 4 x i32> [[LOAD1]], [[LOAD1]]
▲ Show 20 Lines • Show All 334 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/2007-07-25-InfiniteLoop.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
%struct.INT2 = type { i32, i32 } %struct.INT2 = type { i32, i32 }
@blkshifts = external global %struct.INT2* ; <%struct.INT2**> [#uses=2] @blkshifts = external global %struct.INT2* ; <%struct.INT2**> [#uses=2]
define i32 @xcompact() { define i32 @xcompact() {
entry: entry:
store %struct.INT2* null, %struct.INT2** @blkshifts, align 4 store %struct.INT2* null, %struct.INT2** @blkshifts, align 4
br label %bb br label %bb
bb: ; preds = %bb, %entry bb: ; preds = %bb, %entry
%tmp10 = load %struct.INT2*, %struct.INT2** @blkshifts, align 4 ; <%struct.INT2*> [#uses=0] %tmp10 = load %struct.INT2*, %struct.INT2** @blkshifts, align 4 ; <%struct.INT2*> [#uses=0]
; CHECK-NOT: %tmp10 ; CHECK-NOT: %tmp10
br label %bb br label %bb
} }

llvm/test/Transforms/NewGVN/2007-07-26-InterlockingLoops.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
@last = external global [65 x i32*] @last = external global [65 x i32*]
define i32 @NextRootMove(i32 %wtm, i32 %x, i32 %y, i32 %z) { define i32 @NextRootMove(i32 %wtm, i32 %x, i32 %y, i32 %z) {
entry: entry:
%A = alloca i32* %A = alloca i32*
%tmp17618 = load i32*, i32** getelementptr ([65 x i32*], [65 x i32*]* @last, i32 0, i32 1), align 4 %tmp17618 = load i32*, i32** getelementptr ([65 x i32*], [65 x i32*]* @last, i32 0, i32 1), align 4
store i32* %tmp17618, i32** %A store i32* %tmp17618, i32** %A
Show All 31 Lines

llvm/test/Transforms/NewGVN/2007-07-31-NoDomInherit.ll

; XFAIL: * ; XFAIL: *
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
%struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* } %struct.anon = type { i32 (i32, i32, i32)*, i32, i32, [3 x i32], i8*, i8*, i8* }
@debug = external constant i32 ; <i32*> [#uses=0] @debug = external constant i32 ; <i32*> [#uses=0]
@counters = external constant i32 ; <i32*> [#uses=1] @counters = external constant i32 ; <i32*> [#uses=1]
@trialx = external global [17 x i32] ; <[17 x i32]*> [#uses=1] @trialx = external global [17 x i32] ; <[17 x i32]*> [#uses=1]
@dummy1 = external global [7 x i32] ; <[7 x i32]*> [#uses=0] @dummy1 = external global [7 x i32] ; <[7 x i32]*> [#uses=0]
@dummy2 = external global [4 x i32] ; <[4 x i32]*> [#uses=0] @dummy2 = external global [4 x i32] ; <[4 x i32]*> [#uses=0]
@unacceptable = external global i32 ; <i32*> [#uses=0] @unacceptable = external global i32 ; <i32*> [#uses=0]
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/2007-07-31-RedundantPhi.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
@img_width = external global i16 ; <i16*> [#uses=2] @img_width = external global i16 ; <i16*> [#uses=2]
define i32 @smpUMHEXBipredIntegerPelBlockMotionSearch(i16* %cur_pic, i16 signext %ref, i32 %list, i32 %pic_pix_x, i32 %pic_pix_y, i32 %blocktype, i16 signext %pred_mv_x1, i16 signext %pred_mv_y1, i16 signext %pred_mv_x2, i16 signext %pred_mv_y2, i16* %mv_x, i16* %mv_y, i16* %s_mv_x, i16* %s_mv_y, i32 %search_range, i32 %min_mcost, i32 %lambda_factor) { define i32 @smpUMHEXBipredIntegerPelBlockMotionSearch(i16* %cur_pic, i16 signext %ref, i32 %list, i32 %pic_pix_x, i32 %pic_pix_y, i32 %blocktype, i16 signext %pred_mv_x1, i16 signext %pred_mv_y1, i16 signext %pred_mv_x2, i16 signext %pred_mv_y2, i16* %mv_x, i16* %mv_y, i16* %s_mv_x, i16* %s_mv_y, i32 %search_range, i32 %min_mcost, i32 %lambda_factor) {
cond_next143: ; preds = %entry cond_next143: ; preds = %entry
store i16 0, i16* @img_width, align 2 store i16 0, i16* @img_width, align 2
br i1 false, label %cond_next449, label %cond_false434 br i1 false, label %cond_next449, label %cond_false434
Show All 14 Lines

llvm/test/Transforms/NewGVN/2008-07-02-Unreachable.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
; PR2503 ; PR2503
@g_3 = external global i8 ; <i8*> [#uses=2] @g_3 = external global i8 ; <i8*> [#uses=2]
define i8 @func_1(i32 %x, i32 %y) nounwind { define i8 @func_1(i32 %x, i32 %y) nounwind {
entry: entry:
%A = alloca i8 %A = alloca i8
%cmp = icmp eq i32 %x, %y %cmp = icmp eq i32 %x, %y
Show All 27 Lines

llvm/test/Transforms/NewGVN/2010-03-31-RedundantPHIs.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK-NOT: phi ; CHECK-NOT: phi
define i8* @cat(i8* %s1, ...) nounwind { define i8* @cat(i8* %s1, ...) nounwind {
entry: entry:
br i1 undef, label %bb, label %bb3 br i1 undef, label %bb, label %bb3
Show All 33 Lines

llvm/test/Transforms/NewGVN/2010-11-13-Simplify.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
declare i32 @foo(i32) readnone declare i32 @foo(i32) readnone
define i1 @bar() { define i1 @bar() {
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
%a = call i32 @foo (i32 0) readnone %a = call i32 @foo (i32 0) readnone
%b = call i32 @foo (i32 0) readnone %b = call i32 @foo (i32 0) readnone
%c = and i32 %a, %b %c = and i32 %a, %b
%x = call i32 @foo (i32 %a) readnone %x = call i32 @foo (i32 %a) readnone
%y = call i32 @foo (i32 %c) readnone %y = call i32 @foo (i32 %c) readnone
%z = icmp eq i32 %x, %y %z = icmp eq i32 %x, %y
ret i1 %z ret i1 %z
; CHECK: ret i1 true ; CHECK: ret i1 true
} }

llvm/test/Transforms/NewGVN/2011-09-07-TypeIdFor.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
%struct.__fundamental_type_info_pseudo = type { %struct.__type_info_pseudo } %struct.__fundamental_type_info_pseudo = type { %struct.__type_info_pseudo }
%struct.__type_info_pseudo = type { i8*, i8* } %struct.__type_info_pseudo = type { i8*, i8* }
@_ZTIi = external constant %struct.__fundamental_type_info_pseudo @_ZTIi = external constant %struct.__fundamental_type_info_pseudo
@_ZTIb = external constant %struct.__fundamental_type_info_pseudo @_ZTIb = external constant %struct.__fundamental_type_info_pseudo
declare void @_Z4barv() declare void @_Z4barv()
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/2016-08-30-MaskedScatterGather.ll

; XFAIL: * ; XFAIL: *
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> ) declare void @llvm.masked.scatter.v2i32.v2p0i32(<2 x i32> , <2 x i32*> , i32 , <2 x i1> )
declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>) declare <2 x i32> @llvm.masked.gather.v2i32.v2p0i32(<2 x i32*>, i32, <2 x i1>, <2 x i32>)
; This test ensures that masked scatter and gather operations, which take vectors of pointers, ; This test ensures that masked scatter and gather operations, which take vectors of pointers,
; do not have pointer aliasing ignored when being processed. ; do not have pointer aliasing ignored when being processed.
; No scatter/gather calls should end up eliminated ; No scatter/gather calls should end up eliminated
; CHECK: llvm.masked.gather ; CHECK: llvm.masked.gather
Show All 33 Lines

llvm/test/Transforms/NewGVN/MemdepMiscompile.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
; rdar://12801584 ; rdar://12801584
; Value of %shouldExit can be changed by RunInMode. ; Value of %shouldExit can be changed by RunInMode.
; Make sure we do not replace load %shouldExit in while.cond.backedge ; Make sure we do not replace load %shouldExit in while.cond.backedge
; with a phi node where the value from while.body is 0. ; with a phi node where the value from while.body is 0.
define i32 @test() nounwind ssp { define i32 @test() nounwind ssp {
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/basic-cyclic-opt.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
;; Function Attrs: nounwind ssp uwtable ;; Function Attrs: nounwind ssp uwtable
;; We should eliminate the sub, and one of the phi nodes ;; We should eliminate the sub, and one of the phi nodes
define void @vnum_test1(i32* %data) #0 { define void @vnum_test1(i32* %data) #0 {
; CHECK-LABEL: @vnum_test1( ; CHECK-LABEL: @vnum_test1(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[TMP:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 3 ; CHECK-NEXT: [[TMP:%.*]] = getelementptr inbounds i32, i32* [[DATA:%.*]], i64 3
▲ Show 20 Lines • Show All 305 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/basic-undef-test.ll

; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
; ModuleID = 'test3.ll' ; ModuleID = 'test3.ll'
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define i32 @main(i32 *%foo) { define i32 @main(i32 *%foo) {
entry: entry:
; CHECK: load i32, i32* %foo, align 4 ; CHECK: load i32, i32* %foo, align 4
%0 = load i32, i32* %foo, align 4 %0 = load i32, i32* %foo, align 4
store i32 5, i32* undef, align 4 store i32 5, i32* undef, align 4
; CHECK-NOT: load i32, i32* %foo, align 4 ; CHECK-NOT: load i32, i32* %foo, align 4
%1 = load i32, i32* %foo, align 4 %1 = load i32, i32* %foo, align 4
; CHECK: add i32 %0, %0 ; CHECK: add i32 %0, %0
%2 = add i32 %0, %1 %2 = add i32 %0, %1
ret i32 %2 ret i32 %2
} }

llvm/test/Transforms/NewGVN/calloc-load-removal.ll

; RUN: opt -S -basicaa -newgvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -newgvn < %s | FileCheck %s
; RUN: opt -S -basicaa -newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS ; RUN: opt -S -basic-aa -newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
; Check that loads from calloc are recognized as being zero. ; Check that loads from calloc are recognized as being zero.
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define i32 @test1() { define i32 @test1() {
%1 = tail call noalias i8* @calloc(i64 1, i64 4) %1 = tail call noalias i8* @calloc(i64 1, i64 4)
%2 = bitcast i8* %1 to i32* %2 = bitcast i8* %1 to i32*
Show All 15 Lines

llvm/test/Transforms/NewGVN/calls-nonlocal.ll

; XFAIL: * ; XFAIL: *
;; NewGVN zaps the strlens, but currently takes two iterations to evaluate the conditions, because ;; NewGVN zaps the strlens, but currently takes two iterations to evaluate the conditions, because
;; we prune predicateinfo, and the icmps only become equivalent after the strlens are zapped ;; we prune predicateinfo, and the icmps only become equivalent after the strlens are zapped
; Two occurrences of strlen should be zapped. ; Two occurrences of strlen should be zapped.
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin9" target triple = "i386-apple-darwin9"
define i32 @test(i32 %g, i8* %P) nounwind { define i32 @test(i32 %g, i8* %P) nounwind {
entry: entry:
%tmp2 = call i32 @strlen( i8* %P ) nounwind readonly ; <i32> [#uses=1] %tmp2 = call i32 @strlen( i8* %P ) nounwind readonly ; <i32> [#uses=1]
%tmp3 = icmp eq i32 %tmp2, 100 ; <i1> [#uses=1] %tmp3 = icmp eq i32 %tmp2, 100 ; <i1> [#uses=1]
%tmp34 = zext i1 %tmp3 to i8 ; <i8> [#uses=1] %tmp34 = zext i1 %tmp3 to i8 ; <i8> [#uses=1]
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/calls-readonly.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
; Should delete the second call to strlen even though the intervening strchr call exists. ; Should delete the second call to strlen even though the intervening strchr call exists.
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8* @test(i8* %P, i8* %Q, i32 %x, i32 %y) nounwind readonly { define i8* @test(i8* %P, i8* %Q, i32 %x, i32 %y) nounwind readonly {
entry: entry:
%0 = tail call i32 @strlen(i8* %P) ; <i32> [#uses=2] %0 = tail call i32 @strlen(i8* %P) ; <i32> [#uses=2]
Show All 36 Lines

llvm/test/Transforms/NewGVN/completeness.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -enable-phi-of-ops=true -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -enable-phi-of-ops=true -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define i32 @test1(i32, i8**) { define i32 @test1(i32, i8**) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: [[TMP3:%.*]] = icmp ne i32 [[TMP0:%.*]], 0 ; CHECK-NEXT: [[TMP3:%.*]] = icmp ne i32 [[TMP0:%.*]], 0
; CHECK-NEXT: br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP5:%.*]] ; CHECK-NEXT: br i1 [[TMP3]], label [[TMP4:%.*]], label [[TMP5:%.*]]
; CHECK: br label [[TMP6:%.*]] ; CHECK: br label [[TMP6:%.*]]
; CHECK: br label [[TMP6]] ; CHECK: br label [[TMP6]]
▲ Show 20 Lines • Show All 595 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/cond_br.ll

; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
@y = external global i32 @y = external global i32
@z = external global i32 @z = external global i32
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
define void @foo(i32 %x) { define void @foo(i32 %x) {
; CHECK: @foo(i32 %x) ; CHECK: @foo(i32 %x)
; CHECK: %.pre = load i32, i32* @y ; CHECK: %.pre = load i32, i32* @y
; CHECK: call void @bar(i32 %.pre) ; CHECK: call void @bar(i32 %.pre)
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/cond_br2.ll

; XFAIL: * ; XFAIL: *
; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
%"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] } %"class.llvm::SmallVector" = type { %"class.llvm::SmallVectorImpl", [1 x %"union.llvm::SmallVectorBase::U"] }
%"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" } %"class.llvm::SmallVectorImpl" = type { %"class.llvm::SmallVectorTemplateBase" }
%"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" } %"class.llvm::SmallVectorTemplateBase" = type { %"class.llvm::SmallVectorTemplateCommon" }
%"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" } %"class.llvm::SmallVectorTemplateCommon" = type { %"class.llvm::SmallVectorBase" }
%"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" } %"class.llvm::SmallVectorBase" = type { i8*, i8*, i8*, %"union.llvm::SmallVectorBase::U" }
%"union.llvm::SmallVectorBase::U" = type { x86_fp80 } %"union.llvm::SmallVectorBase::U" = type { x86_fp80 }
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/condprop-xfail.ll

; XFAIL: * ; XFAIL: *
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
@a = external global i32 ; <i32*> [#uses=7] @a = external global i32 ; <i32*> [#uses=7]
;; NewGVN takes two passes to get this, because we prune predicateinfo ;; NewGVN takes two passes to get this, because we prune predicateinfo
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
define i32 @test1() nounwind { define i32 @test1() nounwind {
entry: entry:
%0 = load i32, i32* @a, align 4 %0 = load i32, i32* @a, align 4
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/condprop.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
declare void @foo(i1) declare void @foo(i1)
declare void @bar(i32) declare void @bar(i32)
define void @test3(i32 %x, i32 %y) { define void @test3(i32 %x, i32 %y) {
; CHECK-LABEL: @test3( ; CHECK-LABEL: @test3(
; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0 ; CHECK-NEXT: [[XZ:%.*]] = icmp eq i32 [[X:%.*]], 0
▲ Show 20 Lines • Show All 242 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/cyclic-phi-handling.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define void @foo(i32 %arg, i32 %arg1, i32 (i32, i32)* %arg2) { define void @foo(i32 %arg, i32 %arg1, i32 (i32, i32)* %arg2) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: br label %bb3 ; CHECK-NEXT: br label %bb3
; CHECK: bb3: ; CHECK: bb3:
; CHECK-NEXT: [[TMP:%.*]] = phi i32 [ %arg1, %bb ], [ [[TMP:%.*]]4, %bb7 ] ; CHECK-NEXT: [[TMP:%.*]] = phi i32 [ %arg1, %bb ], [ [[TMP:%.*]]4, %bb7 ]
Show All 27 Lines

llvm/test/Transforms/NewGVN/deadstore.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
;; Most of these are borrowed from transforms/DSE/simple.ll ;; Most of these are borrowed from transforms/DSE/simple.ll
;; NewGVN should be able to eliminate any stores of the same value that are actually redundnat. ;; NewGVN should be able to eliminate any stores of the same value that are actually redundnat.
;; tmp5 is store of the same value to the same location as the load. ;; tmp5 is store of the same value to the same location as the load.
define void @test12({ i32, i32 }* %x) nounwind { define void @test12({ i32, i32 }* %x) nounwind {
; CHECK-LABEL: @test12( ; CHECK-LABEL: @test12(
; CHECK-NEXT: [[TMP4:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[X:%.*]], i32 0, i32 0 ; CHECK-NEXT: [[TMP4:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[X:%.*]], i32 0, i32 0
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/equivalent-phi.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
@global = common global [1024 x i32] zeroinitializer, align 16 @global = common global [1024 x i32] zeroinitializer, align 16
;; We should be able to prove the equivalence of two of the phis, and then use that to eliminate ;; We should be able to prove the equivalence of two of the phis, and then use that to eliminate
;; one set of indexing calculations and a load ;; one set of indexing calculations and a load
; Function Attrs: nounwind ssp uwtable ; Function Attrs: nounwind ssp uwtable
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/fence.ll

; XFAIL: * ; XFAIL: *
; RUN: opt -S -basicaa -newgvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -newgvn < %s | FileCheck %s
@a = external constant i32 @a = external constant i32
; We can value forward across the fence since we can (semantically) ; We can value forward across the fence since we can (semantically)
; reorder the following load before the fence. ; reorder the following load before the fence.
define i32 @test(i32* %addr.i) { define i32 @test(i32* %addr.i) {
; CHECK-LABEL: @test ; CHECK-LABEL: @test
; CHECK: store ; CHECK: store
; CHECK: fence ; CHECK: fence
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/funclet.ll

; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32" target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
target triple = "i686-pc-windows-msvc" target triple = "i686-pc-windows-msvc"
%eh.ThrowInfo = type { i32, i8*, i8*, i8* } %eh.ThrowInfo = type { i32, i8*, i8*, i8* }
%struct.A = type { i32* } %struct.A = type { i32* }
@"_TI1?AUA@@" = external constant %eh.ThrowInfo @"_TI1?AUA@@" = external constant %eh.ThrowInfo
Show All 35 Lines

llvm/test/Transforms/NewGVN/lifetime-simple.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
define i8 @test(i8* %P) nounwind { define i8 @test(i8* %P) nounwind {
; CHECK: lifetime.start ; CHECK: lifetime.start
; CHECK-NOT: load ; CHECK-NOT: load
; CHECK: lifetime.end ; CHECK: lifetime.end
Show All 11 Lines

llvm/test/Transforms/NewGVN/load-constant-mem.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
; PR4189 ; PR4189
@G = external constant [4 x i32] @G = external constant [4 x i32]
define i32 @test(i8* %p, i32 %i) nounwind { define i32 @test(i8* %p, i32 %i) nounwind {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[P:%.*]] = getelementptr [4 x i32], [4 x i32]* @G, i32 0, i32 [[I:%.*]] ; CHECK-NEXT: [[P:%.*]] = getelementptr [4 x i32], [4 x i32]* @G, i32 0, i32 [[I:%.*]]
; CHECK-NEXT: store i8 4, i8* [[P:%.*]] ; CHECK-NEXT: store i8 4, i8* [[P:%.*]]
Show All 11 Lines

llvm/test/Transforms/NewGVN/loadforward.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%rec11 = type { i16, i16, i16 } %rec11 = type { i16, i16, i16 }
@str = global %rec11 { i16 1, i16 2, i16 3 } @str = global %rec11 { i16 1, i16 2, i16 3 }
;; Test that we forward the first store to the second load ;; Test that we forward the first store to the second load
define i16 @bazinga() { define i16 @bazinga() {
Show All 22 Lines

llvm/test/Transforms/NewGVN/malloc-load-removal.ll

; RUN: opt -S -basicaa -newgvn < %s | FileCheck %s ; RUN: opt -S -basic-aa -newgvn < %s | FileCheck %s
; RUN: opt -S -basicaa -newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS ; RUN: opt -S -basic-aa -newgvn -disable-simplify-libcalls < %s | FileCheck %s -check-prefix=CHECK_NO_LIBCALLS
; PR13694 ; PR13694
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.8.0" target triple = "x86_64-apple-macosx10.8.0"
declare i8* @malloc(i64) nounwind declare i8* @malloc(i64) nounwind
define noalias i8* @test1() nounwind uwtable ssp { define noalias i8* @test1() nounwind uwtable ssp {
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/memory-handling.ll

;; This test is really dependent on propagating a lot of memory info around, but in the end, not ;; This test is really dependent on propagating a lot of memory info around, but in the end, not
;; screwing up a single add. ;; screwing up a single add.
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
%struct.Letter = type { i32, i32, i32, i32 } %struct.Letter = type { i32, i32, i32, i32 }
@alPhrase = external local_unnamed_addr global [26 x %struct.Letter], align 16 @alPhrase = external local_unnamed_addr global [26 x %struct.Letter], align 16
@aqMainMask = external local_unnamed_addr global [2 x i64], align 16 @aqMainMask = external local_unnamed_addr global [2 x i64], align 16
@aqMainSign = external local_unnamed_addr global [2 x i64], align 16 @aqMainSign = external local_unnamed_addr global [2 x i64], align 16
@cchPhraseLength = external local_unnamed_addr global i32, align 4 @cchPhraseLength = external local_unnamed_addr global i32, align 4
▲ Show 20 Lines • Show All 184 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/noalias.ll

; RUN: opt -scoped-noalias -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -scoped-noalias -basic-aa -newgvn -S < %s | FileCheck %s
define i32 @test1(i32* %p, i32* %q) { define i32 @test1(i32* %p, i32* %q) {
; CHECK-LABEL: @test1(i32* %p, i32* %q) ; CHECK-LABEL: @test1(i32* %p, i32* %q)
; CHECK: load i32, i32* %p ; CHECK: load i32, i32* %p
; CHECK-NOT: noalias ; CHECK-NOT: noalias
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = load i32, i32* %p, !noalias !0 %a = load i32, i32* %p, !noalias !0
%b = load i32, i32* %p %b = load i32, i32* %p
Show All 34 Lines

llvm/test/Transforms/NewGVN/non-local-offset.ll

; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64" target datalayout = "e-p:64:64:64"
; GVN should ignore the store to p[1] to see that the load from p[0] is ; GVN should ignore the store to p[1] to see that the load from p[0] is
; fully redundant. ; fully redundant.
; CHECK-LABEL: @yes( ; CHECK-LABEL: @yes(
; CHECK: if.then: ; CHECK: if.then:
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/nonescaping-malloc.ll

; XFAIL: * ; XFAIL: *
; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -basicaa -newgvn -stats -disable-output 2>&1 | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -stats -disable-output 2>&1 | FileCheck %s
; rdar://7363102 ; rdar://7363102
; CHECK: Number of loads deleted ; CHECK: Number of loads deleted
; GVN should be able to eliminate load %tmp22.i, because it is redundant with ; GVN should be able to eliminate load %tmp22.i, because it is redundant with
; load %tmp8.i. This requires being able to prove that %tmp7.i doesn't ; load %tmp8.i. This requires being able to prove that %tmp7.i doesn't
; alias the malloc'd value %tmp.i20.i.i, which it can do since %tmp7.i ; alias the malloc'd value %tmp.i20.i.i, which it can do since %tmp7.i
; is derived from %tmp5.i which is computed from a load, and %tmp.i20.i.i ; is derived from %tmp5.i which is computed from a load, and %tmp.i20.i.i
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/null-aliases-nothing.ll

; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
%t = type { i32 } %t = type { i32 }
declare void @test1f(i8*) declare void @test1f(i8*)
define void @test1(%t* noalias %stuff ) { define void @test1(%t* noalias %stuff ) {
%p = getelementptr inbounds %t, %t* %stuff, i32 0, i32 0 %p = getelementptr inbounds %t, %t* %stuff, i32 0, i32 0
%before = load i32, i32* %p %before = load i32, i32* %p
Show All 11 Lines

llvm/test/Transforms/NewGVN/phi-translate-partial-alias.ll

; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64"
; GVN shouldn't PRE the load around the loop backedge because it's ; GVN shouldn't PRE the load around the loop backedge because it's
; not actually redundant around the loop backedge, despite appearances ; not actually redundant around the loop backedge, despite appearances
; if phi-translation is ignored. ; if phi-translation is ignored.
; CHECK: define void @test0(i8* %begin) ; CHECK: define void @test0(i8* %begin)
Show All 18 Lines

llvm/test/Transforms/NewGVN/pr10820.ll

; XFAIL: * ; XFAIL: *
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
; NewGVN fails this due to missing load coercion ; NewGVN fails this due to missing load coercion
target datalayout = target datalayout =
"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64" "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@g = external global i31 @g = external global i31
define void @main() nounwind uwtable { define void @main() nounwind uwtable {
Show All 9 Lines

llvm/test/Transforms/NewGVN/pr14166.ll

; XFAIL: * ; XFAIL: *
; RUN: opt -disable-basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -disable-basic-aa -newgvn -S < %s | FileCheck %s
; NewGVN fails this due to missing load coercion ; NewGVN fails this due to missing load coercion
target datalayout = "e-p:32:32:32" target datalayout = "e-p:32:32:32"
target triple = "i386-pc-linux-gnu" target triple = "i386-pc-linux-gnu"
define <2 x i32> @test1() { define <2 x i32> @test1() {
%v1 = alloca <2 x i32> %v1 = alloca <2 x i32>
call void @anything(<2 x i32>* %v1) call void @anything(<2 x i32>* %v1)
%v2 = load <2 x i32>, <2 x i32>* %v1 %v2 = load <2 x i32>, <2 x i32>* %v1
%v3 = inttoptr <2 x i32> %v2 to <2 x i8*> %v3 = inttoptr <2 x i32> %v2 to <2 x i8*>
Show All 16 Lines

llvm/test/Transforms/NewGVN/pr17852.ll

; RUN: opt < %s -basicaa -newgvn ; RUN: opt < %s -basic-aa -newgvn
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
%struct.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 } %struct.S0 = type { [2 x i8], [2 x i8], [4 x i8], [2 x i8], i32, i32, i32, i32 }
define void @fn1(%struct.S0* byval align 8 %p1) { define void @fn1(%struct.S0* byval align 8 %p1) {
br label %for.cond br label %for.cond
for.cond: ; preds = %1, %0 for.cond: ; preds = %1, %0
br label %for.end br label %for.end
%f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2 %f2 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 2
%f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7 %f9 = getelementptr inbounds %struct.S0, %struct.S0* %p1, i64 0, i32 7
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/pr24397.ll

; RUN: opt -basicaa -newgvn -disable-output < %s ; RUN: opt -basic-aa -newgvn -disable-output < %s
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define i64 @foo(i64** %arrayidx) { define i64 @foo(i64** %arrayidx) {
entry: entry:
%p = load i64*, i64** %arrayidx, align 8 %p = load i64*, i64** %arrayidx, align 8
%cmpnull = icmp eq i64* %p, null %cmpnull = icmp eq i64* %p, null
br label %BB2 br label %BB2
Show All 9 Lines

llvm/test/Transforms/NewGVN/pr31472.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.12.0" target triple = "x86_64-apple-macosx10.12.0"
;; Ensure the invoke does not accidentally get deleted as unused, just because the value is not used. ;; Ensure the invoke does not accidentally get deleted as unused, just because the value is not used.
; Function Attrs: norecurse ssp uwtable ; Function Attrs: norecurse ssp uwtable
define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*){ define i32 @main() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*){
; CHECK-LABEL: @main( ; CHECK-LABEL: @main(
Show All 24 Lines

llvm/test/Transforms/NewGVN/pr31483.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
@global = external hidden unnamed_addr constant [11 x i8], align 1 @global = external hidden unnamed_addr constant [11 x i8], align 1
;; Ensure we do not believe the indexing increments are unreachable due to incorrect memory ;; Ensure we do not believe the indexing increments are unreachable due to incorrect memory
;; equivalence detection. In PR31483, we were deleting those blocks as unreachable ;; equivalence detection. In PR31483, we were deleting those blocks as unreachable
; Function Attrs: nounwind ; Function Attrs: nounwind
define signext i32 @ham(i8* %arg, i8* %arg1) #0 { define signext i32 @ham(i8* %arg, i8* %arg1) #0 {
; CHECK-LABEL: @ham( ; CHECK-LABEL: @ham(
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/pr31491.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
;; Test that we do not infinite loop on this testcase, and that we do not try ;; Test that we do not infinite loop on this testcase, and that we do not try
;; to replace the phi node argument with the result of the phi node. ;; to replace the phi node argument with the result of the phi node.
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define internal i32 @pr31491() { define internal i32 @pr31491() {
; CHECK-LABEL: @pr31491( ; CHECK-LABEL: @pr31491(
; CHECK-NEXT: bb5: ; CHECK-NEXT: bb5:
; CHECK-NEXT: br label %bb7 ; CHECK-NEXT: br label %bb7
Show All 20 Lines

llvm/test/Transforms/NewGVN/pr31501.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
%struct.foo = type { %struct.wombat.28*, %struct.zot, %struct.wombat.28* } %struct.foo = type { %struct.wombat.28*, %struct.zot, %struct.wombat.28* }
%struct.zot = type { i64 } %struct.zot = type { i64 }
%struct.barney = type <{ %struct.wombat.28*, %struct.wibble, %struct.snork, %struct.quux.4, %struct.snork.10, %struct.ham.16*, %struct.wobble.23*, i32, i8, i8, [2 x i8] }> %struct.barney = type <{ %struct.wombat.28*, %struct.wibble, %struct.snork, %struct.quux.4, %struct.snork.10, %struct.ham.16*, %struct.wobble.23*, i32, i8, i8, [2 x i8] }>
%struct.wibble = type { %struct.pluto, %struct.bar } %struct.wibble = type { %struct.pluto, %struct.bar }
%struct.pluto = type { %struct.quux } %struct.pluto = type { %struct.quux }
%struct.quux = type { %struct.eggs } %struct.quux = type { %struct.eggs }
▲ Show 20 Lines • Show All 126 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/pr31573.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define void @patatino(i8* %blah) { define void @patatino(i8* %blah) {
; CHECK-LABEL: @patatino( ; CHECK-LABEL: @patatino(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[WHILE_COND:%.*]] ; CHECK-NEXT: br label [[WHILE_COND:%.*]]
; CHECK: while.cond: ; CHECK: while.cond:
Show All 32 Lines

llvm/test/Transforms/NewGVN/pr31594.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
define i1 @patatino(i8* %blah, i32 %choice) { define i1 @patatino(i8* %blah, i32 %choice) {
; CHECK-LABEL: @patatino( ; CHECK-LABEL: @patatino(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[WHILE_COND:%.*]] ; CHECK-NEXT: br label [[WHILE_COND:%.*]]
; CHECK: while.cond: ; CHECK: while.cond:
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/pr31613.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -enable-store-refinement -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -enable-store-refinement -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
;; Both of these tests are tests of phi nodes that end up all equivalent to each other ;; Both of these tests are tests of phi nodes that end up all equivalent to each other
;; Without proper leader ordering, we will end up cycling the leader between all of them and never converge. ;; Without proper leader ordering, we will end up cycling the leader between all of them and never converge.
define void @foo() { define void @foo() {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/pr31682.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
%struct.foo = type { i32, i32, [2 x [4 x [6 x [6 x i16]]]] } %struct.foo = type { i32, i32, [2 x [4 x [6 x [6 x i16]]]] }
@global = external global %struct.foo* @global = external global %struct.foo*
define void @bar() { define void @bar() {
; CHECK-LABEL: @bar( ; CHECK-LABEL: @bar(
Show All 31 Lines

llvm/test/Transforms/NewGVN/pre-new-inst.ll

; XFAIL: * ; XFAIL: *
; RUN: opt -basicaa -newgvn -S %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S %s | FileCheck %s
%MyStruct = type { i32, i32 } %MyStruct = type { i32, i32 }
define i8 @foo(i64 %in, i8* %arr) { define i8 @foo(i64 %in, i8* %arr) {
%addr = alloca %MyStruct %addr = alloca %MyStruct
%dead = trunc i64 %in to i32 %dead = trunc i64 %in to i32
br i1 undef, label %next, label %tmp br i1 undef, label %next, label %tmp
tmp: tmp:
Show All 20 Lines

llvm/test/Transforms/NewGVN/predicates.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
; Function Attrs: noinline norecurse nounwind readonly ssp uwtable ; Function Attrs: noinline norecurse nounwind readonly ssp uwtable
define i32 @mp_unsgn_cmp(i32 %n, i32* nocapture readonly %in1, i32* nocapture readonly %in2) local_unnamed_addr { define i32 @mp_unsgn_cmp(i32 %n, i32* nocapture readonly %in1, i32* nocapture readonly %in2) local_unnamed_addr {
; CHECK-LABEL: @mp_unsgn_cmp( ; CHECK-LABEL: @mp_unsgn_cmp(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP11:%.*]] = icmp sgt i32 [[N:%.*]], -1 ; CHECK-NEXT: [[CMP11:%.*]] = icmp sgt i32 [[N:%.*]], -1
; CHECK-NEXT: br i1 [[CMP11]], label [[FOR_INC_PREHEADER:%.*]], label [[IF_ELSE:%.*]] ; CHECK-NEXT: br i1 [[CMP11]], label [[FOR_INC_PREHEADER:%.*]], label [[IF_ELSE:%.*]]
; CHECK: for.inc.preheader: ; CHECK: for.inc.preheader:
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/range.ll

; RUN: opt -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -basic-aa -newgvn -S < %s | FileCheck %s
define i32 @test1(i32* %p) { define i32 @test1(i32* %p) {
; CHECK-LABEL: @test1(i32* %p) ; CHECK-LABEL: @test1(i32* %p)
; CHECK: %a = load i32, i32* %p, align 4, !range ![[RANGE0:[0-9]+]] ; CHECK: %a = load i32, i32* %p, align 4, !range ![[RANGE0:[0-9]+]]
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = load i32, i32* %p, !range !0 %a = load i32, i32* %p, !range !0
%b = load i32, i32* %p, !range !0 %b = load i32, i32* %p, !range !0
%c = add i32 %a, %b %c = add i32 %a, %b
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/refine-stores.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
;; Now that we do store refinement, we have to verify that we add fake uses ;; Now that we do store refinement, we have to verify that we add fake uses
;; when we skip existing stores. ;; when we skip existing stores.
;; We also are testing that various variations that cause stores to move classes ;; We also are testing that various variations that cause stores to move classes
;; have the right class movement happen ;; have the right class movement happen
;; All of these tests result in verification failures if it does not. ;; All of these tests result in verification failures if it does not.
source_filename = "bugpoint-output-daef094.bc" source_filename = "bugpoint-output-daef094.bc"
target triple = "x86_64-apple-darwin16.5.0" target triple = "x86_64-apple-darwin16.5.0"
▲ Show 20 Lines • Show All 177 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/rle-must-alias.ll

; XFAIL: * ; XFAIL: *
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
; GVN should eliminate the fully redundant %9 GEP which ; GVN should eliminate the fully redundant %9 GEP which
; allows DEAD to be removed. This is PR3198. ; allows DEAD to be removed. This is PR3198.
; The %7 and %4 loads combine to make %DEAD unneeded. ; The %7 and %4 loads combine to make %DEAD unneeded.
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
target triple = "i386-apple-darwin7" target triple = "i386-apple-darwin7"
@H = common global [100 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=3] @H = common global [100 x i32] zeroinitializer, align 32 ; <[100 x i32]*> [#uses=3]
Show All 38 Lines

llvm/test/Transforms/NewGVN/rle-nonlocal.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -basicaa -newgvn -S | FileCheck %s ; RUN: opt < %s -basic-aa -newgvn -S | FileCheck %s
define i32 @main(i32** %p, i32 %x, i32 %y) { define i32 @main(i32** %p, i32 %x, i32 %y) {
; CHECK-LABEL: @main( ; CHECK-LABEL: @main(
; CHECK-NEXT: block1: ; CHECK-NEXT: block1:
; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]] ; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
; CHECK-NEXT: br i1 [[CMP]], label [[BLOCK2:%.*]], label [[BLOCK3:%.*]] ; CHECK-NEXT: br i1 [[CMP]], label [[BLOCK2:%.*]], label [[BLOCK3:%.*]]
; CHECK: block2: ; CHECK: block2:
; CHECK-NEXT: [[A:%.*]] = load i32*, i32** [[P:%.*]] ; CHECK-NEXT: [[A:%.*]] = load i32*, i32** [[P:%.*]]
Show All 30 Lines

llvm/test/Transforms/NewGVN/rle.ll

; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basicaa -newgvn -S -die | FileCheck %s ; RUN: opt < %s -data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basic-aa -newgvn -S -die | FileCheck %s
; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basicaa -newgvn -S -die | FileCheck %s ; RUN: opt < %s -data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basic-aa -newgvn -S -die | FileCheck %s
; memset -> i16 forwarding. ; memset -> i16 forwarding.
define signext i16 @memset_to_i16_local(i16* %A) nounwind ssp { define signext i16 @memset_to_i16_local(i16* %A) nounwind ssp {
entry: entry:
%conv = bitcast i16* %A to i8* %conv = bitcast i16* %A to i8*
tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i1 false) tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i1 false)
%arrayidx = getelementptr inbounds i16, i16* %A, i64 42 %arrayidx = getelementptr inbounds i16, i16* %A, i64 42
%tmp2 = load i16, i16* %arrayidx %tmp2 = load i16, i16* %arrayidx
ret i16 %tmp2 ret i16 %tmp2
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/Transforms/NewGVN/tbaa.ll

; RUN: opt -tbaa -basicaa -newgvn -S < %s | FileCheck %s ; RUN: opt -tbaa -basic-aa -newgvn -S < %s | FileCheck %s
define i32 @test1(i8* %p, i8* %q) { define i32 @test1(i8* %p, i8* %q) {
; CHECK-LABEL: @test1(i8* %p, i8* %q) ; CHECK-LABEL: @test1(i8* %p, i8* %q)
; CHECK: call i32 @foo(i8* %p) ; CHECK: call i32 @foo(i8* %p)
; CHECK-NOT: tbaa ; CHECK-NOT: tbaa
; CHECK: %c = add i32 %a, %a ; CHECK: %c = add i32 %a, %a
%a = call i32 @foo(i8* %p), !tbaa !0 %a = call i32 @foo(i8* %p), !tbaa !0
%b = call i32 @foo(i8* %p) %b = call i32 @foo(i8* %p)
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines