This is an archive of the discontinued LLVM Phabricator instance.

Differential D118339

[test] Use -passes syntax in SROA test cases
ClosedPublic

Authored by bjope on Jan 27 2022, 2:51 AM.

Details

Reviewers
aeubanks
Commits
rGbf06bc1a6d6e: [test] Use -passes syntax in SROA test cases
Summary

Another step to move away from the legacy PM syntax when specifying
passes in opt.

Diff Detail

Event Timeline

bjope created this revision.Jan 27 2022, 2:51 AM
Herald added subscribers: kbarton, nemanjai. · View Herald TranscriptJan 27 2022, 2:51 AM
bjope requested review of this revision.Jan 27 2022, 2:51 AM
Herald added a project: Restricted Project. · View Herald TranscriptJan 27 2022, 2:51 AM
aeubanks accepted this revision.Jan 27 2022, 8:34 AM
This revision is now accepted and ready to land.Jan 27 2022, 8:34 AM
Harbormaster completed remote builds in B145960: Diff 403561.Jan 27 2022, 9:50 AM
This revision was landed with ongoing or failed builds.Jan 27 2022, 10:26 AM
Closed by commit rGbf06bc1a6d6e: [test] Use -passes syntax in SROA test cases (authored by bjope). · Explain Why
This revision was automatically updated to reflect the committed changes.
bjope added a commit: rGbf06bc1a6d6e: [test] Use -passes syntax in SROA test cases.

Revision Contents

Diff 403725

llvm/test/Transforms/SROA/2009-02-20-InstCombine-SROA.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; rdar://6417724 ; rdar://6417724
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.6" target triple = "i386-apple-darwin9.6"
%"struct.std::vector<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >" } %"struct.std::vector<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >" }
%"struct.std::_Vector_base<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >::_Vector_impl" } %"struct.std::_Vector_base<int,std::allocator<int> >" = type { %"struct.std::_Vector_base<int,std::allocator<int> >::_Vector_impl" }
▲ Show 20 Lines • Show All 262 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/address-spaces.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-p1:16:16:16-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture readonly, i32, i1)
declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture readonly, i32, i1) declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture, i8* nocapture readonly, i32, i1)
declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1) declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1) declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/addrspacecast.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 -sroa -S | FileCheck %s
; RUN: opt < %s -passes=sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-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-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-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-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture writeonly, i8 addrspace(1)* nocapture readonly, i32, i1 immarg) #0 declare void @llvm.memcpy.p0i8.p1i8.i32(i8* nocapture writeonly, i8 addrspace(1)* nocapture readonly, i32, i1 immarg) #0
declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture writeonly, i8* nocapture readonly, i32, i1 immarg) #0 declare void @llvm.memcpy.p1i8.p0i8.i32(i8 addrspace(1)* nocapture writeonly, i8* nocapture readonly, i32, i1 immarg) #0
define i64 @alloca_addrspacecast_bitcast(i64 %X) { define i64 @alloca_addrspacecast_bitcast(i64 %X) {
▲ Show 20 Lines • Show All 329 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/alignment.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; RUN: opt -debugify -sroa -S < %s | FileCheck %s -check-prefix DEBUGLOC ; RUN: opt -passes='debugify,function(sroa)' -S < %s | FileCheck %s -check-prefix DEBUGLOC
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1)
define void @test1({ i8, i8 }* %a, { i8, i8 }* %b) { define void @test1({ i8, i8 }* %a, { i8, i8 }* %b) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: %[[gep_a0:.*]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %a, i64 0, i32 0 ; CHECK: %[[gep_a0:.*]] = getelementptr inbounds { i8, i8 }, { i8, i8 }* %a, i64 0, i32 0
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/alloca-address-space.ll

; RUN: opt < %s -sroa -S | FileCheck %s
; RUN: opt < %s -passes=sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-p1:16:16:16-p2:32:32-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64-A2" target datalayout = "e-p:64:64:64-p1:16:16:16-p2:32:32-p3:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64-A2"
declare void @llvm.memcpy.p2i8.p2i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1) declare void @llvm.memcpy.p2i8.p2i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1)
declare void @llvm.memcpy.p1i8.p2i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1) declare void @llvm.memcpy.p1i8.p2i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(2)* nocapture readonly, i32, i1)
declare void @llvm.memcpy.p2i8.p1i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1) declare void @llvm.memcpy.p2i8.p1i8.i32(i8 addrspace(2)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1) declare void @llvm.memcpy.p1i8.p1i8.i32(i8 addrspace(1)* nocapture, i8 addrspace(1)* nocapture readonly, i32, i1)
▲ Show 20 Lines • Show All 133 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/alloca-struct.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 -sroa -S | FileCheck %s
; RUN: opt < %s -passes=sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.RetValIntChar = type { i32, i8 } %struct.RetValIntChar = type { i32, i8 }
%struct.RetValTwoInts = type { i32, i32 } %struct.RetValTwoInts = type { i32, i32 }
%struct.RetValOneIntTwoChar = type { i32, i8 } %struct.RetValOneIntTwoChar = type { i32, i8 }
▲ Show 20 Lines • Show All 172 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/assume.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
source_filename = "tmp.cpp" source_filename = "tmp.cpp"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.n.2 = type { i8 } %struct.n.2 = type { i8 }
%struct.bi = type { %class.as } %struct.bi = type { %class.as }
%class.as = type { %class.ao } %class.as = type { %class.ao }
Show All 22 Lines

llvm/test/Transforms/SROA/basictest.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 -sroa -S | FileCheck %s
; RUN: opt < %s -passes=sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-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-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-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-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
define i32 @test0() { define i32 @test0() {
▲ Show 20 Lines • Show All 2,253 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/big-endian.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
define i8 @test1() { define i8 @test1() {
; We fully promote these to the i24 load or store size, resulting in just masks ; We fully promote these to the i24 load or store size, resulting in just masks
; and other operations that instcombine will fold, but no alloca. Note this is ; and other operations that instcombine will fold, but no alloca. Note this is
; the same as test12 in basictest.ll, but here we assert big-endian byte ; the same as test12 in basictest.ll, but here we assert big-endian byte
; ordering. ; ordering.
▲ Show 20 Lines • Show All 243 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/dbg-addr-diamond.ll

; RUN: opt -use-dbg-addr -sroa -S < %s | FileCheck %s ; RUN: opt -use-dbg-addr -passes=sroa -S < %s | FileCheck %s
; ModuleID = '<stdin>' ; ModuleID = '<stdin>'
source_filename = "newvars.c" source_filename = "newvars.c"
target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.0.24215" target triple = "x86_64-pc-windows-msvc19.0.24215"
%struct.Pair = type { i32, i32 } %struct.Pair = type { i32, i32 }
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/dbg-inline.ll

; Test that SROA can deal with allocas that have more than one ; Test that SROA can deal with allocas that have more than one
; dbg.declare hanging off of it. ; dbg.declare hanging off of it.
; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
source_filename = "/tmp/inlinesplit.cpp" source_filename = "/tmp/inlinesplit.cpp"
target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.15.0" target triple = "x86_64-apple-macosx10.15.0"
%struct.pair = type { i64, i64 } %struct.pair = type { i64, i64 }
; Function Attrs: noinline optnone ssp uwtable ; Function Attrs: noinline optnone ssp uwtable
define i64 @_Z1g4pair(i64 %p.coerce0, i64 %p.coerce1) #0 !dbg !8 { define i64 @_Z1g4pair(i64 %p.coerce0, i64 %p.coerce1) #0 !dbg !8 {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/dbg-single-piece.ll

; RUN: opt -sroa %s -S | FileCheck %s ; RUN: opt -passes=sroa %s -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"
%foo = type { [8 x i8], [8 x i8] } %foo = type { [8 x i8], [8 x i8] }
declare void @llvm.dbg.declare(metadata, metadata, metadata) #0 declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
define void @_ZL18findInsertLocationPN4llvm17MachineBasicBlockENS_9SlotIndexERNS_13LiveIntervalsE() { define void @_ZL18findInsertLocationPN4llvm17MachineBasicBlockENS_9SlotIndexERNS_13LiveIntervalsE() {
entry: entry:
%retval = alloca %foo, align 8 %retval = alloca %foo, align 8
Show All 28 Lines

llvm/test/Transforms/SROA/fca.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
define { i32, i32 } @test0(i32 %x, i32 %y) { define { i32, i32 } @test0(i32 %x, i32 %y) {
; CHECK-LABEL: @test0( ; CHECK-LABEL: @test0(
; CHECK-NOT: alloca ; CHECK-NOT: alloca
; CHECK: insertvalue { i32, i32 } ; CHECK: insertvalue { i32, i32 }
; CHECK: insertvalue { i32, i32 } ; CHECK: insertvalue { i32, i32 }
; CHECK: ret { i32, i32 } ; CHECK: ret { i32, i32 }
Show All 39 Lines

llvm/test/Transforms/SROA/ignore-droppable.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 -sroa -S -o - < %s | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; RUN: opt -passes=sroa -S -o - < %s | FileCheck %s
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare void @llvm.lifetime.start.p0i8(i64 %size, i8* nocapture %ptr) declare void @llvm.lifetime.start.p0i8(i64 %size, i8* nocapture %ptr)
declare void @llvm.lifetime.end.p0i8(i64 %size, i8* nocapture %ptr) declare void @llvm.lifetime.end.p0i8(i64 %size, i8* nocapture %ptr)
define void @positive_assume_uses(i32* %arg) { define void @positive_assume_uses(i32* %arg) {
; CHECK-LABEL: @positive_assume_uses( ; CHECK-LABEL: @positive_assume_uses(
; CHECK-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(i32* [[ARG:%.*]]), "ignore"(i32* undef, i64 2) ] ; CHECK-NEXT: call void @llvm.assume(i1 true) [ "nonnull"(i32* [[ARG:%.*]]), "ignore"(i32* undef, i64 2) ]
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/irregular-type.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
%S = type { [4 x i8] } %S = type { [4 x i8] }
; Ensure the load/store of integer types whose size is not equal to the store ; Ensure the load/store of integer types whose size is not equal to the store
; size are not split. ; size are not split.
define i8 @foo(i23 %0) { define i8 @foo(i23 %0) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
Show All 38 Lines

llvm/test/Transforms/SROA/mem-par-metadata-sroa-cast.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; ;
; Make sure the llvm.access.group meta-data is preserved ; Make sure the llvm.access.group meta-data is preserved
; when a load/store is replaced with another load/store by sroa ; when a load/store is replaced with another load/store by sroa
; Ensure this is done for casting too. ; Ensure this is done for casting too.
; ;
; CHECK: entry: ; CHECK: entry:
; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT:![0-9]*]] ; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT:![0-9]*]]
; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT]] ; CHECK: load i32, i32* {{.*}}, !llvm.access.group [[DISTINCT]]
Show All 23 Lines

llvm/test/Transforms/SROA/mem-par-metadata-sroa.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; ;
; Make sure the llvm.access.group meta-data is preserved ; Make sure the llvm.access.group meta-data is preserved
; when a load/store is replaced with another load/store by sroa ; when a load/store is replaced with another load/store by sroa
; ;
; class Complex { ; class Complex {
; private: ; private:
; float real_; ; float real_;
; float imaginary_; ; float imaginary_;
▲ Show 20 Lines • Show All 102 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/non-integral-pointers.ll

; RUN: opt -sroa -S < %s | FileCheck %s ; RUN: opt -passes=sroa -S < %s | FileCheck %s
; This test checks that SROA does not introduce ptrtoint and inttoptr ; This test checks that SROA does not introduce ptrtoint and inttoptr
; casts from and to non-integral pointers. The "ni:4" bit in the ; casts from and to non-integral pointers. The "ni:4" bit in the
; datalayout states that pointers of address space 4 are to be ; datalayout states that pointers of address space 4 are to be
; considered "non-integral". ; considered "non-integral".
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:4"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/phi-and-select.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
define i32 @test1() { define i32 @test1() {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[COND:%.*]] = icmp sle i32 0, 1 ; CHECK-NEXT: [[COND:%.*]] = icmp sle i32 0, 1
; CHECK-NEXT: br i1 [[COND]], label [[THEN:%.*]], label [[EXIT:%.*]] ; CHECK-NEXT: br i1 [[COND]], label [[THEN:%.*]], label [[EXIT:%.*]]
; CHECK: then: ; CHECK: then:
▲ Show 20 Lines • Show All 846 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/phi-catchswitch.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
target triple = "wasm32-unknown-unknown" target triple = "wasm32-unknown-unknown"
%struct.foo = type { i32 } %struct.foo = type { i32 }
declare i32 @__gxx_wasm_personality_v0(...) declare i32 @__gxx_wasm_personality_v0(...)
declare void @foo() declare void @foo()
Show All 36 Lines

llvm/test/Transforms/SROA/phi-gep.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 -sroa < %s | FileCheck %s ; RUN: opt -S -passes=sroa < %s | FileCheck %s
%pair = type { i32, i32 } %pair = type { i32, i32 }
define i32 @test_sroa_phi_gep(i1 %cond) { define i32 @test_sroa_phi_gep(i1 %cond) {
; CHECK-LABEL: @test_sroa_phi_gep( ; CHECK-LABEL: @test_sroa_phi_gep(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br i1 [[COND:%.*]], label [[IF_THEN:%.*]], label [[END:%.*]] ; CHECK-NEXT: br i1 [[COND:%.*]], label [[IF_THEN:%.*]], label [[END:%.*]]
; CHECK: if.then: ; CHECK: if.then:
▲ Show 20 Lines • Show All 516 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/phi-with-duplicate-pred.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
@a = external global i16, align 1 @a = external global i16, align 1
declare void @maybe_writes() declare void @maybe_writes()
define void @f2() { define void @f2() {
; CHECK-LABEL: @f2( ; CHECK-LABEL: @f2(
▲ Show 20 Lines • Show All 255 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/pointer-offset-size.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64:32" target datalayout = "e-p:64:64:64:32"
%struct.test = type { %struct.basic, %struct.basic } %struct.test = type { %struct.basic, %struct.basic }
%struct.basic = type { i16, i8 } %struct.basic = type { i16, i8 }
define i16 @test(%struct.test* %ts2.i) { define i16 @test(%struct.test* %ts2.i) {
; CHECK-LABEL: @test( ; CHECK-LABEL: @test(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
Show All 19 Lines

llvm/test/Transforms/SROA/ppcf128-no-fold.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "E-m:e-i64:64-n32:64" target datalayout = "E-m:e-i64:64-n32:64"
target triple = "powerpc64-unknown-linux-gnu" target triple = "powerpc64-unknown-linux-gnu"
%struct.ld2 = type { [2 x ppc_fp128] } %struct.ld2 = type { [2 x ppc_fp128] }
declare void @bar(i8*, [2 x i128]) declare void @bar(i8*, [2 x i128])
define void @foo(i8* %v) #0 { define void @foo(i8* %v) #0 {
entry: entry:
Show All 27 Lines

llvm/test/Transforms/SROA/pr26972.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -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-pc-linux" target triple = "x86_64-pc-linux"
; Make sure we properly handle allocas where the allocated ; Make sure we properly handle allocas where the allocated
; size overflows a uint32_t. This specific constant results in ; size overflows a uint32_t. This specific constant results in
; the size in bits being 32 after truncation to a 32-bit int. ; the size in bits being 32 after truncation to a 32-bit int.
; CHECK-LABEL: fn1 ; CHECK-LABEL: fn1
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
define void @fn1() { define void @fn1() {
%a = alloca [1073741825 x i32], align 16 %a = alloca [1073741825 x i32], align 16
%t0 = bitcast [1073741825 x i32]* %a to i8* %t0 = bitcast [1073741825 x i32]* %a to i8*
call void @llvm.lifetime.end.p0i8(i64 4294967300, i8* %t0) call void @llvm.lifetime.end.p0i8(i64 4294967300, i8* %t0)
ret void ret void
} }
declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)

llvm/test/Transforms/SROA/pr37267.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -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-n32: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-n32:64-S128"
target triple = "sparcv9-sun-solaris" target triple = "sparcv9-sun-solaris"
; PR37267 ; PR37267
; Check that we don't crash on this test. ; Check that we don't crash on this test.
define i16 @f1() { define i16 @f1() {
; CHECK-LABEL: @f1( ; CHECK-LABEL: @f1(
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/preserve-nonnull.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; ;
; Make sure that SROA doesn't lose nonnull metadata ; Make sure that SROA doesn't lose nonnull metadata
; on loads from allocas that get optimized out. ; on loads from allocas that get optimized out.
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
; Check that we do basic propagation of nonnull when rewriting. ; Check that we do basic propagation of nonnull when rewriting.
define i8* @propagate_nonnull(i32* %v) { define i8* @propagate_nonnull(i32* %v) {
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/scalable-vectors.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; RUN: opt < %s -passes=sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
; This test checks that SROA runs mem2reg on scalable vectors. ; This test checks that SROA runs mem2reg on scalable vectors.
define <vscale x 16 x i1> @alloca_nxv16i1(<vscale x 16 x i1> %pg) { define <vscale x 16 x i1> @alloca_nxv16i1(<vscale x 16 x i1> %pg) {
; CHECK-LABEL: @alloca_nxv16i1( ; CHECK-LABEL: @alloca_nxv16i1(
; CHECK-NEXT: ret <vscale x 16 x i1> [[PG:%.*]] ; CHECK-NEXT: ret <vscale x 16 x i1> [[PG:%.*]]
; ;
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/select-gep.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 -sroa < %s | FileCheck %s ; RUN: opt -S -passes=sroa < %s | FileCheck %s
%pair = type { i32, i32 } %pair = type { i32, i32 }
define i32 @test_sroa_select_gep(i1 %cond) { define i32 @test_sroa_select_gep(i1 %cond) {
; CHECK-LABEL: @test_sroa_select_gep( ; CHECK-LABEL: @test_sroa_select_gep(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[LOAD_SROA_SPECULATED:%.*]] = select i1 [[COND:%.*]], i32 1, i32 2 ; CHECK-NEXT: [[LOAD_SROA_SPECULATED:%.*]] = select i1 [[COND:%.*]], i32 1, i32 2
; CHECK-NEXT: ret i32 [[LOAD_SROA_SPECULATED]] ; CHECK-NEXT: ret i32 [[LOAD_SROA_SPECULATED]]
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/select-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 -sroa < %s | FileCheck %s ; RUN: opt -S -passes=sroa < %s | FileCheck %s
%st.half = type { half } %st.half = type { half }
; Allow speculateSelectInstLoads to fold load and select ; Allow speculateSelectInstLoads to fold load and select
; even if there is an intervening bitcast. ; even if there is an intervening bitcast.
define <2 x i16> @test_load_bitcast_select(i1 %cond1, i1 %cond2) { define <2 x i16> @test_load_bitcast_select(i1 %cond1, i1 %cond2) {
; CHECK-LABEL: @test_load_bitcast_select( ; CHECK-LABEL: @test_load_bitcast_select(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/slice-order-independence.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-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-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-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-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
; Check that the chosen type for a split is independent from the order of ; Check that the chosen type for a split is independent from the order of
; slices even in case of types that are skipped because their width is not a ; slices even in case of types that are skipped because their width is not a
; byte width multiple ; byte width multiple
define void @skipped_inttype_first({ i16*, i32 }*) { define void @skipped_inttype_first({ i16*, i32 }*) {
Show All 28 Lines

llvm/test/Transforms/SROA/slice-width.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-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-f80:128-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-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-f80:128-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind
declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind
declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
; This tests that allocas are not split into slices that are not byte width multiple ; This tests that allocas are not split into slices that are not byte width multiple
define void @no_split_on_non_byte_width(i32) { define void @no_split_on_non_byte_width(i32) {
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/std-clamp.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
define float @_Z8stdclampfff(float %x, float %lo, float %hi) { define float @_Z8stdclampfff(float %x, float %lo, float %hi) {
; CHECK-LABEL: @_Z8stdclampfff( ; CHECK-LABEL: @_Z8stdclampfff(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[I4:%.*]] = alloca float, align 4 ; CHECK-NEXT: [[I4:%.*]] = alloca float, align 4
; CHECK-NEXT: store float [[HI:%.*]], float* [[I4]], align 4 ; CHECK-NEXT: store float [[HI:%.*]], float* [[I4]], align 4
Show All 21 Lines

llvm/test/Transforms/SROA/tbaa-struct.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 -sroa %s | FileCheck %s ; RUN: opt -S -passes=sroa %s | FileCheck %s
; SROA should keep `!tbaa.struct` metadata ; SROA should keep `!tbaa.struct` metadata
%vector = type { float, float } %vector = type { float, float }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg)
declare <2 x float> @foo(%vector* %0) declare <2 x float> @foo(%vector* %0)
define void @bar(%vector* %y2) { define void @bar(%vector* %y2) {
Show All 22 Lines

llvm/test/Transforms/SROA/tbaa-struct2.ll

; RUN: opt -S -sroa %s | FileCheck %s ; RUN: opt -S -passes=sroa %s | FileCheck %s
; SROA should correctly offset `!tbaa.struct` metadata ; SROA should correctly offset `!tbaa.struct` metadata
%struct.Wishart = type { double, i32 } %struct.Wishart = type { double, i32 }
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg) declare void @llvm.memcpy.p0i8.p0i8.i64(i8* writeonly, i8* readonly, i64, i1 immarg)
declare double @subcall(double %g, i32 %m) declare double @subcall(double %g, i32 %m)
define double @bar(%struct.Wishart* %wishart) { define double @bar(%struct.Wishart* %wishart) {
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/tbaa-subload.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 -sroa %s | FileCheck %s ; RUN: opt -S -passes=sroa %s | FileCheck %s
; This should not crash ; This should not crash
%class.ar = type { i8 } %class.ar = type { i8 }
%class.anon = type <{ %class.ar, [7 x i8], { i64, i64 } }> %class.anon = type <{ %class.ar, [7 x i8], { i64, i64 } }>
define void @caller() { define void @caller() {
; CHECK-LABEL: @caller( ; CHECK-LABEL: @caller(
Show All 26 Lines

llvm/test/Transforms/SROA/vector-conversion.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
define <4 x i64> @vector_ptrtoint({<2 x i32*>, <2 x i32*>} %x) { define <4 x i64> @vector_ptrtoint({<2 x i32*>, <2 x i32*>} %x) {
; CHECK-LABEL: @vector_ptrtoint ; CHECK-LABEL: @vector_ptrtoint
%a = alloca {<2 x i32*>, <2 x i32*>} %a = alloca {<2 x i32*>, <2 x i32*>}
; CHECK-NOT: alloca ; CHECK-NOT: alloca
store {<2 x i32*>, <2 x i32*>} %x, {<2 x i32*>, <2 x i32*>}* %a store {<2 x i32*>, <2 x i32*>} %x, {<2 x i32*>, <2 x i32*>}* %a
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/Transforms/SROA/vector-lifetime-intrinsic.ll

; RUN: opt -sroa -S < %s | FileCheck %s ; RUN: opt -passes=sroa -S < %s | FileCheck %s
target datalayout = "e-p:64:32-i64:32-v32:32-n32-S64" target datalayout = "e-p:64:32-i64:32-v32:32-n32-S64"
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) #0
; Function Attrs: nounwind ; Function Attrs: nounwind
declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) #0
Show All 22 Lines

llvm/test/Transforms/SROA/vector-promotion-different-size.ll

; RUN: opt < %s -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
define <4 x i1> @vector_bitcast() { define <4 x i1> @vector_bitcast() {
; CHECK-LABEL: @vector_bitcast ; CHECK-LABEL: @vector_bitcast
; CHECK: alloca <3 x i1> ; CHECK: alloca <3 x i1>
%a = alloca <3 x i1> %a = alloca <3 x i1>
store <3 x i1> <i1 1,i1 0,i1 1>, <3 x i1>* %a store <3 x i1> <i1 1,i1 0,i1 1>, <3 x i1>* %a
Show All 15 Lines

llvm/test/Transforms/SROA/vector-promotion.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 -sroa -S | FileCheck %s ; RUN: opt < %s -passes=sroa -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
%S1 = type { i64, [42 x float] } %S1 = type { i64, [42 x float] }
define i32 @test1(<4 x i32> %x, <4 x i32> %y) { define i32 @test1(<4 x i32> %x, <4 x i32> %y) {
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_SROA_0_8_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[X:%.*]], i32 2 ; CHECK-NEXT: [[A_SROA_0_8_VEC_EXTRACT:%.*]] = extractelement <4 x i32> [[X:%.*]], i32 2
▲ Show 20 Lines • Show All 620 Lines • Show Last 20 Lines