This is an archive of the discontinued LLVM Phabricator instance.

Differential D139647

[opt] Disincentivize new tests from using old pass syntax
ClosedPublic

Authored by lebedev.ri on Dec 8 2022, 9:52 AM.

Details

Reviewers
aeubanks
kmitropoulou
Commits
rGb1a95848180e: [opt] Disincentivize new tests from using old pass syntax
Summary

Over the past day or so, i've took a large swing at our tests,
and reduced the number of tests that were still using the old syntax
from ~1800 to just 200.

Left to handle: (as it is seen in this patch)

  • Transforms/LSR
  • Transforms/CGP
  • Transforms/TypePromotion
  • Transforms/HardwareLoops
  • Analysis/*
  • some misc.

I think this is the right point to start actively refusing
to honor the old syntax, except for the old tests,
to prevent the old syntax from creeping back in.

Thus, let's add temporary default-off flag,
and if it is not passed refuse to accept old syntax.
The tests that still need porting are annotated with this flag.

Diff Detail

Event Timeline

lebedev.ri created this revision.Dec 8 2022, 9:52 AM
Herald added a reviewer: kmitropoulou. · View Herald TranscriptDec 8 2022, 9:52 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: kosarev, mattd, gchakrabarti and 15 others. · View Herald Transcript
lebedev.ri requested review of this revision.Dec 8 2022, 9:52 AM
Herald added subscribers: • pcwang-thead, jholewinski. · View Herald TranscriptDec 8 2022, 9:52 AM
lebedev.ri edited the summary of this revision. (Show Details)Dec 8 2022, 9:54 AM
lebedev.ri removed a reviewer: kmitropoulou.
Herald added a reviewer: kmitropoulou. · View Herald TranscriptDec 8 2022, 9:54 AM
fhahn added a subscriber: fhahn.Dec 8 2022, 12:04 PM

I like the idea, thanks for working on this!

aeubanks accepted this revision.Dec 8 2022, 12:33 PM
aeubanks added inline comments.
llvm/tools/opt/opt.cpp
90
This revision was not accepted when it landed; it landed in state Needs Review.Dec 8 2022, 12:54 PM
This revision was landed with ongoing or failed builds.
Closed by commit rGb1a95848180e: [opt] Disincentivize new tests from using old pass syntax (authored by lebedev.ri). · Explain Why
This revision was automatically updated to reflect the committed changes.
lebedev.ri added a commit: rGb1a95848180e: [opt] Disincentivize new tests from using old pass syntax.
Herald added a project: Restricted Project. · View Herald TranscriptDec 8 2022, 12:54 PM
Herald added a subscriber: cfe-commits. · View Herald Transcript
lebedev.ri added a comment.Dec 8 2022, 12:55 PM

@aeubanks Thank you for the review!

Harbormaster completed remote builds in B202013: Diff 481340.Dec 8 2022, 5:10 PM

Revision Contents

PathSize
clang/
test/
CodeGen/
2 lines
2 lines
CodeGenCXX/
2 lines
llvm/
test/
Analysis/
AliasSet/
2 lines
CallGraph/
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
Dominators/
2 lines
2 lines
2 lines
GlobalsModRef/
2 lines
LazyValueAnalysis/
4 lines
2 lines
LoopAccessAnalysis/
2 lines
6 lines
4 lines
MemorySSA/
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
MustExecute/
4 lines
2 lines
4 lines
2 lines
ScalarEvolution/
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
Bitcode/
2 lines
2 lines
2 lines
CodeGen/
AArch64/
2 lines
2 lines
2 lines
AMDGPU/
2 lines
8 lines
8 lines
6 lines
2 lines
8 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
ARM/
10 lines
Generic/
2 lines
NVPTX/
4 lines
8 lines
2 lines
4 lines
6 lines
PowerPC/
6 lines
2 lines
2 lines
SystemZ/
2 lines
Thumb/
8 lines
Thumb2/
mve-intrinsics/
2 lines
4 lines
2 lines
WinEH/
2 lines
X86/
GC/
2 lines
4 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
6 lines
6 lines
2 lines
4 lines
2 lines
DebugInfo/
AArch64/
4 lines
ARM/
2 lines
Generic/
2 lines
2 lines
assignment-tracking/
dse/
4 lines
2 lines
licm/
4 lines
2 lines
memcpyopt/
6 lines
parse-and-verify/
4 lines
4 lines
2 lines
2 lines
16 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
4 lines
4 lines
2 lines
X86/
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
4 lines
4 lines
8 lines
2 lines
4 lines
2 lines
2 lines
2 lines
24 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Feature/
OperandBundles/
2 lines
2 lines
2 lines
4 lines
LTO/
X86/
2 lines
Other/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
X86/
4 lines
2 lines
2 lines
2 lines
4 lines
8 lines
12 lines
2 lines
2 lines
2 lines
4 lines
6 lines
26 lines
12 lines
14 lines
6 lines
2 lines
2 lines
2 lines
Transforms/
HardwareLoops/
ARM/
6 lines
LoadStoreVectorizer/
X86/
6 lines
Verifier/
2 lines
2 lines
10 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
10 lines
2 lines
tools/
UpdateTestChecks/
update_analyze_test_checks/
Inputs/
2 lines
2 lines
llvm-reduce/
2 lines
tools/
opt/
8 lines

Diff 481420

clang/test/CodeGen/arm-neon-vcadd.c

// REQUIRES: arm-registered-target // REQUIRES: arm-registered-target
// RUN: %clang_cc1 -triple armv8.3a-arm-none-eabi -target-cpu generic \ // RUN: %clang_cc1 -triple armv8.3a-arm-none-eabi -target-cpu generic \
// RUN: -target-feature +fullfp16 -mfloat-abi soft -S -emit-llvm -o - %s | \ // RUN: -target-feature +fullfp16 -mfloat-abi soft -S -emit-llvm -o - %s | \
// RUN: opt -S -sroa -o - | FileCheck %s // RUN: opt -S -passes=sroa -o - | FileCheck %s
#include <arm_neon.h> #include <arm_neon.h>
void foo16x4_rot90(float16x4_t a, float16x4_t b) void foo16x4_rot90(float16x4_t a, float16x4_t b)
{ {
// CHECK: call <4 x half> @llvm.arm.neon.vcadd.rot90.v4f16 // CHECK: call <4 x half> @llvm.arm.neon.vcadd.rot90.v4f16
float16x4_t result = vcadd_rot90_f16(a, b); float16x4_t result = vcadd_rot90_f16(a, b);
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

clang/test/CodeGen/memcmp-inline-builtin-to-asm.c

// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
// RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -o - %s | opt -S -verify | FileCheck %s // RUN: %clang_cc1 -triple x86_64 -S -emit-llvm -o - %s | opt -S -passes=verify | FileCheck %s
// //
// Verifies that clang detects memcmp inline version and uses it instead of the builtin. // Verifies that clang detects memcmp inline version and uses it instead of the builtin.
typedef unsigned long size_t; typedef unsigned long size_t;
// Clang requires these attributes for a function to be redefined. // Clang requires these attributes for a function to be redefined.
#define AVAILABLE_EXTERNALLY extern inline __attribute__((always_inline)) __attribute__((gnu_inline)) #define AVAILABLE_EXTERNALLY extern inline __attribute__((always_inline)) __attribute__((gnu_inline))
Show All 25 Lines

clang/test/CodeGenCXX/attr-musttail.cpp

// RUN: %clang_cc1 -no-opaque-pointers -fno-elide-constructors -S -emit-llvm %s -triple x86_64-unknown-linux-gnu -o - | FileCheck %s // RUN: %clang_cc1 -no-opaque-pointers -fno-elide-constructors -S -emit-llvm %s -triple x86_64-unknown-linux-gnu -o - | FileCheck %s
// RUN: %clang_cc1 -no-opaque-pointers -fno-elide-constructors -S -emit-llvm %s -triple x86_64-unknown-linux-gnu -o - | opt -verify // RUN: %clang_cc1 -no-opaque-pointers -fno-elide-constructors -S -emit-llvm %s -triple x86_64-unknown-linux-gnu -o - | opt -passes=verify
// FIXME: remove the call to "opt" once the tests are running the Clang verifier automatically again. // FIXME: remove the call to "opt" once the tests are running the Clang verifier automatically again.
int Bar(int); int Bar(int);
int Baz(int); int Baz(int);
int Func1(int x) { int Func1(int x) {
if (x) { if (x) {
// CHECK: %call = musttail call noundef i32 @_Z3Bari(i32 noundef %1) // CHECK: %call = musttail call noundef i32 @_Z3Bari(i32 noundef %1)
▲ Show 20 Lines • Show All 218 Lines • Show Last 20 Lines

llvm/test/Analysis/AliasSet/unknown-inst-tracking.ll

; RUN: opt -S -licm -simple-loop-unswitch < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -licm -simple-loop-unswitch < %s | FileCheck %s
; This test checks for a crash. See PR32587. ; This test checks for a crash. See PR32587.
@global = external global i32 @global = external global i32
declare i32 @f_1(i8, i32 returned) declare i32 @f_1(i8, i32 returned)
define i32 @f_0() { define i32 @f_0() {
Show All 16 Lines

llvm/test/Analysis/CallGraph/2008-09-09-DirectCall.ll

; RUN: opt < %s -print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -print-callgraph -disable-output 2>&1 | FileCheck %s
; CHECK: Call graph node <<null function>> ; CHECK: Call graph node <<null function>>
; CHECK: CS<{{.*}}> calls function 'callee' ; CHECK: CS<{{.*}}> calls function 'callee'
; CHECK: Call graph node for function: 'caller' ; CHECK: Call graph node for function: 'caller'
; CHECK: CS<{{.*}}> calls function 'callee' ; CHECK: CS<{{.*}}> calls function 'callee'
define internal void @callee(...) { define internal void @callee(...) {
entry: entry:
unreachable unreachable
} }
define void @caller() { define void @caller() {
entry: entry:
call void (...) @callee( ptr @callee ) call void (...) @callee( ptr @callee )
unreachable unreachable
} }

llvm/test/Analysis/CallGraph/2008-09-09-UsedByGlobal.ll

; RUN: opt < %s -print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -print-callgraph -disable-output 2>&1 | FileCheck %s
@a = global ptr @f ; <ptr> [#uses=0] @a = global ptr @f ; <ptr> [#uses=0]
; CHECK: calls function 'f' ; CHECK: calls function 'f'
define internal void @f() { define internal void @f() {
unreachable unreachable
} }

llvm/test/Analysis/CallGraph/callback-calls.ll

; RUN: opt < %s -print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -print-callgraph -disable-output 2>&1 | FileCheck %s
; RUN: opt < %s -passes=print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -passes=print-callgraph -disable-output 2>&1 | FileCheck %s
; CHECK: Call graph node for function: 'caller' ; CHECK: Call graph node for function: 'caller'
; CHECK-NEXT: CS<{{.*}}> calls function 'broker' ; CHECK-NEXT: CS<{{.*}}> calls function 'broker'
; CHECK-NEXT: CS<None> calls function 'callback' ; CHECK-NEXT: CS<None> calls function 'callback'
define void @caller(ptr %arg) { define void @caller(ptr %arg) {
call void @broker(ptr @callback, ptr %arg) call void @broker(ptr @callback, ptr %arg)
ret void ret void
Show All 10 Lines

llvm/test/Analysis/CallGraph/ignore-assumelike-calls.ll

; RUN: opt < %s -print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -print-callgraph -disable-output 2>&1 | FileCheck %s
; CHECK: Call graph node <<null function>><<{{.*}}>> #uses=0 ; CHECK: Call graph node <<null function>><<{{.*}}>> #uses=0
; CHECK-NEXT: CS<None> calls function 'other_intrinsic_use' ; CHECK-NEXT: CS<None> calls function 'other_intrinsic_use'
; CHECK-NEXT: CS<None> calls function 'other_cast_intrinsic_use' ; CHECK-NEXT: CS<None> calls function 'other_cast_intrinsic_use'
; CHECK-NEXT: CS<None> calls function 'llvm.lifetime.start.p0' ; CHECK-NEXT: CS<None> calls function 'llvm.lifetime.start.p0'
; CHECK-NEXT: CS<None> calls function 'llvm.memset.p0.i64' ; CHECK-NEXT: CS<None> calls function 'llvm.memset.p0.i64'
; CHECK-NEXT: CS<None> calls function 'llvm.memset.p1.i64' ; CHECK-NEXT: CS<None> calls function 'llvm.memset.p1.i64'
; CHECK-EMPTY: ; CHECK-EMPTY:
; CHECK-NEXT: Call graph node for function: 'addrspacecast_only'<<{{.*}}>> #uses=0 ; CHECK-NEXT: Call graph node for function: 'addrspacecast_only'<<{{.*}}>> #uses=0
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Analysis/CallGraph/ignore-callback-uses.ll

; RUN: opt < %s -print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -print-callgraph -disable-output 2>&1 | FileCheck %s
; CHECK: Call graph node <<null function>><<{{.*}}>> #uses=0 ; CHECK: Call graph node <<null function>><<{{.*}}>> #uses=0
; CHECK-NEXT: CS<{{.*}}> calls function 'f' ; CHECK-NEXT: CS<{{.*}}> calls function 'f'
; CHECK-NEXT: CS<{{.*}}> calls function '__kmpc_fork_call' ; CHECK-NEXT: CS<{{.*}}> calls function '__kmpc_fork_call'
; CHECK-EMPTY: ; CHECK-EMPTY:
%struct.ident_t = type { i32, i32, i32, i32, ptr } %struct.ident_t = type { i32, i32, i32, i32, ptr }
@0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1 @0 = private unnamed_addr constant [23 x i8] c";unknown;unknown;0;0;;\00", align 1
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Analysis/CallGraph/llvm-used.ll

; RUN: opt < %s -print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -print-callgraph -disable-output 2>&1 | FileCheck %s
; The test will report used1 and used2 functions as used on the grounds ; The test will report used1 and used2 functions as used on the grounds
; of llvm.*.used references. Passing IgnoreLLVMUsed = true into the ; of llvm.*.used references. Passing IgnoreLLVMUsed = true into the
; Function::hasAddressTaken() in the CallGraph::addToCallGraph() has to ; Function::hasAddressTaken() in the CallGraph::addToCallGraph() has to
; change their uses to zero. ; change their uses to zero.
; CHECK: Call graph node <<null function>><<{{.*}}>> #uses=0 ; CHECK: Call graph node <<null function>><<{{.*}}>> #uses=0
; CHECK-NEXT: CS<None> calls function 'used1' ; CHECK-NEXT: CS<None> calls function 'used1'
Show All 28 Lines

llvm/test/Analysis/CallGraph/no-intrinsics.ll

; RUN: opt < %s -print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -print-callgraph -disable-output 2>&1 | FileCheck %s
; RUN: opt < %s -passes=print-callgraph -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -passes=print-callgraph -disable-output 2>&1 | FileCheck %s
; Check that intrinsics aren't added to the call graph ; Check that intrinsics aren't added to the call graph
declare void @llvm.memcpy.p0.p0.i32(ptr, ptr, i32, i1) declare void @llvm.memcpy.p0.p0.i32(ptr, ptr, i32, i1)
define void @f(ptr %out, ptr %in) { define void @f(ptr %out, ptr %in) {
call void @llvm.memcpy.p0.p0.i32(ptr align 4 %out, ptr align 4 %in, i32 100, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 4 %out, ptr align 4 %in, i32 100, i1 false)
ret void ret void
} }
; CHECK: Call graph node for function: 'f' ; CHECK: Call graph node for function: 'f'
; CHECK-NOT: calls function 'llvm.memcpy.p0i8.p0i8.i32' ; CHECK-NOT: calls function 'llvm.memcpy.p0i8.p0i8.i32'

llvm/test/Analysis/CallGraph/non-leaf-intrinsics.ll

; RUN: opt -S -print-callgraph -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -print-callgraph -disable-output < %s 2>&1 | FileCheck %s
declare void @llvm.experimental.patchpoint.void(i64, i32, ptr, i32, ...) declare void @llvm.experimental.patchpoint.void(i64, i32, ptr, i32, ...)
declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...) declare token @llvm.experimental.gc.statepoint.p0(i64, i32, ptr, i32, i32, ...)
define private void @f() { define private void @f() {
ret void ret void
} }
Show All 22 Lines

llvm/test/Analysis/Dominators/2007-07-11-SplitBlock.ll

; RUN: opt < %s -loop-rotate -simple-loop-unswitch -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax < %s -loop-rotate -simple-loop-unswitch -disable-output
define i32 @stringSearch_Clib(i32 %count) { define i32 @stringSearch_Clib(i32 %count) {
entry: entry:
br i1 false, label %bb36, label %bb44 br i1 false, label %bb36, label %bb44
cond_true20: ; preds = %bb36 cond_true20: ; preds = %bb36
%tmp33 = add i32 0, 0 ; <i32> [#uses=1] %tmp33 = add i32 0, 0 ; <i32> [#uses=1]
br label %bb36 br label %bb36
Show All 12 Lines

llvm/test/Analysis/Dominators/2007-07-12-SplitBlock.ll

; RUN: opt < %s -loop-rotate -licm -simple-loop-unswitch -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax < %s -loop-rotate -licm -simple-loop-unswitch -disable-output
define i32 @main(i32 %argc, i8** %argv) { define i32 @main(i32 %argc, i8** %argv) {
entry: entry:
br label %bb7 br label %bb7
bb7: ; preds = %bb7, %entry bb7: ; preds = %bb7, %entry
%tmp54 = icmp slt i32 0, 2000000 ; <i1> [#uses=1] %tmp54 = icmp slt i32 0, 2000000 ; <i1> [#uses=1]
br i1 %tmp54, label %bb7, label %bb56 br i1 %tmp54, label %bb7, label %bb56
bb56: ; preds = %bb7 bb56: ; preds = %bb7
ret i32 0 ret i32 0
} }

llvm/test/Analysis/Dominators/invoke.ll

; RUN: opt -verify -disable-output < %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify -disable-output < %s
; This tests that we handle unreachable blocks correctly ; This tests that we handle unreachable blocks correctly
define void @f() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { define void @f() personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) {
%v1 = invoke i32* @g() %v1 = invoke i32* @g()
to label %bb1 unwind label %bb2 to label %bb1 unwind label %bb2
invoke void @__dynamic_cast() invoke void @__dynamic_cast()
to label %bb1 unwind label %bb2 to label %bb1 unwind label %bb2
bb1: bb1:
Show All 10 Lines

llvm/test/Analysis/GlobalsModRef/pr12351.ll

; RUN: opt < %s -aa-pipeline=basic-aa,globals-aa -gvn -S -disable-verify | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -aa-pipeline=basic-aa,globals-aa -gvn -S -disable-verify | FileCheck %s
declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1) declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i1)
define void @foo(i8* %x, i8* %y) { define void @foo(i8* %x, i8* %y) {
call void @llvm.memcpy.p0i8.p0i8.i32(i8* %x, i8* %y, i32 1, i1 false); call void @llvm.memcpy.p0i8.p0i8.i32(i8* %x, i8* %y, i32 1, i1 false);
ret void ret void
} }
define void @bar(i8* %y, i8* %z) { define void @bar(i8* %y, i8* %z) {
Show All 24 Lines

llvm/test/Analysis/LazyValueAnalysis/lvi-after-jumpthreading.ll

; RUN: opt < %s -jump-threading -print-lvi-after-jump-threading -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -jump-threading -print-lvi-after-jump-threading -disable-output 2>&1 | FileCheck %s
; RUN: opt < %s -passes=jump-threading -print-lvi-after-jump-threading -disable-output 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -passes=jump-threading -print-lvi-after-jump-threading -disable-output 2>&1 | FileCheck %s
; Testing LVI cache after jump-threading ; Testing LVI cache after jump-threading
; Jump-threading transforms the IR below to one where ; Jump-threading transforms the IR below to one where
; loop and backedge basic blocks are merged into one. ; loop and backedge basic blocks are merged into one.
; basic block (named backedge) with the branch being: ; basic block (named backedge) with the branch being:
; %cont = icmp slt i32 %iv.next, 400 ; %cont = icmp slt i32 %iv.next, 400
; br i1 %cont, label %backedge, label %exit ; br i1 %cont, label %backedge, label %exit
▲ Show 20 Lines • Show All 180 Lines • Show Last 20 Lines

llvm/test/Analysis/LazyValueAnalysis/lvi-for-ashr.ll

; RUN: opt -correlated-propagation -S %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -correlated-propagation -S %s | FileCheck %s
; CHECK-LABEL: @test-ashr ; CHECK-LABEL: @test-ashr
; CHECK: bb_then ; CHECK: bb_then
; CHECK: %. = select i1 true, i32 3, i32 2 ; CHECK: %. = select i1 true, i32 3, i32 2
define i32 @test-ashr(i32 %c) { define i32 @test-ashr(i32 %c) {
chk65: chk65:
%cmp = icmp sgt i32 %c, 65 %cmp = icmp sgt i32 %c, 65
br i1 %cmp, label %return, label %chk0 br i1 %cmp, label %return, label %chk0
Show All 18 Lines

llvm/test/Analysis/LoopAccessAnalysis/interleave-innermost.ll

; RUN: opt -loop-vectorize -force-vector-interleave=1 -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-vectorize -force-vector-interleave=1 -S < %s | FileCheck %s
; CHECK-LABEL: TestFoo ; CHECK-LABEL: TestFoo
; CHECK-NOT: %wide.vec ; CHECK-NOT: %wide.vec
target datalayout = "e-m:e-i64:64-n32:64" target datalayout = "e-m:e-i64:64-n32:64"
target triple = "powerpc64le-unknown-linux-gnu" target triple = "powerpc64le-unknown-linux-gnu"
define void @TestFoo(i1 %X, i1 %Y) { define void @TestFoo(i1 %X, i1 %Y) {
bb: bb:
Show All 20 Lines

llvm/test/Analysis/LoopAccessAnalysis/memcheck-ni.ll

; RUN: opt -loop-versioning -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-versioning -S < %s | FileCheck %s
; NB: addrspaces 10-13 are non-integral ; NB: addrspaces 10-13 are non-integral
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12:13" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128-ni:10:11:12:13"
%jl_value_t = type opaque %jl_value_t = type opaque
%jl_array_t = type { i8 addrspace(13)*, i64, i16, i16, i32 } %jl_array_t = type { i8 addrspace(13)*, i64, i16, i16, i32 }
define void @"japi1_permutedims!_33509"(%jl_value_t addrspace(10)**) { define void @"japi1_permutedims!_33509"(%jl_value_t addrspace(10)**) {
; CHECK: [[CMP:%[^ ]*]] = icmp ult double addrspace(13)* [[A:%[^ ]*]], [[B:%[^ ]*]] ; CHECK: [[CMP:%[^ ]*]] = icmp ult double addrspace(13)* [[A:%[^ ]*]], [[B:%[^ ]*]]
; CHECK: [[SELECT:%[^ ]*]] = select i1 %18, double addrspace(13)* [[A]], double addrspace(13)* [[B]] ; CHECK: [[SELECT:%[^ ]*]] = select i1 %18, double addrspace(13)* [[A]], double addrspace(13)* [[B]]
top: top:
%1 = alloca [3 x i64], align 8 %1 = alloca [3 x i64], align 8
%2 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %0, align 8 %2 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %0, align 8
%3 = getelementptr inbounds %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %0, i64 1 %3 = getelementptr inbounds %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %0, i64 1
%4 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %3, align 8 %4 = load %jl_value_t addrspace(10)*, %jl_value_t addrspace(10)** %3, align 8
%5 = getelementptr inbounds [3 x i64], [3 x i64]* %1, i64 0, i64 0 %5 = getelementptr inbounds [3 x i64], [3 x i64]* %1, i64 0, i64 0
store i64 1, i64* %5, align 8 store i64 1, i64* %5, align 8
%6 = getelementptr inbounds [3 x i64], [3 x i64]* %1, i64 0, i64 1 %6 = getelementptr inbounds [3 x i64], [3 x i64]* %1, i64 0, i64 1
%7 = load i64, i64* inttoptr (i64 24 to i64*), align 8 %7 = load i64, i64* inttoptr (i64 24 to i64*), align 8
%8 = addrspacecast %jl_value_t addrspace(10)* %4 to %jl_value_t addrspace(11)* %8 = addrspacecast %jl_value_t addrspace(10)* %4 to %jl_value_t addrspace(11)*
Show All 19 LinesL74:
store i64 %18, i64 addrspace(13)* %21, align 8 store i64 %18, i64 addrspace(13)* %21, align 8
%22 = add i64 %value_phi20, 1 %22 = add i64 %value_phi20, 1
%23 = add i64 %14, %value_phi21 %23 = add i64 %14, %value_phi21
%24 = icmp eq i64 %value_phi22, %7 %24 = icmp eq i64 %value_phi22, %7
%25 = add i64 %value_phi22, 1 %25 = add i64 %value_phi22, 1
br i1 %24, label %L94, label %L74 br i1 %24, label %L94, label %L74
L94: L94:
ret void ret void
} }

llvm/test/Analysis/LoopAccessAnalysis/scalable-vector-regression-tests.ll

; RUN: opt -loop-load-elim -mtriple=aarch64 -mattr=+sve -S -debug < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-load-elim -mtriple=aarch64 -mattr=+sve -S -debug < %s 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; Regression tests verifying "assumption that TypeSize is not scalable" and ; Regression tests verifying "assumption that TypeSize is not scalable" and
; "Invalid size request on a scalable vector." are not produced by ; "Invalid size request on a scalable vector." are not produced by
; -load-loop-elim (this would cause the test to fail because opt would exit with ; -load-loop-elim (this would cause the test to fail because opt -temporarily-allow-old-pass-syntax would exit with
; a non-zero exit status). ; a non-zero exit status).
; No output checked for this one, but causes a fatal error if the regression is present. ; No output checked for this one, but causes a fatal error if the regression is present.
define void @regression_test_get_gep_induction_operand_typesize_warning(i64 %n, <vscale x 4 x i32>* %a) { define void @regression_test_get_gep_induction_operand_typesize_warning(i64 %n, <vscale x 4 x i32>* %a) {
entry: entry:
br label %loop.body br label %loop.body
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/debugvalue.ll

; RUN: opt -disable-basic-aa -loop-rotate -verify-memoryssa -S %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-basic-aa -loop-rotate -verify-memoryssa -S %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK-LABEL: @f_w4_i2 ; CHECK-LABEL: @f_w4_i2
define void @f_w4_i2() { define void @f_w4_i2() {
entry: entry:
br label %for.cond br label %for.cond
for.cond: ; preds = %for.body, %entry for.cond: ; preds = %for.body, %entry
Show All 35 Lines

llvm/test/Analysis/MemorySSA/loop-rotate-inv-template.ll

; RUN: opt -disable-output -loop-rotate -verify-memoryssa %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -loop-rotate -verify-memoryssa %s
; REQUIRES: asserts ; REQUIRES: asserts
; Function Attrs: nounwind ; Function Attrs: nounwind
define dso_local void @bar() local_unnamed_addr #0 align 32 { define dso_local void @bar() local_unnamed_addr #0 align 32 {
entry: entry:
br label %looplabel.exit.i br label %looplabel.exit.i
looplabel.exit.i: ; preds = %if.end.i, %entry looplabel.exit.i: ; preds = %if.end.i, %entry
Show All 18 Lines

llvm/test/Analysis/MemorySSA/loop-rotate-simplified-clone.ll

; RUN: opt -verify-memoryssa -loop-rotate %s -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify-memoryssa -loop-rotate %s -S | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK-LABEL: @test() ; CHECK-LABEL: @test()
define dso_local void @test() { define dso_local void @test() {
entry: entry:
br label %preheader br label %preheader
preheader: preheader:
Show All 20 Lines

llvm/test/Analysis/MemorySSA/loop-rotate-valuemap.ll

; RUN: opt -loop-rotate %s -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-rotate %s -S | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; Check that loop rotate keeps proper mapping between cloned instructions, ; Check that loop rotate keeps proper mapping between cloned instructions,
; otherwise, MemorySSA will assert. ; otherwise, MemorySSA will assert.
; CHECK-LABEL: @f ; CHECK-LABEL: @f
define void @f() { define void @f() {
entry: entry:
Show All 17 Lines

llvm/test/Analysis/MemorySSA/loop-unswitch.ll

; RUN: opt -S -simple-loop-unswitch -disable-basic-aa -verify-memoryssa < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -simple-loop-unswitch -disable-basic-aa -verify-memoryssa < %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; CHECK-LABEL: @foo() ; CHECK-LABEL: @foo()
; Function Attrs: readnone speculatable ; Function Attrs: readnone speculatable
declare i32 @foo() #0 declare i32 @foo() #0
Show All 17 Lines

llvm/test/Analysis/MemorySSA/nondeterminism.ll

; RUN: opt -simplifycfg -S --preserve-ll-uselistorder %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -simplifycfg -S --preserve-ll-uselistorder %s | FileCheck %s
; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; CHECK-LABEL: @n ; CHECK-LABEL: @n
; CHECK: uselistorder i16 0, { 3, 2, 4, 1, 5, 0, 6 } ; CHECK: uselistorder i16 0, { 3, 2, 4, 1, 5, 0, 6 }
; Note: test was added in an effort to ensure determinism when updating memoryssa. See PR42574. ; Note: test was added in an effort to ensure determinism when updating memoryssa. See PR42574.
; If the uselistorder check becomes no longer relevant, the test can be disabled or removed. ; If the uselistorder check becomes no longer relevant, the test can be disabled or removed.
%rec9 = type { i16, i32, i32 } %rec9 = type { i16, i32, i32 }
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/pr40037.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -S -simple-loop-unswitch -verify-memoryssa < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -simple-loop-unswitch -verify-memoryssa < %s | FileCheck %s
target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64" target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"
target triple = "s390x-ibm-linux" target triple = "s390x-ibm-linux"
; CHECK-LABEL: @func_23() ; CHECK-LABEL: @func_23()
define dso_local void @func_23() local_unnamed_addr { define dso_local void @func_23() local_unnamed_addr {
br label %bb2 br label %bb2
bb2: ; preds = %bb2.loopexit, %bb bb2: ; preds = %bb2.loopexit, %bb
Show All 23 Lines

llvm/test/Analysis/MemorySSA/pr40749_2.ll

; RUN: opt -S -licm -simple-loop-unswitch -verify-memoryssa %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -licm -simple-loop-unswitch -verify-memoryssa %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64" target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"
target triple = "s390x-ibm-linux" target triple = "s390x-ibm-linux"
@g_92 = external dso_local local_unnamed_addr global i16, align 2 @g_92 = external dso_local local_unnamed_addr global i16, align 2
@g_993 = external dso_local local_unnamed_addr global i32, align 4 @g_993 = external dso_local local_unnamed_addr global i32, align 4
; CHECK-LABEL: @ff6 ; CHECK-LABEL: @ff6
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/pr42294.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -loop-rotate -licm %s -disable-output -debug-only=licm 2>&1 | FileCheck %s -check-prefix=LICM ; RUN: opt -temporarily-allow-old-pass-syntax -loop-rotate -licm %s -disable-output -debug-only=licm 2>&1 | FileCheck %s -check-prefix=LICM
; RUN: opt -loop-rotate -licm %s -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-rotate -licm %s -S | FileCheck %s
; LICM-NOT: LICM sinking instruction: %.pre = load i8, ptr %arrayidx.phi.trans.insert ; LICM-NOT: LICM sinking instruction: %.pre = load i8, ptr %arrayidx.phi.trans.insert
; CHECK-LABEL: @fn1 ; CHECK-LABEL: @fn1
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK: br i1 true, label %[[END:.*]], label %[[PH:.*]] ; CHECK: br i1 true, label %[[END:.*]], label %[[PH:.*]]
; CHECK: [[PH]]: ; CHECK: [[PH]]:
; CHECK: br label %[[CRIT:.*]] ; CHECK: br label %[[CRIT:.*]]
Show All 35 Lines

llvm/test/Analysis/MemorySSA/pr43044.ll

; RUN: opt -loop-rotate -licm -verify-memoryssa %s -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-rotate -licm -verify-memoryssa %s -S | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64" target datalayout = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-v128:64-a:8:16-n32:64"
target triple = "s390x-ibm-linux" target triple = "s390x-ibm-linux"
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture)
; CHECK-LABEL: @func_42() ; CHECK-LABEL: @func_42()
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/pr43641.ll

; RUN: opt -simple-loop-unswitch -enable-nontrivial-unswitch -verify-memoryssa -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -simple-loop-unswitch -enable-nontrivial-unswitch -verify-memoryssa -S < %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK-LABEL: @c ; CHECK-LABEL: @c
define dso_local void @c(i32 signext %d) local_unnamed_addr { define dso_local void @c(i32 signext %d) local_unnamed_addr {
entry: entry:
br i1 undef, label %while.end, label %while.body.lr.ph br i1 undef, label %while.end, label %while.body.lr.ph
while.body.lr.ph: ; preds = %entry while.body.lr.ph: ; preds = %entry
Show All 13 Lines

llvm/test/Analysis/MemorySSA/pr44029.ll

; RUN: opt -loop-simplifycfg -verify-memoryssa -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-simplifycfg -verify-memoryssa -S < %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
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"
declare i32 @eggs(...) declare i32 @eggs(...)
declare void @spam() declare void @spam()
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/pr46574.ll

; RUN: opt -loop-instsimplify -loop-simplifycfg -licm -simple-loop-unswitch -enable-nontrivial-unswitch %s -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax -loop-instsimplify -loop-simplifycfg -licm -simple-loop-unswitch -enable-nontrivial-unswitch %s -disable-output
; REQUIRES: asserts ; REQUIRES: asserts
%0 = type { i24, i32, i32, i8 } %0 = type { i24, i32, i32, i8 }
@g_1077 = external dso_local local_unnamed_addr global [4 x [3 x [2 x { i8, i8, i8, i8, i8, i8, i8, i8, i32 }]]], align 4 @g_1077 = external dso_local local_unnamed_addr global [4 x [3 x [2 x { i8, i8, i8, i8, i8, i8, i8, i8, i32 }]]], align 4
define void @func_22() { define void @func_22() {
bb: bb:
Show All 24 Lines

llvm/test/Analysis/MemorySSA/simple_loop_unswitch_nontrivial.ll

; RUN: opt -simple-loop-unswitch -enable-nontrivial-unswitch -verify-memoryssa -S %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -simple-loop-unswitch -enable-nontrivial-unswitch -verify-memoryssa -S %s | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
declare void @foo() declare void @foo()
; In Test1, there are no definitions. MemorySSA updates insert trivial phis and remove them. ; In Test1, there are no definitions. MemorySSA updates insert trivial phis and remove them.
; Verify all are removed, considering the SLU pass leaves unreachable blocks hanging when the MSSA updates are done. ; Verify all are removed, considering the SLU pass leaves unreachable blocks hanging when the MSSA updates are done.
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

llvm/test/Analysis/MustExecute/const-cond.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 -disable-output -print-mustexecute %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -print-mustexecute %s 2>&1 | FileCheck %s
; RUN: opt -disable-output -passes=print-mustexecute %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -passes=print-mustexecute %s 2>&1 | FileCheck %s
; In general the CFG below is easily simplified but this is useful for ; In general the CFG below is easily simplified but this is useful for
; pass ordering issue elimination. ; pass ordering issue elimination.
define i1 @const_cond(i32 %high) { define i1 @const_cond(i32 %high) {
; CHECK-LABEL: @const_cond( ; CHECK-LABEL: @const_cond(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
Show All 36 Lines

llvm/test/Analysis/MustExecute/infinite_loops.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 -disable-output -print-mustexecute %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -print-mustexecute %s 2>&1 | FileCheck %s
; Infinite loop. ; Infinite loop.
; Make sure that the backedge is mustexec. ; Make sure that the backedge is mustexec.
define void @test_no_exit_block(i1 %cond, i32 %a, i32 %b) { define void @test_no_exit_block(i1 %cond, i32 %a, i32 %b) {
; CHECK-LABEL: @test_no_exit_block( ; CHECK-LABEL: @test_no_exit_block(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[LOOP:%.*]] ; CHECK-NEXT: br label [[LOOP:%.*]]
; CHECK: loop: ; CHECK: loop:
▲ Show 20 Lines • Show All 101 Lines • Show Last 20 Lines

llvm/test/Analysis/MustExecute/loop-header.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 -disable-output -print-mustexecute %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -print-mustexecute %s 2>&1 | FileCheck %s
define i1 @header_with_icf(ptr noalias %p, i32 %high) { define i1 @header_with_icf(ptr noalias %p, i32 %high) {
; CHECK-LABEL: @header_with_icf( ; CHECK-LABEL: @header_with_icf(
; CHECK-LABEL: loop: ; CHECK-LABEL: loop:
; CHECK: %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ] ; (mustexec in: loop) ; CHECK: %iv = phi i32 [ 0, %entry ], [ %iv.next, %loop ] ; (mustexec in: loop)
; CHECK: %v = load i32, ptr %p, align 4 ; (mustexec in: loop) ; CHECK: %v = load i32, ptr %p, align 4 ; (mustexec in: loop)
; CHECK: call void @maythrow_and_use(i32 %v) ; (mustexec in: loop) ; CHECK: call void @maythrow_and_use(i32 %v) ; (mustexec in: loop)
; CHECK-NOT: mustexec ; CHECK-NOT: mustexec
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines
; CHECK-NOT: mustexec ; CHECK-NOT: mustexec
entry: entry:
br label %loop br label %loop
loop: loop:
%iv = phi i32 [0, %entry], [%iv.next, %next] %iv = phi i32 [0, %entry], [%iv.next, %next]
br label %inner_loop br label %inner_loop
inner_loop: inner_loop:
%v = load i32, ptr %p %v = load i32, ptr %p
%inner.test = icmp eq i32 %v, 0 %inner.test = icmp eq i32 %v, 0
br i1 %inner.test, label %inner_loop, label %next br i1 %inner.test, label %inner_loop, label %next
next: next:
call void @maythrow_and_use(i32 %v) call void @maythrow_and_use(i32 %v)
%iv.next = add nsw nuw i32 %iv, 1 %iv.next = add nsw nuw i32 %iv, 1
▲ Show 20 Lines • Show All 75 Lines • Show Last 20 Lines

llvm/test/Analysis/MustExecute/pr57780.ll

; RUN: opt -disable-output -print-mustexecute < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -print-mustexecute < %s 2>&1 | FileCheck %s
@c = global i16 0, align 2 @c = global i16 0, align 2
; CHECK-LABEL: define void @latch_cycle_irreducible ; CHECK-LABEL: define void @latch_cycle_irreducible
; CHECK: store i16 5, ptr @c, align 2{{$}} ; CHECK: store i16 5, ptr @c, align 2{{$}}
define void @latch_cycle_irreducible() { define void @latch_cycle_irreducible() {
entry: entry:
br label %loop br label %loop
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/2007-08-06-MisinterpretBranch.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 -indvars -adce -simplifycfg -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -indvars -adce -simplifycfg -S | FileCheck %s
; PR1598 ; PR1598
define i32 @f(i32 %a, i32 %b, i32 %x, i32 %y) { define i32 @f(i32 %a, i32 %b, i32 %x, i32 %y) {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] ; CHECK-NEXT: [[TMP3:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[X:%.*]], 1 ; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[X:%.*]], 1
; CHECK-NEXT: [[SMAX:%.*]] = call i32 @llvm.smax.i32(i32 [[Y:%.*]], i32 [[TMP0]]) ; CHECK-NEXT: [[SMAX:%.*]] = call i32 @llvm.smax.i32(i32 [[Y:%.*]], i32 [[TMP0]])
Show All 17 Lines

llvm/test/Analysis/ScalarEvolution/2012-03-26-LoadConstant.ll

; RUN: opt < %s -globalopt -instcombine -loop-rotate -licm -instcombine -indvars -loop-deletion -constmerge -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -globalopt -temporarily-allow-old-pass-syntax -instcombine -loop-rotate -licm -instcombine -indvars -loop-deletion -constmerge -S | FileCheck %s
; PR11882: ComputeLoadConstantCompareExitLimit crash. ; PR11882: ComputeLoadConstantCompareExitLimit crash.
; ;
; for.body is deleted leaving a loop-invariant load. ; for.body is deleted leaving a loop-invariant load.
; CHECK-NOT: for.body ; CHECK-NOT: for.body
target datalayout = "e-p:64:64:64-n32:64" target datalayout = "e-p:64:64:64-n32:64"
@func_21_l_773 = external global i32, align 4 @func_21_l_773 = external global i32, align 4
@g_814 = external global i32, align 4 @g_814 = external global i32, align 4
Show All 34 Lines

llvm/test/Analysis/ScalarEvolution/2012-05-29-MulAddRec.ll

; RUN: opt < %s -S -indvars -loop-unroll | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -indvars -loop-unroll | FileCheck %s
; ;
; loop-unroll fully unrolls the inner loop, creating an interesting ; loop-unroll fully unrolls the inner loop, creating an interesting
; chain of multiplication. indvars forces SCEV to run again on the ; chain of multiplication. indvars forces SCEV to run again on the
; outer loop. While reducing the recurrence at %mul3, unsigned integer overflow ; outer loop. While reducing the recurrence at %mul3, unsigned integer overflow
; causes one of the terms to reach zero. This forces all multiples in ; causes one of the terms to reach zero. This forces all multiples in
; the recurrence to be zero, reducing the whole thing to a constant expression. ; the recurrence to be zero, reducing the whole thing to a constant expression.
; ;
; PR12929: cast<Ty>() argument of incompatible type ; PR12929: cast<Ty>() argument of incompatible type
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/avoid-assume-hang.ll

; RUN: opt %s -always-inline | opt -passes='print<scalar-evolution>' ; RUN: opt -temporarily-allow-old-pass-syntax %s -always-inline | opt -temporarily-allow-old-pass-syntax -passes='print<scalar-evolution>'
; There was optimization bug in ScalarEvolution, that causes too long ; There was optimization bug in ScalarEvolution, that causes too long
; compute time and stack overflow crash. ; compute time and stack overflow crash.
declare void @body(i32) declare void @body(i32)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
define available_externally void @assume1(i64 %i.ext, i64 %a) alwaysinline { define available_externally void @assume1(i64 %i.ext, i64 %a) alwaysinline {
%cmp0 = icmp ne i64 %i.ext, %a %cmp0 = icmp ne i64 %i.ext, %a
call void @llvm.assume(i1 %cmp0) call void @llvm.assume(i1 %cmp0)
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

llvm/test/Analysis/ScalarEvolution/scev-expander-existing-value-offset.ll

; RUN: opt < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S |FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -loop-vectorize -force-vector-interleave=1 -force-vector-width=4 -S |FileCheck %s
; SCEV expansion uses existing value or value + offset to reduce duplicate code expansion so foo should only generate one select inst after loop vectorization. ; SCEV expansion uses existing value or value + offset to reduce duplicate code expansion so foo should only generate one select inst after loop vectorization.
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: select ; CHECK: select
; CHECK-NOT: select ; CHECK-NOT: select
@ySrcL = common global i8* null, align 8 @ySrcL = common global i8* null, align 8
@smL = common global i32 0, align 4 @smL = common global i32 0, align 4
Show All 35 Lines

llvm/test/Analysis/ScalarEvolution/scev-expander-reuse-unroll.ll

; RUN: opt < %s -loop-unroll -unroll-runtime -unroll-count=2 -verify-scev-maps -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -loop-unroll -unroll-runtime -unroll-count=2 -verify-scev-maps -S | FileCheck %s
; Check SCEV expansion uses existing value when unrolling an inner loop with runtime trip count in a loop nest. ; Check SCEV expansion uses existing value when unrolling an inner loop with runtime trip count in a loop nest.
; The outer loop gets unrolled twice, so we see 2 selects in the outer loop blocks. ; The outer loop gets unrolled twice, so we see 2 selects in the outer loop blocks.
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-LABEL: for.body.loopexit: ; CHECK-LABEL: for.body.loopexit:
; CHECK: select ; CHECK: select
; CHECK-LABEL: for.body: ; CHECK-LABEL: for.body:
; CHECK: select ; CHECK: select
Show All 30 Lines

llvm/test/Analysis/ScalarEvolution/scev-expander-reuse-vect.ll

; RUN: opt < %s -loop-vectorize -force-vector-width=4 -verify-scev-maps -S |FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -loop-vectorize -force-vector-width=4 -verify-scev-maps -S |FileCheck %s
; SCEV expansion uses existing value when the SCEV has no AddRec expr. ; SCEV expansion uses existing value when the SCEV has no AddRec expr.
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK: select ; CHECK: select
; CHECK-NOT: select ; CHECK-NOT: select
; CHECK: ret ; CHECK: ret
@a = common global [1000 x i16] zeroinitializer, align 16 @a = common global [1000 x i16] zeroinitializer, align 16
Show All 31 Lines

llvm/test/Analysis/ScalarEvolution/scev-invalid.ll

; RUN: opt < %s -S -indvars -loop-unroll | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -indvars -loop-unroll | FileCheck %s
; ;
; PR15570: SEGV: SCEV back-edge info invalid after dead code removal. ; PR15570: SEGV: SCEV back-edge info invalid after dead code removal.
; ;
; Indvars creates a SCEV expression for the loop's back edge taken ; Indvars creates a SCEV expression for the loop's back edge taken
; count, then determines that the comparison is always true and ; count, then determines that the comparison is always true and
; removes it. ; removes it.
; ;
; When loop-unroll asks for the expression, it contains a NULL ; When loop-unroll asks for the expression, it contains a NULL
Show All 25 Lines

llvm/test/Bitcode/compatibility-6.0.ll

; Bitcode compatibility test for llvm 6.0.0 ; Bitcode compatibility test for llvm 6.0.0
; ;
; N.b: This is 6.0-compatible IR. The CHECK lines occasionally differ from ; N.b: This is 6.0-compatible IR. The CHECK lines occasionally differ from
; the IR used to generate the bitcode, and may need to be updated. ; the IR used to generate the bitcode, and may need to be updated.
; RUN: opt -verify -disable-output < %s.bc ; RUN: opt -temporarily-allow-old-pass-syntax -verify -disable-output < %s.bc
; RUN: llvm-dis < %s.bc | FileCheck %s ; RUN: llvm-dis < %s.bc | FileCheck %s
target datalayout = "E" target datalayout = "E"
; CHECK: target datalayout = "E" ; CHECK: target datalayout = "E"
target triple = "x86_64-apple-macosx10.10.0" target triple = "x86_64-apple-macosx10.10.0"
; CHECK: target triple = "x86_64-apple-macosx10.10.0" ; CHECK: target triple = "x86_64-apple-macosx10.10.0"
▲ Show 20 Lines • Show All 1,705 Lines • Show Last 20 Lines

llvm/test/Bitcode/extractelement.ll

; RUN: opt < %s -instsimplify | llvm-dis -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax < %s -instsimplify | llvm-dis -disable-output
; RUN: verify-uselistorder < %s ; RUN: verify-uselistorder < %s
; PR3465 ; PR3465
define double @test() { define double @test() {
%tmp24 = extractelement <2 x double> bitcast (<1 x i128> < i128 85070591730234615870450834276742070272 > to <2 x double>), i32 0 %tmp24 = extractelement <2 x double> bitcast (<1 x i128> < i128 85070591730234615870450834276742070272 > to <2 x double>), i32 0
ret double %tmp24 ret double %tmp24
} }

llvm/test/Bitcode/infer_dso_local.ll

; RUN: opt -verify %S/Inputs/infer_dso_local.bc | llvm-dis | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify %S/Inputs/infer_dso_local.bc | llvm-dis | FileCheck %s
; CHECK: define linkonce_odr hidden void @test() ; CHECK: define linkonce_odr hidden void @test()

llvm/test/CodeGen/AArch64/llvm-masked-gather-legal-for-sve.ll

; RUN: opt -mtriple=aarch64-linux-gnu -mattr=+sve -scalarize-masked-mem-intrin -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=aarch64-linux-gnu -mattr=+sve -scalarize-masked-mem-intrin -S < %s | FileCheck %s
; Testing that masked gathers operating on scalable vectors that are ; Testing that masked gathers operating on scalable vectors that are
; packed in SVE registers are not scalarized. ; packed in SVE registers are not scalarized.
; CHECK-LABEL: @masked_gather_nxv4i32( ; CHECK-LABEL: @masked_gather_nxv4i32(
; CHECK: call <vscale x 4 x i32> @llvm.masked.gather.nxv4i32 ; CHECK: call <vscale x 4 x i32> @llvm.masked.gather.nxv4i32
define <vscale x 4 x i32> @masked_gather_nxv4i32(<vscale x 4 x i32*> %ld, <vscale x 4 x i1> %masks, <vscale x 4 x i32> %passthru) { define <vscale x 4 x i32> @masked_gather_nxv4i32(<vscale x 4 x i32*> %ld, <vscale x 4 x i1> %masks, <vscale x 4 x i32> %passthru) {
%res = call <vscale x 4 x i32> @llvm.masked.gather.nxv4i32(<vscale x 4 x i32*> %ld, i32 0, <vscale x 4 x i1> %masks, <vscale x 4 x i32> %passthru) %res = call <vscale x 4 x i32> @llvm.masked.gather.nxv4i32(<vscale x 4 x i32*> %ld, i32 0, <vscale x 4 x i1> %masks, <vscale x 4 x i32> %passthru)
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/CodeGen/AArch64/llvm-masked-scatter-legal-for-sve.ll

; RUN: opt -mtriple=aarch64-linux-gnu -mattr=+sve -scalarize-masked-mem-intrin -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=aarch64-linux-gnu -mattr=+sve -scalarize-masked-mem-intrin -S < %s | FileCheck %s
; Testing that masked scatters operating on scalable vectors that are ; Testing that masked scatters operating on scalable vectors that are
; packed in SVE registers are not scalarized. ; packed in SVE registers are not scalarized.
; CHECK-LABEL: @masked_scatter_nxv4i32( ; CHECK-LABEL: @masked_scatter_nxv4i32(
; CHECK: call void @llvm.masked.scatter.nxv4i32 ; CHECK: call void @llvm.masked.scatter.nxv4i32
define void @masked_scatter_nxv4i32(<vscale x 4 x i32> %data, <vscale x 4 x i32*> %ptrs, <vscale x 4 x i1> %masks) { define void @masked_scatter_nxv4i32(<vscale x 4 x i32> %data, <vscale x 4 x i32*> %ptrs, <vscale x 4 x i1> %masks) {
call void @llvm.masked.scatter.nxv4i32(<vscale x 4 x i32> %data, <vscale x 4 x i32*> %ptrs, i32 0, <vscale x 4 x i1> %masks) call void @llvm.masked.scatter.nxv4i32(<vscale x 4 x i32> %data, <vscale x 4 x i32*> %ptrs, i32 0, <vscale x 4 x i1> %masks)
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/CodeGen/AArch64/sve-ptest-removal-cmple.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt -instcombine -S %s | llc -mtriple=aarch64--linux-gnu -mattr=+sve -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S %s | llc -mtriple=aarch64--linux-gnu -mattr=+sve -o - | FileCheck %s
target triple = "aarch64-unknown-linux-gnu" target triple = "aarch64-unknown-linux-gnu"
; ;
; Immediate Compares ; Immediate Compares
; ;
define i32 @cmple_imm_nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %a) { define i32 @cmple_imm_nxv16i8(<vscale x 16 x i1> %pg, <vscale x 16 x i8> %a) {
▲ Show 20 Lines • Show All 532 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/amdgpu-unroll-threshold.ll

; RUN: opt < %s -S -mtriple=amdgcn-- -loop-unroll | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=amdgcn-- -loop-unroll | FileCheck %s
; Check that the loop in unroll_default is not fully unrolled using the default ; Check that the loop in unroll_default is not fully unrolled using the default
; unroll threshold ; unroll threshold
; CHECK-LABEL: @unroll_default ; CHECK-LABEL: @unroll_default
; CHECK: entry: ; CHECK: entry:
; CHECK: br i1 %cmp ; CHECK: br i1 %cmp
; CHECK: ret void ; CHECK: ret void
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/force-alwaysinline-lds-global-address.ll

; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-amd-amdhsa -amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s
; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -passes=amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-amd-amdhsa -passes=amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s
; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-stress-function-calls -amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-amd-amdhsa -amdgpu-stress-function-calls -amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s
; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-stress-function-calls -passes=amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-amd-amdhsa -amdgpu-stress-function-calls -passes=amdgpu-always-inline -amdgpu-enable-lower-module-lds=false %s | FileCheck --check-prefix=ALL %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
@lds0 = addrspace(3) global i32 undef, align 4 @lds0 = addrspace(3) global i32 undef, align 4
@lds1 = addrspace(3) global [512 x i32] undef, align 4 @lds1 = addrspace(3) global [512 x i32] undef, align 4
@nested.lds.address = addrspace(1) global ptr addrspace(3) @lds0, align 4 @nested.lds.address = addrspace(1) global ptr addrspace(3) @lds0, align 4
@gds0 = addrspace(2) global i32 undef, align 4 @gds0 = addrspace(2) global i32 undef, align 4
▲ Show 20 Lines • Show All 84 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/inline-maxbb.ll

; RUN: opt -mtriple=amdgcn-- -inline -S -amdgpu-inline-max-bb=2 %s | FileCheck %s --check-prefix=NOINL ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn-- -inline -S -amdgpu-inline-max-bb=2 %s | FileCheck %s --check-prefix=NOINL
; RUN: opt -mtriple=amdgcn-- -inline -S -amdgpu-inline-max-bb=3 %s | FileCheck %s --check-prefix=INL ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn-- -inline -S -amdgpu-inline-max-bb=3 %s | FileCheck %s --check-prefix=INL
; RUN: opt -mtriple=amdgcn-- -passes=inline -S -amdgpu-inline-max-bb=2 %s | FileCheck %s --check-prefix=NOINL ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn-- -passes=inline -S -amdgpu-inline-max-bb=2 %s | FileCheck %s --check-prefix=NOINL
; RUN: opt -mtriple=amdgcn-- -passes=inline -S -amdgpu-inline-max-bb=3 %s | FileCheck %s --check-prefix=INL ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn-- -passes=inline -S -amdgpu-inline-max-bb=3 %s | FileCheck %s --check-prefix=INL
define i32 @callee(i32 %x) { define i32 @callee(i32 %x) {
entry: entry:
%cc = icmp eq i32 %x, 1 %cc = icmp eq i32 %x, 1
br i1 %cc, label %ret_res, label %mulx br i1 %cc, label %ret_res, label %mulx
mulx: mulx:
%mul1 = mul i32 %x, %x %mul1 = mul i32 %x, %x
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/loop-idiom.ll

; RUN: opt -loop-idiom -S < %s -march=r600 -mcpu=redwood | FileCheck --check-prefix=R600 --check-prefix=FUNC %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-idiom -S < %s -march=r600 -mcpu=redwood | FileCheck --check-prefix=R600 --check-prefix=FUNC %s
; RUN: opt -loop-idiom -S < %s -march=amdgcn -mcpu=tahiti -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-idiom -S < %s -march=amdgcn -mcpu=tahiti -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s
; RUN: opt -loop-idiom -S < %s -march=amdgcn -mcpu=tonga -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-idiom -S < %s -march=amdgcn -mcpu=tonga -verify-machineinstrs| FileCheck --check-prefix=SI --check-prefix=FUNC %s
target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5" target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5"
; Make sure loop-idiom doesn't create memcpy or memset. There are no library ; Make sure loop-idiom doesn't create memcpy or memset. There are no library
; implementations of these for R600. ; implementations of these for R600.
; FUNC: @no_memcpy ; FUNC: @no_memcpy
; R600-NOT: {{^}}llvm.memcpy ; R600-NOT: {{^}}llvm.memcpy
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/opencl-printf-and-hostcall.ll

; RUN: opt -S -mtriple=amdgcn-unknown-unknown -amdgpu-printf-runtime-binding < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-unknown-unknown -amdgpu-printf-runtime-binding < %s 2>&1 | FileCheck %s
@.str = private unnamed_addr addrspace(4) constant [6 x i8] c"%s:%d\00", align 1 @.str = private unnamed_addr addrspace(4) constant [6 x i8] c"%s:%d\00", align 1
define amdgpu_kernel void @test_kernel(i32 %n) { define amdgpu_kernel void @test_kernel(i32 %n) {
entry: entry:
%str = alloca [9 x i8], align 1, addrspace(5) %str = alloca [9 x i8], align 1, addrspace(5)
%arraydecay = getelementptr inbounds [9 x i8], [9 x i8] addrspace(5)* %str, i32 0, i32 0 %arraydecay = getelementptr inbounds [9 x i8], [9 x i8] addrspace(5)* %str, i32 0, i32 0
%call1 = call i32 (i8 addrspace(4)*, ...) @printf(i8 addrspace(4)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(4)* @.str, i32 0, i32 0), i8 addrspace(5)* %arraydecay, i32 %n) %call1 = call i32 (i8 addrspace(4)*, ...) @printf(i8 addrspace(4)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(4)* @.str, i32 0, i32 0), i8 addrspace(5)* %arraydecay, i32 %n)
Show All 10 Lines

llvm/test/CodeGen/AMDGPU/opencl-printf.ll

; RUN: opt -mtriple=r600-- -amdgpu-printf-runtime-binding -mcpu=r600 -S < %s | FileCheck --check-prefix=FUNC --check-prefix=R600 %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=r600-- -amdgpu-printf-runtime-binding -mcpu=r600 -S < %s | FileCheck --check-prefix=FUNC --check-prefix=R600 %s
; RUN: opt -mtriple=amdgcn-- -amdgpu-printf-runtime-binding -mcpu=fiji -S < %s | FileCheck --check-prefix=FUNC --check-prefix=GCN %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn-- -amdgpu-printf-runtime-binding -mcpu=fiji -S < %s | FileCheck --check-prefix=FUNC --check-prefix=GCN %s
; RUN: opt -mtriple=amdgcn--amdhsa -amdgpu-printf-runtime-binding -mcpu=fiji -S < %s | FileCheck --check-prefix=FUNC --check-prefix=GCN %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn--amdhsa -amdgpu-printf-runtime-binding -mcpu=fiji -S < %s | FileCheck --check-prefix=FUNC --check-prefix=GCN %s
; RUN: opt -mtriple=amdgcn--amdhsa -passes=amdgpu-printf-runtime-binding -mcpu=fiji -S < %s | FileCheck --check-prefix=FUNC --check-prefix=GCN %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn--amdhsa -passes=amdgpu-printf-runtime-binding -mcpu=fiji -S < %s | FileCheck --check-prefix=FUNC --check-prefix=GCN %s
; FUNC-LABEL: @test_kernel( ; FUNC-LABEL: @test_kernel(
; R600-LABEL: entry ; R600-LABEL: entry
; R600-NOT: call i8 addrspace(1)* @__printf_alloc ; R600-NOT: call i8 addrspace(1)* @__printf_alloc
; R600: call i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(2)* @.str, i32 0, i32 0), i8 addrspace(5)* %arraydecay, i32 %n) ; R600: call i32 (i8 addrspace(2)*, ...) @printf(i8 addrspace(2)* getelementptr inbounds ([6 x i8], [6 x i8] addrspace(2)* @.str, i32 0, i32 0), i8 addrspace(5)* %arraydecay, i32 %n)
; GCN-LABEL: entry ; GCN-LABEL: entry
; GCN: call i8 addrspace(1)* @__printf_alloc ; GCN: call i8 addrspace(1)* @__printf_alloc
; GCN-LABEL: entry.split ; GCN-LABEL: entry.split
Show All 23 Lines

llvm/test/CodeGen/AMDGPU/propagate-attributes-function-pointer-argument.ll

; This is a regression test for a bug in the AMDGPU Propagate Attributes pass ; This is a regression test for a bug in the AMDGPU Propagate Attributes pass
; where a call instruction's callee could be replaced with a function pointer ; where a call instruction's callee could be replaced with a function pointer
; passed to the original call instruction as an argument. ; passed to the original call instruction as an argument.
; ;
; Example: ; Example:
; `call void @f(ptr @g)` ; `call void @f(ptr @g)`
; could become ; could become
; `call void @g(ptr @g.1)` ; `call void @g(ptr @g.1)`
; which is invalid IR. ; which is invalid IR.
; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-propagate-attributes-late %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-amd-amdhsa -amdgpu-propagate-attributes-late %s | FileCheck %s
; CHECK-LABEL: define amdgpu_kernel void @thiswasabug() #0 ; CHECK-LABEL: define amdgpu_kernel void @thiswasabug() #0
; CHECK-NOT: call void @g(ptr @g.1) ; CHECK-NOT: call void @g(ptr @g.1)
; CHECK-DAG: call void @f(ptr @g.1) ; CHECK-DAG: call void @f(ptr @g.1)
; CHECK-DAG: call void @g() ; CHECK-DAG: call void @g()
define amdgpu_kernel void @thiswasabug() #0 { define amdgpu_kernel void @thiswasabug() #0 {
; no replacement, but @g should be renamed to @g.1 ; no replacement, but @g should be renamed to @g.1
call void @f(ptr @g) call void @f(ptr @g)
Show All 21 Lines

llvm/test/CodeGen/AMDGPU/r600.alu-limits.ll

; RUN: opt -loop-unroll -unroll-threshold=2000 -S < %s | llc -march=r600 -mcpu=cypress | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-unroll -unroll-threshold=2000 -S < %s | llc -march=r600 -mcpu=cypress | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; CHECK: {{^}}alu_limits: ; CHECK: {{^}}alu_limits:
; CHECK: CF_END ; CHECK: CF_END
%struct.foo = type {i32, i32, i32} %struct.foo = type {i32, i32, i32}
define amdgpu_kernel void @alu_limits(ptr addrspace(1) %out, ptr addrspace(5) %in, i32 %offset) { define amdgpu_kernel void @alu_limits(ptr addrspace(1) %out, ptr addrspace(5) %in, i32 %offset) {
Show All 20 Lines

llvm/test/CodeGen/AMDGPU/reqd-work-group-size.ll

; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -amdgpu-lower-kernel-attributes -instcombine %s | FileCheck -enable-var-scope %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn-amd-amdhsa -S -amdgpu-lower-kernel-attributes -instcombine %s | FileCheck -enable-var-scope %s
; RUN: opt -mtriple=amdgcn-amd-amdhsa -S -passes=amdgpu-lower-kernel-attributes,instcombine %s | FileCheck -enable-var-scope %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn-amd-amdhsa -S -passes=amdgpu-lower-kernel-attributes,instcombine %s | FileCheck -enable-var-scope %s
target datalayout = "n32" target datalayout = "n32"
; CHECK-LABEL: @invalid_reqd_work_group_size( ; CHECK-LABEL: @invalid_reqd_work_group_size(
; CHECK: load i16, ; CHECK: load i16,
define amdgpu_kernel void @invalid_reqd_work_group_size(ptr addrspace(1) %out) #0 !reqd_work_group_size !1 { define amdgpu_kernel void @invalid_reqd_work_group_size(ptr addrspace(1) %out) #0 !reqd_work_group_size !1 {
%dispatch.ptr = tail call ptr addrspace(4) @llvm.amdgcn.dispatch.ptr() %dispatch.ptr = tail call ptr addrspace(4) @llvm.amdgcn.dispatch.ptr()
%gep.group.size.x = getelementptr inbounds i8, ptr addrspace(4) %dispatch.ptr, i64 4 %gep.group.size.x = getelementptr inbounds i8, ptr addrspace(4) %dispatch.ptr, i64 4
▲ Show 20 Lines • Show All 448 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/simplify-libcalls2.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -S -amdgpu-simplifylib -debug-only=amdgpu-simplifylib -mtriple=amdgcn-unknown-amdhsa -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -amdgpu-simplifylib -debug-only=amdgpu-simplifylib -mtriple=amdgcn-unknown-amdhsa -disable-output < %s 2>&1 | FileCheck %s
; RUN: opt -S -passes=amdgpu-simplifylib -debug-only=amdgpu-simplifylib -mtriple=amdgcn-unknown-amdhsa -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -passes=amdgpu-simplifylib -debug-only=amdgpu-simplifylib -mtriple=amdgcn-unknown-amdhsa -disable-output < %s 2>&1 | FileCheck %s
; CHECK-NOT: AMDIC: try folding call void @llvm.lifetime.start.p0 ; CHECK-NOT: AMDIC: try folding call void @llvm.lifetime.start.p0
; CHECK-NOT: AMDIC: try folding call void @llvm.lifetime.end.p0 ; CHECK-NOT: AMDIC: try folding call void @llvm.lifetime.end.p0
; CHECK-NOT: AMDIC: try folding call void @llvm.dbg.value ; CHECK-NOT: AMDIC: try folding call void @llvm.dbg.value
define void @foo(i32 %i) { define void @foo(i32 %i) {
call void @llvm.lifetime.start.p0(i64 1, ptr undef) call void @llvm.lifetime.start.p0(i64 1, ptr undef)
call void @llvm.lifetime.end.p0(i64 1, ptr undef) call void @llvm.lifetime.end.p0(i64 1, ptr undef)
Show All 14 Lines

llvm/test/CodeGen/AMDGPU/speculative-execution-freecasts.ll

; RUN: opt < %s -S -mtriple=amdgcn-unknown-amdhsa -speculative-execution \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=amdgcn-unknown-amdhsa -speculative-execution \
; RUN: -spec-exec-max-speculation-cost 1 -spec-exec-max-not-hoisted 1 \ ; RUN: -spec-exec-max-speculation-cost 1 -spec-exec-max-not-hoisted 1 \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; CHECK-LABEL: @ifThen_bitcast( ; CHECK-LABEL: @ifThen_bitcast(
; CHECK: bitcast ; CHECK: bitcast
; CHECK: br i1 true ; CHECK: br i1 true
define void @ifThen_bitcast(i32 %y) { define void @ifThen_bitcast(i32 %y) {
br i1 true, label %a, label %b br i1 true, label %a, label %b
Show All 21 Lines

llvm/test/CodeGen/AMDGPU/stress-calls.ll

; RUN: opt -S -mtriple=amdgcn-amd-amdhsa -amdgpu-stress-function-calls -amdgpu-always-inline %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-amd-amdhsa -amdgpu-stress-function-calls -amdgpu-always-inline %s | FileCheck %s
; CHECK: define internal fastcc i32 @alwaysinline_func(i32 %a) #0 { ; CHECK: define internal fastcc i32 @alwaysinline_func(i32 %a) #0 {
define internal fastcc i32 @alwaysinline_func(i32 %a) alwaysinline { define internal fastcc i32 @alwaysinline_func(i32 %a) alwaysinline {
entry: entry:
%tmp0 = add i32 %a, 1 %tmp0 = add i32 %a, 1
ret i32 %tmp0 ret i32 %tmp0
} }
Show All 27 Lines

llvm/test/CodeGen/AMDGPU/tti-unroll-prefs.ll

; RUN: opt -loop-unroll -S -mtriple=amdgcn-- -mcpu=tahiti %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-unroll -S -mtriple=amdgcn-- -mcpu=tahiti %s | FileCheck %s
; This IR comes from this OpenCL C code: ; This IR comes from this OpenCL C code:
; ;
; if (b + 4 > a) { ; if (b + 4 > a) {
; for (int i = 0; i < 4; i++, b++) { ; for (int i = 0; i < 4; i++, b++) {
; if (b + 1 <= a) ; if (b + 1 <= a)
; *(dst + c + b) = 0; ; *(dst + c + b) = 0;
; else ; else
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

llvm/test/CodeGen/AMDGPU/unify-metadata.ll

; RUN: opt -mtriple=amdgcn--amdhsa -amdgpu-unify-metadata -S < %s | FileCheck -check-prefix=ALL %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn--amdhsa -amdgpu-unify-metadata -S < %s | FileCheck -check-prefix=ALL %s
; RUN: opt -mtriple=amdgcn--amdhsa -passes=amdgpu-unify-metadata -S < %s | FileCheck -check-prefix=ALL %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=amdgcn--amdhsa -passes=amdgpu-unify-metadata -S < %s | FileCheck -check-prefix=ALL %s
; This test check that we have a singe metadata value after linking several ; This test check that we have a singe metadata value after linking several
; modules for records such as opencl.ocl.version, llvm.ident and similar. ; modules for records such as opencl.ocl.version, llvm.ident and similar.
; ALL-DAG: !opencl.ocl.version = !{![[OCL_VER:[0-9]+]]} ; ALL-DAG: !opencl.ocl.version = !{![[OCL_VER:[0-9]+]]}
; ALL-DAG: !llvm.ident = !{![[LLVM_IDENT_0:[0-9]+]], ![[LLVM_IDENT_1:[0-9]+]]} ; ALL-DAG: !llvm.ident = !{![[LLVM_IDENT_0:[0-9]+]], ![[LLVM_IDENT_1:[0-9]+]]}
; ALL-DAG: !opencl.used.extensions = !{![[USED_EXT_0:[0-9]+]], ![[USED_EXT_1:[0-9]+]], ![[USED_EXT_2:[0-9]+]]} ; ALL-DAG: !opencl.used.extensions = !{![[USED_EXT_0:[0-9]+]], ![[USED_EXT_1:[0-9]+]], ![[USED_EXT_2:[0-9]+]]}
Show All 18 Lines

llvm/test/CodeGen/AMDGPU/vectorize-buffer-fat-pointer.ll

; RUN: opt -S -mtriple=amdgcn-- -load-store-vectorizer < %s | FileCheck -check-prefix=OPT %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=amdgcn-- -load-store-vectorizer < %s | FileCheck -check-prefix=OPT %s
; OPT-LABEL: @func( ; OPT-LABEL: @func(
define void @func(i32 addrspace(7)* %out) { define void @func(i32 addrspace(7)* %out) {
entry: entry:
%a0 = getelementptr i32, i32 addrspace(7)* %out, i32 0 %a0 = getelementptr i32, i32 addrspace(7)* %out, i32 0
%a1 = getelementptr i32, i32 addrspace(7)* %out, i32 1 %a1 = getelementptr i32, i32 addrspace(7)* %out, i32 1
%a2 = getelementptr i32, i32 addrspace(7)* %out, i32 2 %a2 = getelementptr i32, i32 addrspace(7)* %out, i32 2
%a3 = getelementptr i32, i32 addrspace(7)* %out, i32 3 %a3 = getelementptr i32, i32 addrspace(7)* %out, i32 3
; OPT: store <4 x i32> <i32 0, i32 1, i32 2, i32 3>, <4 x i32> addrspace(7)* %0, align 4 ; OPT: store <4 x i32> <i32 0, i32 1, i32 2, i32 3>, <4 x i32> addrspace(7)* %0, align 4
store i32 0, i32 addrspace(7)* %a0 store i32 0, i32 addrspace(7)* %a0
store i32 1, i32 addrspace(7)* %a1 store i32 1, i32 addrspace(7)* %a1
store i32 2, i32 addrspace(7)* %a2 store i32 2, i32 addrspace(7)* %a2
store i32 3, i32 addrspace(7)* %a3 store i32 3, i32 addrspace(7)* %a3
ret void ret void
} }

llvm/test/CodeGen/ARM/bit-reverse-to-rbit.ll

;RUN: opt -instcombine -S < %s | llc -mtriple=armv5e--linux-gnueabi | FileCheck %s ;RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S < %s | llc -mtriple=armv5e--linux-gnueabi | FileCheck %s
;RUN: opt -instcombine -S < %s | llc -mtriple=thumbv4t--linux-gnueabi | FileCheck %s ;RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S < %s | llc -mtriple=thumbv4t--linux-gnueabi | FileCheck %s
;RUN: opt -instcombine -S < %s | llc -mtriple=armv6--linux-gnueabi | FileCheck %s ;RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S < %s | llc -mtriple=armv6--linux-gnueabi | FileCheck %s
;RUN: opt -instcombine -S < %s | llc -mtriple=armv7--linux-gnueabi | FileCheck %s --check-prefix=RBIT ;RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S < %s | llc -mtriple=armv7--linux-gnueabi | FileCheck %s --check-prefix=RBIT
;RUN: opt -instcombine -S < %s | llc -mtriple=thumbv8--linux-gnueabi | FileCheck %s --check-prefix=RBIT ;RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S < %s | llc -mtriple=thumbv8--linux-gnueabi | FileCheck %s --check-prefix=RBIT
;CHECK-NOT: rbit ;CHECK-NOT: rbit
;RBIT: rbit ;RBIT: rbit
define void @byte_reversal(i8* %p, i32 %n) { define void @byte_reversal(i8* %p, i32 %n) {
entry: entry:
br label %for.cond br label %for.cond
Show All 20 Lines

llvm/test/CodeGen/Generic/overloaded-intrinsic-name.ll

; RUN: opt -verify -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify -S < %s | FileCheck %s
; Tests the name mangling performed by the codepath following ; Tests the name mangling performed by the codepath following
; getMangledTypeStr(). Only tests that code with the various manglings ; getMangledTypeStr(). Only tests that code with the various manglings
; run fine: doesn't actually test the mangling with the type of the ; run fine: doesn't actually test the mangling with the type of the
; arguments. Meant to serve as an example-document on how the user ; arguments. Meant to serve as an example-document on how the user
; should do name manglings. ; should do name manglings.
; Exercise the most general case, llvm_anyptr_type, using gc.relocate ; Exercise the most general case, llvm_anyptr_type, using gc.relocate
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/CodeGen/NVPTX/access-non-generic.ll

; RUN: llc < %s -march=nvptx -mcpu=sm_20 | FileCheck %s --check-prefix PTX ; RUN: llc < %s -march=nvptx -mcpu=sm_20 | FileCheck %s --check-prefix PTX
; RUN: llc < %s -march=nvptx64 -mcpu=sm_20 | FileCheck %s --check-prefix PTX ; RUN: llc < %s -march=nvptx64 -mcpu=sm_20 | FileCheck %s --check-prefix PTX
; RUN: opt -mtriple=nvptx-- < %s -S -infer-address-spaces | FileCheck %s --check-prefix IR ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=nvptx-- < %s -S -infer-address-spaces | FileCheck %s --check-prefix IR
; RUN: opt -mtriple=nvptx64-- < %s -S -infer-address-spaces | FileCheck %s --check-prefix IR ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=nvptx64-- < %s -S -infer-address-spaces | FileCheck %s --check-prefix IR
; RUN: %if ptxas %{ llc < %s -march=nvptx -mcpu=sm_20 | %ptxas-verify %} ; RUN: %if ptxas %{ llc < %s -march=nvptx -mcpu=sm_20 | %ptxas-verify %}
; RUN: %if ptxas %{ llc < %s -march=nvptx64 -mcpu=sm_20 | %ptxas-verify %} ; RUN: %if ptxas %{ llc < %s -march=nvptx64 -mcpu=sm_20 | %ptxas-verify %}
@array = internal addrspace(3) global [10 x float] zeroinitializer, align 4 @array = internal addrspace(3) global [10 x float] zeroinitializer, align 4
@scalar = internal addrspace(3) global float 0.000000e+00, align 4 @scalar = internal addrspace(3) global float 0.000000e+00, align 4
; Verifies nvptx-favor-non-generic correctly optimizes generic address space ; Verifies nvptx-favor-non-generic correctly optimizes generic address space
; usage to non-generic address space usage for the patterns we claim to handle: ; usage to non-generic address space usage for the patterns we claim to handle:
▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

llvm/test/CodeGen/NVPTX/intrinsic-old.ll

; RUN: llc < %s -march=nvptx -mcpu=sm_20 | FileCheck -allow-deprecated-dag-overlap %s ; RUN: llc < %s -march=nvptx -mcpu=sm_20 | FileCheck -allow-deprecated-dag-overlap %s
; RUN: llc < %s -march=nvptx64 -mcpu=sm_20 | FileCheck -allow-deprecated-dag-overlap %s ; RUN: llc < %s -march=nvptx64 -mcpu=sm_20 | FileCheck -allow-deprecated-dag-overlap %s
; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda -nvvm-intr-range \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda -nvvm-intr-range \
; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_20 %s ; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_20 %s
; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda -passes=nvvm-intr-range \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda -passes=nvvm-intr-range \
; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_20 %s ; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_20 %s
; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda \
; RUN: -nvvm-intr-range -nvvm-intr-range-sm=30 \ ; RUN: -nvvm-intr-range -nvvm-intr-range-sm=30 \
; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_30 %s ; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_30 %s
; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda \
; RUN: -passes=nvvm-intr-range -nvvm-intr-range-sm=30 \ ; RUN: -passes=nvvm-intr-range -nvvm-intr-range-sm=30 \
; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_30 %s ; RUN: | FileCheck -allow-deprecated-dag-overlap --check-prefix=RANGE --check-prefix=RANGE_30 %s
; RUN: %if ptxas %{ llc < %s -march=nvptx -mcpu=sm_20 | %ptxas-verify %} ; RUN: %if ptxas %{ llc < %s -march=nvptx -mcpu=sm_20 | %ptxas-verify %}
; RUN: %if ptxas %{ llc < %s -march=nvptx64 -mcpu=sm_20 | %ptxas-verify %} ; RUN: %if ptxas %{ llc < %s -march=nvptx64 -mcpu=sm_20 | %ptxas-verify %}
define ptx_device i32 @test_tid_x() { define ptx_device i32 @test_tid_x() {
; CHECK: mov.u32 %r{{[0-9]+}}, %tid.x; ; CHECK: mov.u32 %r{{[0-9]+}}, %tid.x;
; RANGE: call i32 @llvm.nvvm.read.ptx.sreg.tid.x(), !range ![[BLK_IDX_XY:[0-9]+]] ; RANGE: call i32 @llvm.nvvm.read.ptx.sreg.tid.x(), !range ![[BLK_IDX_XY:[0-9]+]]
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

llvm/test/CodeGen/NVPTX/math-intrins-sm80-ptx70-instcombine.ll

; RUN: opt < %s -instcombine -S -mtriple=nvptx-nvidia-cuda -march=nvptx64 \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -instcombine -S -mtriple=nvptx-nvidia-cuda -march=nvptx64 \
; RUN: -mcpu=sm_80 -mattr=+ptx70 | \ ; RUN: -mcpu=sm_80 -mattr=+ptx70 | \
; RUN: FileCheck %s ; RUN: FileCheck %s
declare half @llvm.nvvm.fmin.f16(half, half) declare half @llvm.nvvm.fmin.f16(half, half)
declare half @llvm.nvvm.fmin.ftz.f16(half, half) declare half @llvm.nvvm.fmin.ftz.f16(half, half)
declare <2 x half> @llvm.nvvm.fmin.f16x2(<2 x half>, <2 x half>) declare <2 x half> @llvm.nvvm.fmin.f16x2(<2 x half>, <2 x half>)
declare <2 x half> @llvm.nvvm.fmin.ftz.f16x2(<2 x half>, <2 x half>) declare <2 x half> @llvm.nvvm.fmin.ftz.f16x2(<2 x half>, <2 x half>)
declare float @llvm.nvvm.fmin.nan.f(float, float) declare float @llvm.nvvm.fmin.nan.f(float, float)
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

llvm/test/CodeGen/NVPTX/nvvm-reflect-module-flag.ll

; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda -nvvm-reflect | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda -nvvm-reflect | FileCheck %s
; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda -passes=nvvm-reflect | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda -passes=nvvm-reflect | FileCheck %s
declare i32 @__nvvm_reflect(i8*) declare i32 @__nvvm_reflect(i8*)
@str = private unnamed_addr addrspace(1) constant [11 x i8] c"__CUDA_FTZ\00" @str = private unnamed_addr addrspace(1) constant [11 x i8] c"__CUDA_FTZ\00"
define i32 @foo() { define i32 @foo() {
%call = call i32 @__nvvm_reflect(i8* addrspacecast (i8 addrspace(1)* getelementptr inbounds ([11 x i8], [11 x i8] addrspace(1)* @str, i32 0, i32 0) to i8*)) %call = call i32 @__nvvm_reflect(i8* addrspacecast (i8 addrspace(1)* getelementptr inbounds ([11 x i8], [11 x i8] addrspace(1)* @str, i32 0, i32 0) to i8*))
; CHECK: ret i32 42 ; CHECK: ret i32 42
ret i32 %call ret i32 %call
} }
!llvm.module.flags = !{!0} !llvm.module.flags = !{!0}
!0 = !{i32 4, !"nvvm-reflect-ftz", i32 42} !0 = !{i32 4, !"nvvm-reflect-ftz", i32 42}

llvm/test/CodeGen/NVPTX/speculative-execution-divergent-target.ll

; Checks that speculative-execution only runs on divergent targets, if you pass ; Checks that speculative-execution only runs on divergent targets, if you pass
; -spec-exec-only-if-divergent-target. ; -spec-exec-only-if-divergent-target.
; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda -speculative-execution | \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda -speculative-execution | \
; RUN: FileCheck --check-prefix=ON %s ; RUN: FileCheck --check-prefix=ON %s
; RUN: opt < %s -S -mtriple=nvptx-nvidia-cuda -speculative-execution \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -mtriple=nvptx-nvidia-cuda -speculative-execution \
; RUN: -spec-exec-only-if-divergent-target | \ ; RUN: -spec-exec-only-if-divergent-target | \
; RUN: FileCheck --check-prefix=ON %s ; RUN: FileCheck --check-prefix=ON %s
; RUN: opt < %s -S -speculative-execution -spec-exec-only-if-divergent-target | \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -speculative-execution -spec-exec-only-if-divergent-target | \
; RUN: FileCheck --check-prefix=OFF %s ; RUN: FileCheck --check-prefix=OFF %s
; Hoist in if-then pattern. ; Hoist in if-then pattern.
define void @f() { define void @f() {
; ON: %x = add i32 2, 3 ; ON: %x = add i32 2, 3
; ON: br i1 true ; ON: br i1 true
; OFF: br i1 true ; OFF: br i1 true
; OFF: %x = add i32 2, 3 ; OFF: %x = add i32 2, 3
br i1 true, label %a, label %b br i1 true, label %a, label %b
a: a:
%x = add i32 2, 3 %x = add i32 2, 3
br label %b br label %b
b: b:
ret void ret void
} }

llvm/test/CodeGen/PowerPC/ppc64-P9-mod.ll

; RUN: llc < %s -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 -verify-machineinstrs | FileCheck %s
; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr9 -verify-machineinstrs | FileCheck %s ; RUN: llc < %s -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr9 -verify-machineinstrs | FileCheck %s
; RUN: llc < %s -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr8 | FileCheck %s -check-prefix=CHECK-PWR8 -implicit-check-not mod[us][wd] ; RUN: llc < %s -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr8 | FileCheck %s -check-prefix=CHECK-PWR8 -implicit-check-not mod[us][wd]
; RUN: opt < %s -div-rem-pairs -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 | \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -div-rem-pairs -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr9 | \
; RUN: llc -verify-machineinstrs | FileCheck %s -check-prefix=CHECK-DRP ; RUN: llc -verify-machineinstrs | FileCheck %s -check-prefix=CHECK-DRP
; RUN: opt < %s -div-rem-pairs -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr9 | \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -div-rem-pairs -mtriple=powerpc64-unknown-linux-gnu -mcpu=pwr9 | \
; RUN: llc -verify-machineinstrs | FileCheck %s -check-prefix=CHECK-DRP ; RUN: llc -verify-machineinstrs | FileCheck %s -check-prefix=CHECK-DRP
; RUN: opt < %s -div-rem-pairs -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr8 | \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -div-rem-pairs -mtriple=powerpc64le-unknown-linux-gnu -mcpu=pwr8 | \
; RUN: llc -verify-machineinstrs | FileCheck %s -check-prefix=CHECK-PWR8 -implicit-check-not mod[us][wd] ; RUN: llc -verify-machineinstrs | FileCheck %s -check-prefix=CHECK-PWR8 -implicit-check-not mod[us][wd]
@mod_resultsw = local_unnamed_addr global i32 0, align 4 @mod_resultsw = local_unnamed_addr global i32 0, align 4
@mod_resultud = local_unnamed_addr global i64 0, align 8 @mod_resultud = local_unnamed_addr global i64 0, align 8
@div_resultsw = local_unnamed_addr global i32 0, align 4 @div_resultsw = local_unnamed_addr global i32 0, align 4
@mod_resultuw = local_unnamed_addr global i32 0, align 4 @mod_resultuw = local_unnamed_addr global i32 0, align 4
@div_resultuw = local_unnamed_addr global i32 0, align 4 @div_resultuw = local_unnamed_addr global i32 0, align 4
@div_resultsd = local_unnamed_addr global i64 0, align 8 @div_resultsd = local_unnamed_addr global i64 0, align 8
▲ Show 20 Lines • Show All 263 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/vec_shuffle.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt -mtriple=powerpc-unknown-linux-gnu < %s -instcombine | \ ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=powerpc-unknown-linux-gnu < %s -instcombine | \
; RUN: llc -mtriple=ppc32-- -mcpu=g5 | not grep vperm ; RUN: llc -mtriple=ppc32-- -mcpu=g5 | not grep vperm
; RUN: llc -verify-machineinstrs < %s -mtriple=ppc32-- -mcpu=g5 | FileCheck %s ; RUN: llc -verify-machineinstrs < %s -mtriple=ppc32-- -mcpu=g5 | FileCheck %s
define void @VSLDOI_xy(ptr %A, ptr %B) { define void @VSLDOI_xy(ptr %A, ptr %B) {
; CHECK-LABEL: VSLDOI_xy: ; CHECK-LABEL: VSLDOI_xy:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: lvx 2, 0, 3 ; CHECK-NEXT: lvx 2, 0, 3
; CHECK-NEXT: lvx 3, 0, 4 ; CHECK-NEXT: lvx 3, 0, 4
▲ Show 20 Lines • Show All 608 Lines • Show Last 20 Lines

llvm/test/CodeGen/PowerPC/vperm-instcombine.ll

; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -instcombine -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-v128:128:128-n32: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-v128:128:128-n32:64"
target triple = "powerpc64le-unknown-linux-gnu" target triple = "powerpc64le-unknown-linux-gnu"
define <16 x i8> @foo() nounwind ssp { define <16 x i8> @foo() nounwind ssp {
; CHECK: @foo ; CHECK: @foo
;; Arguments are {0,1,...,15},{16,17,...,31},{30,28,26,...,0} ;; Arguments are {0,1,...,15},{16,17,...,31},{30,28,26,...,0}
%1 = call <4 x i32> @llvm.ppc.altivec.vperm(<4 x i32> <i32 50462976, i32 117835012, i32 185207048, i32 252579084>, <4 x i32> <i32 319951120, i32 387323156, i32 454695192, i32 522067228>, <16 x i8> <i8 30, i8 28, i8 26, i8 24, i8 22, i8 20, i8 18, i8 16, i8 14, i8 12, i8 10, i8 8, i8 6, i8 4, i8 2, i8 0>) %1 = call <4 x i32> @llvm.ppc.altivec.vperm(<4 x i32> <i32 50462976, i32 117835012, i32 185207048, i32 252579084>, <4 x i32> <i32 319951120, i32 387323156, i32 454695192, i32 522067228>, <16 x i8> <i8 30, i8 28, i8 26, i8 24, i8 22, i8 20, i8 18, i8 16, i8 14, i8 12, i8 10, i8 8, i8 6, i8 4, i8 2, i8 0>)
%2 = bitcast <4 x i32> %1 to <16 x i8> %2 = bitcast <4 x i32> %1 to <16 x i8>
ret <16 x i8> %2 ret <16 x i8> %2
;; Revised arguments are {16,17,...31},{0,1,...,15},{1,3,5,...,31} ;; Revised arguments are {16,17,...31},{0,1,...,15},{1,3,5,...,31}
;; optimized into the following: ;; optimized into the following:
; CHECK: ret <16 x i8> <i8 17, i8 19, i8 21, i8 23, i8 25, i8 27, i8 29, i8 31, i8 1, i8 3, i8 5, i8 7, i8 9, i8 11, i8 13, i8 15> ; CHECK: ret <16 x i8> <i8 17, i8 19, i8 21, i8 23, i8 25, i8 27, i8 29, i8 31, i8 1, i8 3, i8 5, i8 7, i8 9, i8 11, i8 13, i8 15>
} }
declare <4 x i32> @llvm.ppc.altivec.vperm(<4 x i32>, <4 x i32>, <16 x i8>) declare <4 x i32> @llvm.ppc.altivec.vperm(<4 x i32>, <4 x i32>, <16 x i8>)

llvm/test/CodeGen/SystemZ/inline-thresh-adjust.ll

; RUN: opt < %s -mtriple=systemz-unknown -mcpu=z15 -inline -disable-output \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -mtriple=systemz-unknown -mcpu=z15 -inline -disable-output \
; RUN: -debug-only=inline,systemztti 2>&1 | FileCheck %s ; RUN: -debug-only=inline,systemztti 2>&1 | FileCheck %s
; REQUIRES: asserts ; REQUIRES: asserts
; ;
; Check that the inlining threshold is incremented for a function using an ; Check that the inlining threshold is incremented for a function using an
; argument only as a memcpy source. ; argument only as a memcpy source.
; CHECK: Inlining calls in: root_function ; CHECK: Inlining calls in: root_function
; CHECK: Inlining {{.*}} Call: call void @leaf_function_A(ptr %Dst) ; CHECK: Inlining {{.*}} Call: call void @leaf_function_A(ptr %Dst)
Show All 23 Lines

llvm/test/CodeGen/Thumb/consthoist-few-dependents.ll

; RUN: opt -consthoist -S %s -o - | FileCheck %s --check-prefix=OPT ; RUN: opt -temporarily-allow-old-pass-syntax -consthoist -S %s -o - | FileCheck %s --check-prefix=OPT
; RUN: opt -consthoist -S -consthoist-min-num-to-rebase=1 %s -o - | FileCheck %s --check-prefix=OPT --check-prefix=OPT-1 ; RUN: opt -temporarily-allow-old-pass-syntax -consthoist -S -consthoist-min-num-to-rebase=1 %s -o - | FileCheck %s --check-prefix=OPT --check-prefix=OPT-1
; RUN: opt -consthoist -S -consthoist-min-num-to-rebase=2 %s -o - | FileCheck %s --check-prefix=OPT --check-prefix=OPT-2 ; RUN: opt -temporarily-allow-old-pass-syntax -consthoist -S -consthoist-min-num-to-rebase=2 %s -o - | FileCheck %s --check-prefix=OPT --check-prefix=OPT-2
; RUN: opt -consthoist -S -consthoist-min-num-to-rebase=3 %s -o - | FileCheck %s --check-prefix=OPT --check-prefix=OPT-3 ; RUN: opt -temporarily-allow-old-pass-syntax -consthoist -S -consthoist-min-num-to-rebase=3 %s -o - | FileCheck %s --check-prefix=OPT --check-prefix=OPT-3
; RUN: llc -consthoist-min-num-to-rebase=2 %s -o - | FileCheck %s --check-prefix=LLC ; RUN: llc -consthoist-min-num-to-rebase=2 %s -o - | FileCheck %s --check-prefix=LLC
target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
target triple = "thumbv6m-none-unknown-musleabi" target triple = "thumbv6m-none-unknown-musleabi"
; Test that constant 0 and 1 of i1 type is NOT hoisted due low ; Test that constant 0 and 1 of i1 type is NOT hoisted due low
; materializing cost. ; materializing cost.
▲ Show 20 Lines • Show All 178 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-intrinsics/predicates.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt -instcombine -mtriple=thumbv8.1m.main %s | llc -mtriple=thumbv8.1m.main -mattr=+mve.fp -verify-machineinstrs -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -mtriple=thumbv8.1m.main %s | llc -mtriple=thumbv8.1m.main -mattr=+mve.fp -verify-machineinstrs -o - | FileCheck %s
declare <16 x i1> @llvm.arm.mve.vctp8(i32) declare <16 x i1> @llvm.arm.mve.vctp8(i32)
declare <8 x i1> @llvm.arm.mve.vctp16(i32) declare <8 x i1> @llvm.arm.mve.vctp16(i32)
declare <4 x i1> @llvm.arm.mve.vctp32(i32) declare <4 x i1> @llvm.arm.mve.vctp32(i32)
declare <2 x i1> @llvm.arm.mve.vctp64(i32) declare <2 x i1> @llvm.arm.mve.vctp64(i32)
declare i32 @llvm.arm.mve.pred.v2i.v2i1(<2 x i1>) declare i32 @llvm.arm.mve.pred.v2i.v2i1(<2 x i1>)
declare i32 @llvm.arm.mve.pred.v2i.v4i1(<4 x i1>) declare i32 @llvm.arm.mve.pred.v2i.v4i1(<4 x i1>)
▲ Show 20 Lines • Show All 244 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-intrinsics/vadc-multiple.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt -instcombine -mtriple=thumbv8.1m.main -S %s | FileCheck --check-prefix=IR %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -mtriple=thumbv8.1m.main -S %s | FileCheck --check-prefix=IR %s
; RUN: opt -instcombine -mtriple=thumbv8.1m.main %s | llc -mtriple=thumbv8.1m.main -mattr=+mve.fp -verify-machineinstrs -O3 -o - | FileCheck --check-prefix=ASM %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -mtriple=thumbv8.1m.main %s | llc -mtriple=thumbv8.1m.main -mattr=+mve.fp -verify-machineinstrs -O3 -o - | FileCheck --check-prefix=ASM %s
%struct.foo = type { [2 x <4 x i32>] } %struct.foo = type { [2 x <4 x i32>] }
define arm_aapcs_vfpcc i32 @test_vadciq_multiple(%struct.foo %a, %struct.foo %b, i32 %carry) { define arm_aapcs_vfpcc i32 @test_vadciq_multiple(%struct.foo %a, %struct.foo %b, i32 %carry) {
entry: entry:
%a.0 = extractvalue %struct.foo %a, 0, 0 %a.0 = extractvalue %struct.foo %a, 0, 0
%a.1 = extractvalue %struct.foo %a, 0, 1 %a.1 = extractvalue %struct.foo %a, 0, 1
%b.0 = extractvalue %struct.foo %b, 0, 0 %b.0 = extractvalue %struct.foo %b, 0, 0
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

llvm/test/CodeGen/Thumb2/mve-vpt-from-intrinsics.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: opt -instcombine -mtriple=thumbv8.1m.main-none-eabi %s | llc -mtriple=thumbv8.1m.main-none-eabi -mattr=+mve --verify-machineinstrs -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -mtriple=thumbv8.1m.main-none-eabi %s | llc -mtriple=thumbv8.1m.main-none-eabi -mattr=+mve --verify-machineinstrs -o - | FileCheck %s
target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64" target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
define arm_aapcs_vfpcc <8 x i16> @test_vpt_block(<8 x i16> %v_inactive, <8 x i16> %v1, <8 x i16> %v2, <8 x i16> %v3) { define arm_aapcs_vfpcc <8 x i16> @test_vpt_block(<8 x i16> %v_inactive, <8 x i16> %v1, <8 x i16> %v2, <8 x i16> %v3) {
; CHECK-LABEL: test_vpt_block: ; CHECK-LABEL: test_vpt_block:
; CHECK: @ %bb.0: @ %entry ; CHECK: @ %bb.0: @ %entry
; CHECK-NEXT: vpt.i16 eq, q1, q2 ; CHECK-NEXT: vpt.i16 eq, q1, q2
; CHECK-NEXT: vaddt.i16 q0, q3, q2 ; CHECK-NEXT: vaddt.i16 q0, q3, q2
Show All 34 Lines

llvm/test/CodeGen/WinEH/wineh-intrinsics.ll

; RUN: opt -lint -disable-output < %s ; RUN: opt -temporarily-allow-old-pass-syntax -lint -disable-output < %s
; This test is meant to prove that the verifier does not report errors for correct ; This test is meant to prove that the verifier does not report errors for correct
; use of the llvm.eh.exceptionpointer intrinsic. ; use of the llvm.eh.exceptionpointer intrinsic.
target triple = "x86_64-pc-windows-msvc" target triple = "x86_64-pc-windows-msvc"
declare i8* @llvm.eh.exceptionpointer.p0i8(token) declare i8* @llvm.eh.exceptionpointer.p0i8(token)
declare i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token) declare i8 addrspace(1)* @llvm.eh.exceptionpointer.p1i8(token)
Show All 35 Lines

llvm/test/CodeGen/X86/GC/deadargelim.ll

; RUN: opt < %s -deadargelim ; RUN: opt -temporarily-allow-old-pass-syntax < %s -deadargelim
declare void @llvm.gcroot(ptr, ptr) declare void @llvm.gcroot(ptr, ptr)
define void @g() { define void @g() {
entry: entry:
call void @f(i32 0) call void @f(i32 0)
ret void ret void
} }
define internal void @f(i32 %unused) gc "example" { define internal void @f(i32 %unused) gc "example" {
entry: entry:
%var = alloca ptr %var = alloca ptr
call void @llvm.gcroot(ptr %var, ptr null) call void @llvm.gcroot(ptr %var, ptr null)
ret void ret void
} }

llvm/test/CodeGen/X86/GC/inline.ll

; RUN: opt < %s -inline -S | grep example ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -S | grep example
%IntArray = type { i32, [0 x ptr] } %IntArray = type { i32, [0 x ptr] }
declare void @llvm.gcroot(ptr, ptr) nounwind declare void @llvm.gcroot(ptr, ptr) nounwind
define i32 @f() { define i32 @f() {
%x = call i32 @g( ) ; <i32> [#uses=1] %x = call i32 @g( ) ; <i32> [#uses=1]
ret i32 %x ret i32 %x
} }
define internal i32 @g() gc "example" { define internal i32 @g() gc "example" {
%root = alloca ptr ; <ptr> [#uses=2] %root = alloca ptr ; <ptr> [#uses=2]
Show All 9 Lines

llvm/test/CodeGen/X86/GC/inline2.ll

; RUN: opt < %s -inline -S | grep sample ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -S | grep sample
; RUN: opt < %s -inline -S | grep example ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -S | grep example
%IntArray = type { i32, [0 x ptr] } %IntArray = type { i32, [0 x ptr] }
declare void @llvm.gcroot(ptr, ptr) nounwind declare void @llvm.gcroot(ptr, ptr) nounwind
define i32 @f() gc "sample" { define i32 @f() gc "sample" {
%x = call i32 @g( ) ; <i32> [#uses=1] %x = call i32 @g( ) ; <i32> [#uses=1]
ret i32 %x ret i32 %x
} }
define internal i32 @g() gc "example" { define internal i32 @g() gc "example" {
%root = alloca ptr ; <ptr> [#uses=2] %root = alloca ptr ; <ptr> [#uses=2]
Show All 9 Lines

llvm/test/CodeGen/X86/block-placement.ll

; RUN: llc -mtriple=i686-linux -pre-RA-sched=source < %s | FileCheck %s ; RUN: llc -mtriple=i686-linux -pre-RA-sched=source < %s | FileCheck %s
; RUN: opt -disable-output -debugify < %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -debugify < %s
declare void @error(i32 %i, i32 %a, i32 %b) declare void @error(i32 %i, i32 %a, i32 %b)
define i32 @test_ifchains(i32 %i, i32* %a, i32 %b) { define i32 @test_ifchains(i32 %i, i32* %a, i32 %b) {
; Test a chain of ifs, where the block guarded by the if is error handling code ; Test a chain of ifs, where the block guarded by the if is error handling code
; that is not expected to run. ; that is not expected to run.
; CHECK-LABEL: test_ifchains: ; CHECK-LABEL: test_ifchains:
; CHECK: %entry ; CHECK: %entry
▲ Show 20 Lines • Show All 1,592 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/constant-hoisting-bfi.ll

; RUN: opt -consthoist -mtriple=x86_64-unknown-linux-gnu -consthoist-with-block-frequency=true -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -consthoist -mtriple=x86_64-unknown-linux-gnu -consthoist-with-block-frequency=true -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"
; Check when BFI is enabled for constant hoisting, constant 214748364701 ; Check when BFI is enabled for constant hoisting, constant 214748364701
; will not be hoisted to the func entry. ; will not be hoisted to the func entry.
; CHECK-LABEL: @test1( ; CHECK-LABEL: @test1(
; CHECK: entry: ; CHECK: entry:
; CHECK-NOT: bitcast i64 214748364701 to i64 ; CHECK-NOT: bitcast i64 214748364701 to i64
▲ Show 20 Lines • Show All 150 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/deopt-intrinsic-cconv.ll

; RUN: llc < %s | FileCheck %s ; RUN: llc < %s | FileCheck %s
; RUN: llc -debug-only=stackmaps < %s 2>&1 | FileCheck --check-prefix=STACKMAPS %s ; RUN: llc -debug-only=stackmaps < %s 2>&1 | FileCheck --check-prefix=STACKMAPS %s
; RUN: opt -disable-output -debugify < %s ; RUN: opt -temporarily-allow-old-pass-syntax -disable-output -debugify < %s
; REQUIRES: asserts ; REQUIRES: asserts
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.11.0" target triple = "x86_64-apple-macosx10.11.0"
declare webkit_jscc i64 @llvm.experimental.deoptimize.i64(...) declare webkit_jscc i64 @llvm.experimental.deoptimize.i64(...)
define i64 @caller_1() { define i64 @caller_1() {
Show All 23 Lines

llvm/test/CodeGen/X86/frame-order.ll

; RUN: llc -mtriple=x86_64-linux-gnueabi -disable-debug-info-print < %s | FileCheck %s ; RUN: llc -mtriple=x86_64-linux-gnueabi -disable-debug-info-print < %s | FileCheck %s
; RUN: opt -strip -S < %s | llc -mtriple=x86_64-linux-gnueabi -disable-debug-info-print | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -strip -S < %s | llc -mtriple=x86_64-linux-gnueabi -disable-debug-info-print | FileCheck %s
; This test checks if the code is generated correctly with and without debug info. ; This test checks if the code is generated correctly with and without debug info.
; This LL file was generated by running 'clang -g -gcodeview' on the ; This LL file was generated by running 'clang -g -gcodeview' on the
; following code: ; following code:
; 1: extern "C" volatile int x; ; 1: extern "C" volatile int x;
; 2: extern "C" void capture(int *p); ; 2: extern "C" void capture(int *p);
; 3: static __forceinline inline void will_be_inlined() { ; 3: static __forceinline inline void will_be_inlined() {
▲ Show 20 Lines • Show All 112 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/loadStore_vectorizer.ll

; RUN: opt -mtriple x86_64-- -load-store-vectorizer < %s -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple x86_64-- -load-store-vectorizer < %s -S | FileCheck %s
%struct_render_pipeline_state = type opaque %struct_render_pipeline_state = type opaque
define fastcc void @test1(ptr addrspace(1) %pso) unnamed_addr { define fastcc void @test1(ptr addrspace(1) %pso) unnamed_addr {
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test1
; CHECK: load i16 ; CHECK: load i16
; CHECK: load i16 ; CHECK: load i16
entry: entry:
Show All 15 Lines

llvm/test/CodeGen/X86/masked_gather_scatter.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -mtriple=x86_64-unknown-linux-gnu -mattr=+avx512f < %s | FileCheck %s --check-prefix=ALL --check-prefix=KNL_64 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu -mattr=+avx512f < %s | FileCheck %s --check-prefix=ALL --check-prefix=KNL_64
; RUN: llc -mtriple=i386-unknown-linux-gnu -mattr=+avx512f < %s | FileCheck %s --check-prefix=ALL --check-prefix=KNL_32 ; RUN: llc -mtriple=i386-unknown-linux-gnu -mattr=+avx512f < %s | FileCheck %s --check-prefix=ALL --check-prefix=KNL_32
; RUN: llc -mtriple=x86_64-unknown-linux-gnu -mattr=+avx512vl -mattr=+avx512dq < %s | FileCheck %s --check-prefix=ALL --check-prefix=SKX --check-prefix=SKX_SMALL ; RUN: llc -mtriple=x86_64-unknown-linux-gnu -mattr=+avx512vl -mattr=+avx512dq < %s | FileCheck %s --check-prefix=ALL --check-prefix=SKX --check-prefix=SKX_SMALL
; RUN: llc -mtriple=x86_64-unknown-linux-gnu -mattr=+avx512vl -mattr=+avx512dq -code-model=large < %s | FileCheck %s --check-prefix=ALL --check-prefix=SKX --check-prefix=SKX_LARGE ; RUN: llc -mtriple=x86_64-unknown-linux-gnu -mattr=+avx512vl -mattr=+avx512dq -code-model=large < %s | FileCheck %s --check-prefix=ALL --check-prefix=SKX --check-prefix=SKX_LARGE
; RUN: llc -mtriple=i386-unknown-linux-gnu -mattr=+avx512vl -mattr=+avx512dq < %s | FileCheck %s --check-prefix=ALL --check-prefix=SKX_32 ; RUN: llc -mtriple=i386-unknown-linux-gnu -mattr=+avx512vl -mattr=+avx512dq < %s | FileCheck %s --check-prefix=ALL --check-prefix=SKX_32
; RUN: opt -mtriple=x86_64-apple-darwin -scalarize-masked-mem-intrin -mcpu=corei7-avx -S < %s | FileCheck %s -check-prefix=SCALAR ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=x86_64-apple-darwin -scalarize-masked-mem-intrin -mcpu=corei7-avx -S < %s | FileCheck %s -check-prefix=SCALAR
; RUN: opt -mtriple=x86_64-apple-darwin -passes=scalarize-masked-mem-intrin -mcpu=corei7-avx -S < %s | FileCheck %s -check-prefix=SCALAR ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=x86_64-apple-darwin -passes=scalarize-masked-mem-intrin -mcpu=corei7-avx -S < %s | FileCheck %s -check-prefix=SCALAR
; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu -mcpu=skx < %s -o /dev/null ; RUN: llc -O0 -mtriple=x86_64-unknown-linux-gnu -mcpu=skx < %s -o /dev/null
@glob_array = internal unnamed_addr constant [16 x i32] [i32 1, i32 1, i32 2, i32 3, i32 5, i32 8, i32 13, i32 21, i32 34, i32 55, i32 89, i32 144, i32 233, i32 377, i32 610, i32 987], align 16 @glob_array = internal unnamed_addr constant [16 x i32] [i32 1, i32 1, i32 2, i32 3, i32 5, i32 8, i32 13, i32 21, i32 34, i32 55, i32 89, i32 144, i32 233, i32 377, i32 610, i32 987], align 16
; SCALAR-LABEL: test1 ; SCALAR-LABEL: test1
; SCALAR: extractelement <16 x ptr> ; SCALAR: extractelement <16 x ptr>
; SCALAR-NEXT: load float ; SCALAR-NEXT: load float
; SCALAR-NEXT: insertelement <16 x float> ; SCALAR-NEXT: insertelement <16 x float>
▲ Show 20 Lines • Show All 5,231 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/no-plt-libcalls.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; Check if "RtLibUseGOT" works correctly when lib calls are simplified. ; Check if "RtLibUseGOT" works correctly when lib calls are simplified.
; RUN: opt < %s -instcombine -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -instcombine -S | FileCheck %s
@percent_s = constant [4 x i8] c"%s\0A\00" @percent_s = constant [4 x i8] c"%s\0A\00"
@hello_world = constant [13 x i8] c"hello world\0A\00" @hello_world = constant [13 x i8] c"hello world\0A\00"
declare i32 @printf(i8*, ...) declare i32 @printf(i8*, ...)
define void @printf_call() { define void @printf_call() {
; CHECK-LABEL: @printf_call( ; CHECK-LABEL: @printf_call(
; CHECK-NEXT: [[PUTS:%.*]] = call i32 @puts(i8* nonnull dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @hello_world, i64 0, i64 0)) ; CHECK-NEXT: [[PUTS:%.*]] = call i32 @puts(i8* nonnull dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @hello_world, i64 0, i64 0))
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
Show All 12 Lines

llvm/test/CodeGen/X86/pointer-vector.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=i686-linux -mcpu=corei7 | FileCheck %s ; RUN: llc < %s -mtriple=i686-linux -mcpu=corei7 | FileCheck %s
; RUN: opt -instsimplify -disable-output < %s ; RUN: opt -temporarily-allow-old-pass-syntax -instsimplify -disable-output < %s
define <8 x ptr> @SHUFF0(<4 x ptr> %ptrv) nounwind { define <8 x ptr> @SHUFF0(<4 x ptr> %ptrv) nounwind {
; CHECK-LABEL: SHUFF0: ; CHECK-LABEL: SHUFF0:
; CHECK: # %bb.0: # %entry ; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pshufd {{.*#+}} xmm2 = xmm0[2,3,1,2] ; CHECK-NEXT: pshufd {{.*#+}} xmm2 = xmm0[2,3,1,2]
; CHECK-NEXT: pshufd {{.*#+}} xmm1 = xmm0[0,1,1,1] ; CHECK-NEXT: pshufd {{.*#+}} xmm1 = xmm0[0,1,1,1]
; CHECK-NEXT: movdqa %xmm2, %xmm0 ; CHECK-NEXT: movdqa %xmm2, %xmm0
; CHECK-NEXT: retl ; CHECK-NEXT: retl
▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/pr38762.ll

; RUN: opt < %s -S -simplifycfg | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -simplifycfg | FileCheck %s
; Note: This patch is a complement to pr38763. ; Note: This patch is a complement to pr38763.
; ;
; When SimplifyCFG changes the PHI node into a select instruction, the debug ; When SimplifyCFG changes the PHI node into a select instruction, the debug
; information becomes ambiguous. It causes the debugger to display unreached ; information becomes ambiguous. It causes the debugger to display unreached
; lines and invalid variable values. ; lines and invalid variable values.
; ;
; When in the debugger, on the line "if (read1 > 3)", and we step from the ; When in the debugger, on the line "if (read1 > 3)", and we step from the
; 'if' condition, onto the addition, then back to the 'if' again, which is ; 'if' condition, onto the addition, then back to the 'if' again, which is
; misleading because that addition doesn't really "happen" (it's speculated). ; misleading because that addition doesn't really "happen" (it's speculated).
; IR generated with: ; IR generated with:
; clang -S -g -gno-column-info -O2 -emit-llvm pr38762.cpp -o pr38762.ll -mllvm -opt-bisect-limit=10 ; clang -S -g -gno-column-info -O2 -emit-llvm pr38762.cpp -o pr38762.ll -mllvm -opt-bisect-limit=10
; // pr38762.cpp ; // pr38762.cpp
; int main() { ; int main() {
; volatile int foo = 0; ; volatile int foo = 0;
; int read1 = foo; ; int read1 = foo;
; int brains = foo; ; int brains = foo;
; ;
; if (read1 > 3) { ; if (read1 > 3) {
; brains *= 2; ; brains *= 2;
; brains += 1; ; brains += 1;
; } ; }
; ;
; return brains; ; return brains;
; } ; }
; Change the debug locations associated with the PHI nodes being promoted, to ; Change the debug locations associated with the PHI nodes being promoted, to
; the debug locations from the insertion point in the dominant block. ; the debug locations from the insertion point in the dominant block.
; CHECK-LABEL: entry ; CHECK-LABEL: entry
; CHECK: %cmp = icmp sgt i32 %foo.0., 3, !dbg !14 ; CHECK: %cmp = icmp sgt i32 %foo.0., 3, !dbg !14
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/pr38763.ll

; RUN: opt < %s -S -simplifycfg | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -simplifycfg | FileCheck %s
; When SimplifyCFG changes the PHI node into a select instruction, the debug ; When SimplifyCFG changes the PHI node into a select instruction, the debug
; information becomes ambiguous. It causes the debugger to display wrong ; information becomes ambiguous. It causes the debugger to display wrong
; variable value. ; variable value.
; ;
; When in the debugger, on the line "if (read == 4)", the value of "result" ; When in the debugger, on the line "if (read == 4)", the value of "result"
; is reported as '2', where it should be zero. ; is reported as '2', where it should be zero.
; IR generated with: ; IR generated with:
; clang -S -g -O2 -emit-llvm pr38763.cpp -o pr38763.ll -mllvm -opt-bisect-limit=10 ; clang -S -g -O2 -emit-llvm pr38763.cpp -o pr38763.ll -mllvm -opt-bisect-limit=10
; // pr38763.cpp ; // pr38763.cpp
; int main() { ; int main() {
; volatile int foo = 4; ; volatile int foo = 4;
; int read = foo; ; int read = foo;
; int read1 = foo; ; int read1 = foo;
; ;
; int result = 0; ; int result = 0;
; if (read == 4) { ; if (read == 4) {
; result = read1 + 2; ; result = read1 + 2;
; } else { ; } else {
; result = read1 - 2; ; result = read1 - 2;
; } ; }
; ;
; return result; ; return result;
; } ; }
; Remove the '@llvm.dbg.value' associated with 'result' for the true/false ; Remove the '@llvm.dbg.value' associated with 'result' for the true/false
; branches, as they becomes ambiguous. ; branches, as they becomes ambiguous.
; CHECK-LABEL: entry ; CHECK-LABEL: entry
; CHECK: %cmp = icmp eq i32 %foo.0., 4, !dbg !14 ; CHECK: %cmp = icmp eq i32 %foo.0., 4, !dbg !14
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/pr39243.ll

; RUN: opt < %s -S -simplifycfg | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -S -simplifycfg | FileCheck %s
; Note: This patch fixes the regression introduced by pr38762. ; Note: This patch fixes the regression introduced by pr38762.
; ;
; When SimplifyCFG changes the PHI node into a select instruction, the debug ; When SimplifyCFG changes the PHI node into a select instruction, the debug
; information becomes ambiguous. It causes the debugger to display unreached ; information becomes ambiguous. It causes the debugger to display unreached
; lines and invalid variable values. ; lines and invalid variable values.
; ;
; When the function 'hoistAllInstructionsInto' hoist a basic block: ; When the function 'hoistAllInstructionsInto' hoist a basic block:
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

llvm/test/CodeGen/X86/tls-loads-control2.ll

; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic --tls-load-hoist=true -o - %s | FileCheck %s --check-prefix=HOIST0 ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic --tls-load-hoist=true -o - %s | FileCheck %s --check-prefix=HOIST0
; RUN: opt -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic -o - %s | FileCheck %s --check-prefix=HOIST2 ; RUN: opt -temporarily-allow-old-pass-syntax -S -mtriple=x86_64-unknown-unknown -tlshoist --relocation-model=pic -o - %s | FileCheck %s --check-prefix=HOIST2
$_ZTW5thl_x = comdat any $_ZTW5thl_x = comdat any
@thl_x = thread_local global i32 0, align 4 @thl_x = thread_local global i32 0, align 4
; Function Attrs: mustprogress uwtable ; Function Attrs: mustprogress uwtable
define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 { define i32 @_Z2f1i(i32 %c) local_unnamed_addr #0 {
entry: entry:
Show All 40 Lines

llvm/test/CodeGen/X86/vector-gep.ll

; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc < %s -mtriple=i686-linux -mcpu=corei7-avx | FileCheck %s ; RUN: llc < %s -mtriple=i686-linux -mcpu=corei7-avx | FileCheck %s
; RUN: opt -instsimplify -disable-output < %s ; RUN: opt -temporarily-allow-old-pass-syntax -instsimplify -disable-output < %s
define <4 x ptr> @AGEP0(ptr %ptr) nounwind { define <4 x ptr> @AGEP0(ptr %ptr) nounwind {
; CHECK-LABEL: AGEP0: ; CHECK-LABEL: AGEP0:
; CHECK: # %bb.0: ; CHECK: # %bb.0:
; CHECK-NEXT: vbroadcastss {{[0-9]+}}(%esp), %xmm0 ; CHECK-NEXT: vbroadcastss {{[0-9]+}}(%esp), %xmm0
; CHECK-NEXT: vpaddd {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0, %xmm0 ; CHECK-NEXT: vpaddd {{\.?LCPI[0-9]+_[0-9]+}}, %xmm0, %xmm0
; CHECK-NEXT: retl ; CHECK-NEXT: retl
%vecinit.i = insertelement <4 x ptr> undef, ptr %ptr, i32 0 %vecinit.i = insertelement <4 x ptr> undef, ptr %ptr, i32 0
▲ Show 20 Lines • Show All 202 Lines • Show Last 20 Lines

llvm/test/DebugInfo/AArch64/ir-outliner.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
; RUN: opt -verify -iroutliner -ir-outlining-no-cost < %s | \ ; RUN: opt -temporarily-allow-old-pass-syntax -verify -iroutliner -ir-outlining-no-cost < %s | \
; RUN: llc -filetype=obj -mtriple=aarch64-- | llvm-dwarfdump - | FileCheck %s ; RUN: llc -filetype=obj -mtriple=aarch64-- | llvm-dwarfdump - | FileCheck %s
; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck -check-prefix=IRDEBUG %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck -check-prefix=IRDEBUG %s
; Ensure that the IR Outliner produces valid DWARF debug information when ; Ensure that the IR Outliner produces valid DWARF debug information when
; creating outlined functions. ; creating outlined functions.
; CHECK: DW_TAG_compile_unit ; CHECK: DW_TAG_compile_unit
; CHECK-DAG: DW_AT_name ("outline_debug1") ; CHECK-DAG: DW_AT_name ("outline_debug1")
; Check the high address of bar. This is one past the end of bar. It should be ; Check the high address of bar. This is one past the end of bar. It should be
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

llvm/test/DebugInfo/ARM/lowerbdgdeclare_vla.ll

; RUN: opt -instcombine %s -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine %s -S | FileCheck %s
; ;
; Generate me from: ; Generate me from:
; clang -cc1 -triple thumbv7-apple-ios7.0.0 -S -target-abi apcs-gnu -gdwarf-2 -Os test.c -o test.ll -emit-llvm ; clang -cc1 -triple thumbv7-apple-ios7.0.0 -S -target-abi apcs-gnu -gdwarf-2 -Os test.c -o test.ll -emit-llvm
; void run(float r) ; void run(float r)
; { ; {
; int count = r; ; int count = r;
; float vla[count]; ; float vla[count];
; vla[0] = r; ; vla[0] = r;
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/2010-03-19-DbgDeclare.ll

; RUN: opt < %s -verify -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -verify -S | FileCheck %s
; CHECK: DW_LANG_Mips_Assembler ; CHECK: DW_LANG_Mips_Assembler
define void @Foo(i32 %a, i32 %b) { define void @Foo(i32 %a, i32 %b) {
entry: entry:
call void @llvm.dbg.declare(metadata ptr null, metadata !1, metadata !DIExpression()), !dbg !DILocation(scope: !6) call void @llvm.dbg.declare(metadata ptr null, metadata !1, metadata !DIExpression()), !dbg !DILocation(scope: !6)
ret void ret void
} }
Show All 11 Lines

llvm/test/DebugInfo/Generic/PR37395.ll

; RUN: opt -lcssa -S %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -lcssa -S %s | FileCheck %s
source_filename = "small.c" source_filename = "small.c"
@a = common dso_local global i32 0, align 4, !dbg !0 @a = common dso_local global i32 0, align 4, !dbg !0
; CHECK-LABEL: @f ; CHECK-LABEL: @f
define dso_local void @f() !dbg !10 { define dso_local void @f() !dbg !10 {
entry: entry:
%0 = load i32, ptr @a, align 4, !dbg !17 %0 = load i32, ptr @a, align 4, !dbg !17
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/dse/dse-after-memcpyopt-merge.ll

; RUN: opt %s -S -dse -o - -experimental-assignment-tracking | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -S -dse -o - -experimental-assignment-tracking | FileCheck %s
;; Observed in the wild, but test is created by running memcpyopt on ;; Observed in the wild, but test is created by running memcpyopt -temporarily-allow-old-pass-syntax on
;; assignment-tracking/memcpyopt/merge-stores.ll then manually inserting ;; assignment-tracking/memcpyopt/merge-stores.ll then manually inserting
;; two stores that overwrite each end of the memset. ;; two stores that overwrite each end of the memset.
;; ;;
;; A memory intrinsic (or vector instruction) might have multiple dbg.assigns ;; A memory intrinsic (or vector instruction) might have multiple dbg.assigns
;; linked to it if it has been created as a result of merging scalar stores, ;; linked to it if it has been created as a result of merging scalar stores,
;; such as in this example. DSE is going to shorten the memset because there's ;; such as in this example. DSE is going to shorten the memset because there's
;; a later store that overwrites part of it. Insert a linked dbg.assign after ;; a later store that overwrites part of it. Insert a linked dbg.assign after
;; each overlapping fragment to undef the dead part's memory location without ;; each overlapping fragment to undef the dead part's memory location without
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/dse/shorten.ll

; RUN: opt %s -S -dse -o - -experimental-assignment-tracking | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -S -dse -o - -experimental-assignment-tracking | FileCheck %s
;; $ cat test.cpp ;; $ cat test.cpp
;; void esc(int*); ;; void esc(int*);
;; void shortenEnd() { ;; void shortenEnd() {
;; int local[20]; ;; int local[20];
;; __builtin_memset(local, 0, 6 * 4); ;; __builtin_memset(local, 0, 6 * 4);
;; __builtin_memset(local + 4, 8, 10 * 4); ;; __builtin_memset(local + 4, 8, 10 * 4);
;; esc(local); ;; esc(local);
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/licm/merge.ll

; RUN: opt -licm %s -S -experimental-assignment-tracking | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -licm %s -S -experimental-assignment-tracking | FileCheck %s
;; Ensure that we correctly merge the DIAssignID's from the sunk stores, add it ;; Ensure that we correctly merge the DIAssignID's from the sunk stores, add it
;; to the new new store instruction, and update the dbg.assign intrinsics using ;; to the new new store instruction, and update the dbg.assign intrinsics using
;; them to use it instead. ;; them to use it instead.
;; Generated from the following, with some changes to the IR by hand: ;; Generated from the following, with some changes to the IR by hand:
;; $ cat test.c ;; $ cat test.c
;; void b(int c) { ;; void b(int c) {
;; esc(&c); ;; esc(&c);
;; for (; c; c++) // NOTE: I've added another store to c in the loop by hand. ;; for (; c; c++) // NOTE: I've added another store to c in the loop by hand.
;; ; ;; ;
;; } ;; }
;; $ clang -O2 -Xclang -disable-llvm-passes -g -emit-llvm -S -o a.ll ;; $ clang -O2 -Xclang -disable-llvm-passes -g -emit-llvm -S -o a.ll
;; $ opt -passes=declare-to-assign,sroa,instcombine,simplifycfg,loop-simplify,lcssa,loop-rotate a.ll ;; $ opt -temporarily-allow-old-pass-syntax -passes=declare-to-assign,sroa,instcombine,simplifycfg,loop-simplify,lcssa,loop-rotate a.ll
; CHECK-LABEL: for.inc: ; CHECK-LABEL: for.inc:
;; Check that the stores have actually been removed from this block, otherwise ;; Check that the stores have actually been removed from this block, otherwise
;; this test is useless. ;; this test is useless.
; CHECK-NOT: store i32 %inc, ptr %c.addr ; CHECK-NOT: store i32 %inc, ptr %c.addr
;; Check that the two dbg.assigns now have the same (merged) !DIAssingID ID. ;; Check that the two dbg.assigns now have the same (merged) !DIAssingID ID.
; CHECK: call void @llvm.dbg.assign(metadata i32 %inc, metadata ![[VAR_C:[0-9]+]], metadata !DIExpression(), metadata ![[ID:[0-9]+]], metadata ptr %c.addr, metadata !DIExpression()), !dbg ; CHECK: call void @llvm.dbg.assign(metadata i32 %inc, metadata ![[VAR_C:[0-9]+]], metadata !DIExpression(), metadata ![[ID:[0-9]+]], metadata ptr %c.addr, metadata !DIExpression()), !dbg
; CHECK-NOT: store i32 %inc, ptr %c.addr ; CHECK-NOT: store i32 %inc, ptr %c.addr
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/licm/multi-exit.ll

; RUN: opt %s -S -licm -o - -experimental-assignment-tracking | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -S -licm -o - -experimental-assignment-tracking | FileCheck %s
;; $ cat test.c ;; $ cat test.c
;; int b, c, d; ;; int b, c, d;
;; void e(); ;; void e();
;; void f(int *g) { *g = b; } ;; void f(int *g) { *g = b; }
;; void i() { ;; void i() {
;; int h, a; ;; int h, a;
;; for (;;) { ;; for (;;) {
▲ Show 20 Lines • Show All 171 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/memcpyopt/merge-stores.ll

; RUN: opt %s -S -memcpyopt -o - -experimental-assignment-tracking | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -S -memcpyopt -temporarily-allow-old-pass-syntax -o - -experimental-assignment-tracking | FileCheck %s
;; $ cat test.cpp ;; $ cat test.cpp
;; struct v { ;; struct v {
;; float c[4]; ;; float c[4];
;; ;;
;; v(float d) { ;; v(float d) {
;; c[0] = c[1] = c[2] = d; ;; c[0] = c[1] = c[2] = d;
;; c[3] = 0.f; ;; c[3] = 0.f;
;; } ;; }
;; }; ;; };
;; ;;
;; void esc(v*); ;; void esc(v*);
;; ;;
;; v f() { ;; v f() {
;; v g(0); ;; v g(0);
;; esc(&g); ;; esc(&g);
;; } ;; }
;; IR grabbed before memcpyopt in: ;; IR grabbed before memcpyopt -temporarily-allow-old-pass-syntax in:
;; clang++ -Xclang -fexperimental-assignment-tracking -g -c -O2 test.cpp ;; clang++ -Xclang -fexperimental-assignment-tracking -g -c -O2 test.cpp
;; Check that the memset that memcpyopt creates to merge 4 stores merges the ;; Check that the memset that memcpyopt -temporarily-allow-old-pass-syntax creates to merge 4 stores merges the
;; DIASsignIDs from the stores. ;; DIASsignIDs from the stores.
; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata ![[ID:[0-9]+]], metadata ptr %arrayidx.i, metadata !DIExpression()) ; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_fragment, 64, 32), metadata ![[ID:[0-9]+]], metadata ptr %arrayidx.i, metadata !DIExpression())
; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32), metadata ![[ID]], metadata ptr %arrayidx3.i, metadata !DIExpression()) ; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 32, 32), metadata ![[ID]], metadata ptr %arrayidx3.i, metadata !DIExpression())
; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32), metadata ![[ID]], metadata ptr %arrayidx5.i, metadata !DIExpression()) ; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 0, 32), metadata ![[ID]], metadata ptr %arrayidx5.i, metadata !DIExpression())
; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 96, 32), metadata ![[ID]], metadata ptr %arrayidx7.i, metadata !DIExpression()) ; CHECK: call void @llvm.dbg.assign(metadata float 0.000000e+00, metadata ![[VAR]], metadata !DIExpression(DW_OP_LLVM_fragment, 96, 32), metadata ![[ID]], metadata ptr %arrayidx7.i, metadata !DIExpression())
; CHECK: call void @llvm.memset{{.*}}, !DIAssignID ![[ID]] ; CHECK: call void @llvm.memset{{.*}}, !DIAssignID ![[ID]]
▲ Show 20 Lines • Show All 129 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/parse-and-verify/instruction-type.ll

; RUN: opt -S %s -verify -experimental-assignment-tracking 2>&1 \ ; RUN: opt -temporarily-allow-old-pass-syntax -S %s -verify -experimental-assignment-tracking 2>&1 \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
;; NOTE: Expect opt to return zero because the badly formed debug info ;; NOTE: Expect opt -temporarily-allow-old-pass-syntax to return zero because the badly formed debug info
;; is going to be stripped. ;; is going to be stripped.
;; Check that badly formed assignment tracking metadata is caught either ;; Check that badly formed assignment tracking metadata is caught either
;; while parsing or by the verifier. ;; while parsing or by the verifier.
;; Check verifier output. ;; Check verifier output.
; CHECK: !DIAssignID attached to unexpected instruction kind ; CHECK: !DIAssignID attached to unexpected instruction kind
Show All 24 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/parse-and-verify/roundtrip.ll

; RUN: opt %s -verify -experimental-assignment-tracking \ ; RUN: opt -temporarily-allow-old-pass-syntax %s -verify -experimental-assignment-tracking \
; RUN: | opt -verify -S -experimental-assignment-tracking \ ; RUN: | opt -temporarily-allow-old-pass-syntax -verify -S -experimental-assignment-tracking \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
;; Roundtrip test (text -> bitcode -> text) for DIAssignID metadata and ;; Roundtrip test (text -> bitcode -> text) for DIAssignID metadata and
;; llvm.dbg.assign intrinsics. ;; llvm.dbg.assign intrinsics.
;; DIAssignID attachment only. ;; DIAssignID attachment only.
; CHECK-LABEL: @fun() ; CHECK-LABEL: @fun()
; CHECK: %local = alloca i32, align 4, !DIAssignID ![[ID1:[0-9]+]] ; CHECK: %local = alloca i32, align 4, !DIAssignID ![[ID1:[0-9]+]]
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/assignment-tracking/parse-and-verify/verify.ll

; RUN: opt %s -S -verify -experimental-assignment-tracking 2>&1 \ ; RUN: opt -temporarily-allow-old-pass-syntax %s -S -verify -experimental-assignment-tracking 2>&1 \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
;; Check that badly formed assignment tracking metadata is caught either ;; Check that badly formed assignment tracking metadata is caught either
;; while parsing or by the verifier. ;; while parsing or by the verifier.
;; ;;
;; Checks for this one are inline. ;; Checks for this one are inline.
define dso_local void @fun2() !dbg !15 { define dso_local void @fun2() !dbg !15 {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/callsite-attr-invalid.ll

; RUN: opt -verify < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify < %s 2>&1 | FileCheck %s
; CHECK: DIFlagAllCallsDescribed must be attached to a definition ; CHECK: DIFlagAllCallsDescribed must be attached to a definition
; CHECK: warning: ignoring invalid debug info ; CHECK: warning: ignoring invalid debug info
; Source: ; Source:
; struct A { ~A(); }; ; struct A { ~A(); };
; void foo() { A x; } ; void foo() { A x; }
Show All 39 Lines

llvm/test/DebugInfo/Generic/debug-info-always-inline.ll

; RUN: opt < %s -always-inline -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -always-inline -S | FileCheck %s
; ;
; Generated from the following C++ source with: ; Generated from the following C++ source with:
; clang -cc1 -disable-llvm-optzns -emit-llvm -g -stack-protector 2 test.cpp ; clang -cc1 -disable-llvm-optzns -emit-llvm -g -stack-protector 2 test.cpp
; ;
; /* BEGIN SOURCE */ ; /* BEGIN SOURCE */
; int __attribute__((always_inline)) foo() ; int __attribute__((always_inline)) foo()
; { ; {
; int arr[10]; ; int arr[10];
; arr[0] = 5; ; arr[0] = 5;
; int sum = 4; ; int sum = 4;
; return sum; ; return sum;
; } ; }
; ;
; extern void bar(); ; extern void bar();
; ;
; int main() ; int main()
; { ; {
; bar(); ; bar();
; int i = foo(); ; int i = foo();
; return i; ; return i;
; } ; }
; /* END SOURCE */ ; /* END SOURCE */
; The patch that includes this test case, is addressing the following issue: ; The patch that includes this test case, is addressing the following issue:
; ;
; When functions are inlined, instructions without debug information ; When functions are inlined, instructions without debug information
; are attributed with the call site's DebugLoc. After inlining, inlined static ; are attributed with the call site's DebugLoc. After inlining, inlined static
; allocas are moved to the caller's entry block, adjacent to the caller's original ; allocas are moved to the caller's entry block, adjacent to the caller's original
; static alloca instructions. By retaining the call site's DebugLoc, these instructions ; static alloca instructions. By retaining the call site's DebugLoc, these instructions
; may cause instructions that are subsequently inserted at the entry block to pick ; may cause instructions that are subsequently inserted at the entry block to pick
; up the same DebugLoc. ; up the same DebugLoc.
; ;
; In the offending case stack protection inserts an instruction at the caller's ; In the offending case stack protection inserts an instruction at the caller's
; entry block, which inadvertently picks up the inlined call's DebugLoc, because ; entry block, which inadvertently picks up the inlined call's DebugLoc, because
; the entry block's first instruction is the recently moved inlined alloca instruction. ; the entry block's first instruction is the recently moved inlined alloca instruction.
; ;
; The stack protection instruction then becomes part of the function prologue, with the ; The stack protection instruction then becomes part of the function prologue, with the
; result that the line number that is associated with the stack protection instruction ; result that the line number that is associated with the stack protection instruction
; is deemed to be the end of the function prologue. Since this line number is the ; is deemed to be the end of the function prologue. Since this line number is the
; call site's line number, setting a breakpoint at the function in the debugger ; call site's line number, setting a breakpoint at the function in the debugger
; will make the user stop at the line of the inlined call. ; will make the user stop at the line of the inlined call.
; Note that without the stack protection instruction this effect would not occur ; Note that without the stack protection instruction this effect would not occur
; because the allocas all get collapsed into a single instruction that reserves ; because the allocas all get collapsed into a single instruction that reserves
; stack space and have no further influence on the prologue's line number information. ; stack space and have no further influence on the prologue's line number information.
; The selected solution is to not attribute static allocas with the call site's ; The selected solution is to not attribute static allocas with the call site's
; DebugLoc. ; DebugLoc.
; At some point in the future, it may be desirable to describe the inlining ; At some point in the future, it may be desirable to describe the inlining
; in the alloca instructions, but then the code that handles prologues must ; in the alloca instructions, but then the code that handles prologues must
; be able to handle this correctly, including the late insertion of instructions ; be able to handle this correctly, including the late insertion of instructions
; into it. ; into it.
; In this context it is also important to distingush between functions ; In this context it is also important to distingush between functions
; with the "nodebug" attribute and those without it. Alloca instructions from ; with the "nodebug" attribute and those without it. Alloca instructions from
; nodebug functions should continue to have no DebugLoc, whereas those from ; nodebug functions should continue to have no DebugLoc, whereas those from
; non-nodebug functions (i.e. functions with debug information) may want to ; non-nodebug functions (i.e. functions with debug information) may want to
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/debug_value_list.ll

; RUN: opt -verify < %s | opt -verify -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify < %s | opt -temporarily-allow-old-pass-syntax -verify -S | FileCheck %s
; Simple IR-BC-IR round-trip test for a @llvm.dbg.value that uses !DIArgList ; Simple IR-BC-IR round-trip test for a @llvm.dbg.value that uses !DIArgList
; and DW_OP_LLVM_arg. ; and DW_OP_LLVM_arg.
source_filename = ".\\debug_value_list.cpp" source_filename = ".\\debug_value_list.cpp"
target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.16.27034" target triple = "x86_64-pc-windows-msvc19.16.27034"
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/global-sra-array.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
source_filename = "test.c" source_filename = "test.c"
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"
%struct.mystruct = type { i32, i64 } %struct.mystruct = type { i32, i64 }
; Generated at -Os from: ; Generated at -Os from:
; ;
; static struct { int a; char b; } array[2]; ; static struct { int a; char b; } array[2];
▲ Show 20 Lines • Show All 118 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/global-sra-single-member.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
; struct { ; struct {
; int f0; ; int f0;
; } static a; ; } static a;
; int main() { ; int main() {
; a.f0++; ; a.f0++;
; return 0; ; return 0;
; } ; }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/global-sra-struct-fwd-decl.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
; Generated at -O2 -g from: ; Generated at -O2 -g from:
; typedef struct {} a; ; typedef struct {} a;
; static struct { ; static struct {
; long b; ; long b;
; a c; ; a c;
; } d; ; } d;
; e() { ; e() {
; long f = d.b + 1; ; long f = d.b + 1;
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/global-sra-struct-zero-length.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
; Generated at -O2 -g from: ; Generated at -O2 -g from:
; typedef struct { ; typedef struct {
; } a; ; } a;
; static struct { ; static struct {
; long b; ; long b;
; a c; ; a c;
; } d; ; } d;
; e() { ; e() {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/global-sra-struct.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
source_filename = "test.c" source_filename = "test.c"
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"
%struct.mystruct = type { i32, i64 } %struct.mystruct = type { i32, i64 }
; Generated at -Os from: ; Generated at -Os from:
; ;
; static struct mystruct { ; static struct mystruct {
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/indvar-discriminator.ll

; RUN: opt -indvars -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -indvars -S < %s | FileCheck %s
; ;
; When the induction variable is widened by indvars, check that the debug loc ; When the induction variable is widened by indvars, check that the debug loc
; associated with the loop increment is correctly propagated. ; associated with the loop increment is correctly propagated.
; Also, when the exit condition of a loop is rewritten to be a canonical != ; Also, when the exit condition of a loop is rewritten to be a canonical !=
; comparison, check that the debug loc of the orginal comparison is reused. ; comparison, check that the debug loc of the orginal comparison is reused.
; ;
; Test case obtained from the following source code: ; Test case obtained from the following source code:
; ;
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/inline-debug-info-multiret.ll

; RUN: opt -inline -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -inline -S < %s | FileCheck %s
; ;
; A hand-edited version of inline-debug-info.ll to test inlining of a ; A hand-edited version of inline-debug-info.ll to test inlining of a
; function with multiple returns. ; function with multiple returns.
; ;
; Make sure the branch instructions created during inlining has a debug location, ; Make sure the branch instructions created during inlining has a debug location,
; so the range of the inlined function is correct. ; so the range of the inlined function is correct.
; CHECK: br label %_Z4testi.exit, !dbg ![[MD:[0-9]+]] ; CHECK: br label %_Z4testi.exit, !dbg ![[MD:[0-9]+]]
; CHECK: br label %_Z4testi.exit, !dbg ![[MD]] ; CHECK: br label %_Z4testi.exit, !dbg ![[MD]]
▲ Show 20 Lines • Show All 146 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/inline-debug-info.ll

; RUN: opt -inline -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -inline -S < %s | FileCheck %s
; Created from source ; Created from source
; ;
; ;
; 1 // test.cpp ; 1 // test.cpp
; 2 extern int global_var; ; 2 extern int global_var;
; 3 extern int test_ext(int k); ; 3 extern int test_ext(int k);
; 4 int test (int k) { ; 4 int test (int k) {
▲ Show 20 Lines • Show All 164 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/inline-debug-loc.ll

; RUN: opt -inline -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -inline -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"
; Function @bar contains instruction %cmp which is not associated to any debug ; Function @bar contains instruction %cmp which is not associated to any debug
; location. This test verifies that the inliner doesn't incorrectly attribute ; location. This test verifies that the inliner doesn't incorrectly attribute
; the callsite debug location to %cmp. ; the callsite debug location to %cmp.
define i32 @bar(i32 %a, i32 %b) #0 !dbg !6 { define i32 @bar(i32 %a, i32 %b) #0 !dbg !6 {
Show All 38 Lines

llvm/test/DebugInfo/Generic/inline-no-debug-info.ll

; RUN: opt < %s -inline -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -S | FileCheck %s
; This was generated from the following source: ; This was generated from the following source:
; int a, b; ; int a, b;
; __attribute__((__always_inline__)) static void callee2() { b = 2; } ; __attribute__((__always_inline__)) static void callee2() { b = 2; }
; __attribute__((__nodebug__)) void callee() { a = 1; callee2(); } ; __attribute__((__nodebug__)) void callee() { a = 1; callee2(); }
; void caller() { callee(); } ; void caller() { callee(); }
; by running ; by running
; clang -S test.c -emit-llvm -O1 -gline-tables-only -fno-strict-aliasing ; clang -S test.c -emit-llvm -O1 -gline-tables-only -fno-strict-aliasing
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/licm-hoist-debug-loc.ll

; RUN: opt -S -licm %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -licm %s | FileCheck %s
; ;
; LICM should null out debug locations when it hoists instructions out of a loop. ; LICM should null out debug locations when it hoists instructions out of a loop.
; ;
; Generated with ; Generated with
; clang -O0 -S -emit-llvm test.cpp -g -gline-tables-only -o t.ll ; clang -O0 -S -emit-llvm test.cpp -g -gline-tables-only -o t.ll
; opt -S -sroa -adce -simplifycfg -reassociate -domtree -loops \ ; opt -temporarily-allow-old-pass-syntax -S -sroa -adce -simplifycfg -reassociate -domtree -loops \
; -loop-simplify -lcssa -aa -scalar-evolution -loop-rotate t.ll > test.ll ; -loop-simplify -lcssa -aa -scalar-evolution -loop-rotate t.ll > test.ll
; ;
; void bar(int *); ; void bar(int *);
; void foo(int k, int p) ; void foo(int k, int p)
; { ; {
; for (int i = 0; i < k; i++) { ; for (int i = 0; i < k; i++) {
; bar(&p + 4); ; bar(&p + 4);
; } ; }
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/licm-hoist-intrinsic-debug-loc.ll

; RUN: opt -S -licm %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -licm %s | FileCheck %s
; ;
; LICM should null out debug locations when it hoists intrinsics that won't lower to function calls out of a loop. ; LICM should null out debug locations when it hoists intrinsics that won't lower to function calls out of a loop.
; CHECK: define float @foo ; CHECK: define float @foo
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: call float @llvm.fma.f32(float %coef_0, float %coef_1, float 0.000000e+00){{$}} ; CHECK-NEXT: call float @llvm.fma.f32(float %coef_0, float %coef_1, float 0.000000e+00){{$}}
; CHECK-NEXT: br label %loop.header ; CHECK-NEXT: br label %loop.header
; ;
define float @foo(float* %A, float %coef_0, float %coef_1, i32 %n) !dbg !2 { define float @foo(float* %A, float %coef_0, float %coef_1, i32 %n) !dbg !2 {
Show All 28 Lines
!llvm.module.flags = !{!6} !llvm.module.flags = !{!6}
!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14", isOptimized: false, runtimeVersion: 0, emissionKind: LineTablesOnly, splitDebugInlining: false, nameTableKind: None) !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14", isOptimized: false, runtimeVersion: 0, emissionKind: LineTablesOnly, splitDebugInlining: false, nameTableKind: None)
!1 = !DIFile(filename: "source.c", directory: "/") !1 = !DIFile(filename: "source.c", directory: "/")
!2 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !4, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !5) !2 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !4, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !5)
!3 = !DILocation(line: 4, column: 17, scope: !2) !3 = !DILocation(line: 4, column: 17, scope: !2)
!4 = !DISubroutineType(types: !5) !4 = !DISubroutineType(types: !5)
!5 = !{} !5 = !{}
!6 = !{i32 2, !"Debug Info Version", i32 3} !6 = !{i32 2, !"Debug Info Version", i32 3}
No newline at end of file

llvm/test/DebugInfo/Generic/simplifycfg_sink_last_inst.ll

; RUN: opt -simplifycfg -sink-common-insts -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -simplifycfg -sink-common-insts -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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
; Simplify CFG will try to sink the last instruction in a series of basic ; Simplify CFG will try to sink the last instruction in a series of basic
; blocks, creating a "common" instruction in the successor block. If the ; blocks, creating a "common" instruction in the successor block. If the
; debug locations of the commoned instructions have different file/line ; debug locations of the commoned instructions have different file/line
; numbers the debug location of the common instruction should be a merged ; numbers the debug location of the common instruction should be a merged
; location. ; location.
; Generated from source: ; Generated from source:
; extern int foo(void); ; extern int foo(void);
; extern int bar(void); ; extern int bar(void);
; ;
; int test(int a, int b) { ; int test(int a, int b) {
; if(a) ; if(a)
; b -= foo(); ; b -= foo();
; else ; else
; b -= bar(); ; b -= bar();
; return b; ; return b;
; } ; }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/DebugInfo/Generic/volatile-alloca.ll

; RUN: opt -mem2reg -instcombine %s -o - -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -mem2reg -instcombine %s -o - -S | FileCheck %s
; ;
; Test that a dbg.declare describing am alloca with volatile ; Test that a dbg.declare describing am alloca with volatile
; load/stores is not lowered into a dbg.value, since the alloca won't ; load/stores is not lowered into a dbg.value, since the alloca won't
; be elided anyway. ; be elided anyway.
; ;
; Generated from: ; Generated from:
; ;
; unsigned long long g(); ; unsigned long long g();
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/clone-module-2.ll

; RUN: opt -run-twice -verify -S -o - %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -run-twice -verify -S -o - %s | FileCheck %s
; If a module contains a DISubprogram referenced only indirectly from ; If a module contains a DISubprogram referenced only indirectly from
; instruction-level debug info metadata, but not attached to any Function ; instruction-level debug info metadata, but not attached to any Function
; defined within the module, cloning such a module with CloneModule was ; defined within the module, cloning such a module with CloneModule was
; causing a DICompileUnit duplication: it would be moved in indirecty via a ; causing a DICompileUnit duplication: it would be moved in indirecty via a
; DISubprogram by DebugInfoFinder (making sure DISubprogram's don't get ; DISubprogram by DebugInfoFinder (making sure DISubprogram's don't get
; duplicated) first without being explicitly self-mapped within the ValueMap ; duplicated) first without being explicitly self-mapped within the ValueMap
; shared among CloneFunctionInto calls, and then it would get copied during ; shared among CloneFunctionInto calls, and then it would get copied during
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/clone-module.ll

; RUN: opt -run-twice -verify -S -o - %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -run-twice -verify -S -o - %s | FileCheck %s
; The ValueMap shared between CloneFunctionInto calls within CloneModule needs ; The ValueMap shared between CloneFunctionInto calls within CloneModule needs
; to contain identity mappings for all of the DISubprogram's to prevent them ; to contain identity mappings for all of the DISubprogram's to prevent them
; from being duplicated by MapMetadata / RemapInstruction calls, this is ; from being duplicated by MapMetadata / RemapInstruction calls, this is
; achieved via DebugInfoFinder collecting all the DISubprogram's. However, ; achieved via DebugInfoFinder collecting all the DISubprogram's. However,
; CloneFunctionInto was missing calls into DebugInfoFinder for functions w/o ; CloneFunctionInto was missing calls into DebugInfoFinder for functions w/o
; DISubprogram's attached, but still referring DISubprogram's from within. ; DISubprogram's attached, but still referring DISubprogram's from within.
; ;
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/dbg-value-dropped-instcombine.ll

; RUN: opt -instcombine -S %s -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S %s -o - | FileCheck %s
; In pr40648 one of two dbg.values used to describe the variable bumble was ; In pr40648 one of two dbg.values used to describe the variable bumble was
; being dropped by instcombine. Test that both dbg.values survive instcombine. ; being dropped by instcombine. Test that both dbg.values survive instcombine.
; $ clang -O0 -Xclang -disable-O0-optnone -g bees.c -emit-llvm -S -o - \ ; $ clang -O0 -Xclang -disable-O0-optnone -g bees.c -emit-llvm -S -o - \
; | opt -opt-bisect-limit=10 -O2 -o - ; | opt -temporarily-allow-old-pass-syntax -opt-bisect-limit=10 -O2 -o -
; $ cat bees.c ; $ cat bees.c
; struct bees { ; struct bees {
; int a; ; int a;
; int b; ; int b;
; } ; }
; int global = 0; ; int global = 0;
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/dbgloc-insert-extract-val-instrs.ll

;; Check that every instruction inserted by -deadargelim has a debug location. ;; Check that every instruction inserted by -deadargelim has a debug location.
;; The test was generated by using -debugify option. ;; The test was generated by using -debugify option.
; RUN: opt < %s -deadargelim -S 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -deadargelim -S 2>&1 | FileCheck %s
; CHECK-LABEL: fn ; CHECK-LABEL: fn
; CHECK: %oldret = extractvalue { i32, i32, i16 } %z, 0, !dbg ![[LOC:.*]] ; CHECK: %oldret = extractvalue { i32, i32, i16 } %z, 0, !dbg ![[LOC:.*]]
; CHECK: %newret = insertvalue { i32, i32 } poison, i32 %oldret, 0, !dbg ![[LOC:.*]] ; CHECK: %newret = insertvalue { i32, i32 } poison, i32 %oldret, 0, !dbg ![[LOC:.*]]
; CHECK: %oldret1 = extractvalue { i32, i32, i16 } %z, 1, !dbg ![[LOC:.*]] ; CHECK: %oldret1 = extractvalue { i32, i32, i16 } %z, 1, !dbg ![[LOC:.*]]
; CHECK: %newret2 = insertvalue { i32, i32 } %newret, i32 %oldret1, 1, !dbg ![[LOC:.*]] ; CHECK: %newret2 = insertvalue { i32, i32 } %newret, i32 %oldret1, 1, !dbg ![[LOC:.*]]
; CHECK-LABEL: fn1 ; CHECK-LABEL: fn1
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/dead-store-elimination-marks-undef.ll

; RUN: opt -mtriple=x86_64-- -S --dse %s -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=x86_64-- -S --dse %s -o - | FileCheck %s
; Ensure that we can mark a value as undefined when performing dead ; Ensure that we can mark a value as undefined when performing dead
; store elimination. ; store elimination.
; Bugzilla #45080 ; Bugzilla #45080
@b = common dso_local local_unnamed_addr global i32 0, align 1 @b = common dso_local local_unnamed_addr global i32 0, align 1
define dso_local i32 @main() local_unnamed_addr !dbg !7 { define dso_local i32 @main() local_unnamed_addr !dbg !7 {
%1 = alloca i32, align 4 %1 = alloca i32, align 4
%2 = load i32, i32* @b, align 1, !dbg !13 %2 = load i32, i32* @b, align 1, !dbg !13
Show All 26 Lines

llvm/test/DebugInfo/X86/global-sra-fp80-array.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
source_filename = "array.c" source_filename = "array.c"
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.mystruct = type { i32, i64 } %struct.mystruct = type { i32, i64 }
; Generated from: ; Generated from:
; ;
▲ Show 20 Lines • Show All 120 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/global-sra-fp80-struct.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
source_filename = "struct.c" source_filename = "struct.c"
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%struct.mystruct = type { x86_fp80, i32, [12 x i8] } %struct.mystruct = type { x86_fp80, i32, [12 x i8] }
; Generated from: ; Generated from:
; ;
▲ Show 20 Lines • Show All 125 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/global-sra-struct-fit-segment.ll

; RUN: opt -S -globalopt < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck %s
;; Generated at -g from: ;; Generated at -g from:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;subroutine sub(inode,node) ;;subroutine sub(inode,node)
;; implicit none ;; implicit none
;; integer nodea,nodeb,jmax,inode,node ;; integer nodea,nodeb,jmax,inode,node
;; save nodea,nodeb,jmax ;; save nodea,nodeb,jmax
;; if(inode.eq.1) then ;; if(inode.eq.1) then
▲ Show 20 Lines • Show All 124 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/instcombine-demanded-bits-salvage.ll

; RUN: opt -mtriple=x86_64-- %s -S --instcombine -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=x86_64-- %s -S --instcombine -o - | FileCheck %s
; Verify that demanded bits optimisations don't affect debuginfo ; Verify that demanded bits optimisations don't affect debuginfo
; variable values. ; variable values.
; Bugzilla #44371 ; Bugzilla #44371
@a = common dso_local local_unnamed_addr global i32 0, align 4 @a = common dso_local local_unnamed_addr global i32 0, align 4
define dso_local i32 @p() local_unnamed_addr !dbg !11 { define dso_local i32 @p() local_unnamed_addr !dbg !11 {
entry: entry:
%conv = load i32, i32* @a, align 4, !dbg !14 %conv = load i32, i32* @a, align 4, !dbg !14
Show All 28 Lines

llvm/test/DebugInfo/X86/licm-undef-dbg-value.ll

; RUN: opt -licm %s -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -licm %s -S | FileCheck %s
; CHECK: for.body: ; CHECK: for.body:
; CHECK-NEXT: llvm.dbg.value(metadata i8 undef ; CHECK-NEXT: llvm.dbg.value(metadata i8 undef
; The load is loop invariant. Check that we leave an undef dbg.value behind ; The load is loop invariant. Check that we leave an undef dbg.value behind
; when licm sinks the instruction. ; when licm sinks the instruction.
; clang reduce.cpp -g -O2 -Xclang -disable-llvm-passes -emit-llvm -o reduce.ll ; clang reduce.cpp -g -O2 -Xclang -disable-llvm-passes -emit-llvm -o reduce.ll
; opt -simplifycfg -sroa -loop-rotate -o - -S reduce.ll ; opt -temporarily-allow-old-pass-syntax -simplifycfg -sroa -loop-rotate -o - -S reduce.ll
; cat reduce.cpp ; cat reduce.cpp
; extern char a; ; extern char a;
; extern char b; ; extern char b;
; void use(char); ; void use(char);
; void fun() { ; void fun() {
; char local = 0; ; char local = 0;
; for (;b;) ; for (;b;)
; local = a; ; local = a;
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/DebugInfo/X86/undef-type-md.ll

; RUN: opt -S -ipsccp %S/undef-type-md.ll | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -ipsccp %S/undef-type-md.ll | FileCheck %s
; CHECK: llvm.nondebug.metadata = !{[[NONDEBUG_METADATA:![0-9]+]]} ; CHECK: llvm.nondebug.metadata = !{[[NONDEBUG_METADATA:![0-9]+]]}
; CHECK: [[NONDEBUG_METADATA]] = distinct !{null} ; CHECK: [[NONDEBUG_METADATA]] = distinct !{null}
; CHECK: !DITemplateValueParameter({{.*}} value: %class.1 addrspace(1)* undef) ; CHECK: !DITemplateValueParameter({{.*}} value: %class.1 addrspace(1)* undef)
; ModuleID = '<stdin>' ; ModuleID = '<stdin>'
source_filename = "test.cpp" source_filename = "test.cpp"
%"struct.1" = type <{ float, i32, i8, [3 x i8] }> %"struct.1" = type <{ float, i32, i8, [3 x i8] }>
%"class.1" = type { %"struct.1" } %"class.1" = type { %"struct.1" }
Show All 25 Lines

llvm/test/DebugInfo/check-debugify-preserves-analyses.ll

; RUN: opt < %s -passes='require<globals-aa>,function-attrs' | \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -passes='require<globals-aa>,function-attrs' | \
; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.no_dbg ; RUN: opt -temporarily-allow-old-pass-syntax -S -strip -strip-dead-prototypes -strip-named-metadata > %t.no_dbg
; RUN: opt < %s -debugify-each -passes='require<globals-aa>,function-attrs' | \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -debugify-each -passes='require<globals-aa>,function-attrs' | \
; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.with_dbg ; RUN: opt -temporarily-allow-old-pass-syntax -S -strip -strip-dead-prototypes -strip-named-metadata > %t.with_dbg
; RUN: diff %t.no_dbg %t.with_dbg ; RUN: diff %t.no_dbg %t.with_dbg
define i32 @f_1(i32 %x) { define i32 @f_1(i32 %x) {
%tmp = call i32 @f_1(i32 0) [ "deopt"() ] %tmp = call i32 @f_1(i32 0) [ "deopt"() ]
ret i32 0 ret i32 0
} }

llvm/test/DebugInfo/debugify-bogus-dbg-value.ll

; RUN: opt -check-debugify < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -check-debugify < %s 2>&1 | FileCheck %s
define <2 x i64> @test-fun(<2 x i64> %A) !dbg !6 { define <2 x i64> @test-fun(<2 x i64> %A) !dbg !6 {
%and = and <2 x i64> %A, <i64 23, i64 42>, !dbg !14 %and = and <2 x i64> %A, <i64 23, i64 42>, !dbg !14
; CHECK: ERROR: dbg.value operand has size 128, but its variable has size 256 ; CHECK: ERROR: dbg.value operand has size 128, but its variable has size 256
call void @llvm.dbg.value(metadata <2 x i64> %and, metadata !12, metadata !DIExpression()), !dbg !15 call void @llvm.dbg.value(metadata <2 x i64> %and, metadata !12, metadata !DIExpression()), !dbg !15
; CHECK: ERROR: dbg.value operand has size 512, but its variable has size 256 ; CHECK: ERROR: dbg.value operand has size 512, but its variable has size 256
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

llvm/test/DebugInfo/debugify-export.ll

; RUN: opt %s -disable-output -debugify-each -debugify-quiet -debugify-export - -globalopt | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -disable-output -debugify-each -debugify-quiet -debugify-export - -globalopt -temporarily-allow-old-pass-syntax | FileCheck %s
; RUN: opt %s -disable-output -debugify-each -debugify-quiet -debugify-export - -passes=globalopt | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -disable-output -debugify-each -debugify-quiet -debugify-export - -passes=globalopt -temporarily-allow-old-pass-syntax | FileCheck %s
; CHECK: Pass Name ; CHECK: Pass Name
; CHECK-SAME: # of missing debug values ; CHECK-SAME: # of missing debug values
; CHECK-SAME: # of missing locations ; CHECK-SAME: # of missing locations
; CHECK-SAME: Missing/Expected value ratio ; CHECK-SAME: Missing/Expected value ratio
; CHECK-SAME: Missing/Expected location ratio ; CHECK-SAME: Missing/Expected location ratio
; CHECK: {{Module Verifier|GlobalOptPass}} ; CHECK: {{Module Verifier|GlobalOptPass}}
; CHECK-SAME: 0,0,0.000000e+00,0.000000e+00 ; CHECK-SAME: 0,0,0.000000e+00,0.000000e+00
define void @foo() { define void @foo() {
ret void ret void
} }

llvm/test/DebugInfo/debugify-ignore-phi.ll

; RUN: opt -check-debugify < %s -S 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -check-debugify < %s -S 2>&1 | FileCheck %s
define void @test_phi(i1 %cond) !dbg !6 { define void @test_phi(i1 %cond) !dbg !6 {
br i1 %cond, label %1, label %2, !dbg !11 br i1 %cond, label %1, label %2, !dbg !11
1: ; preds = %0 1: ; preds = %0
br label %2, !dbg !12 br label %2, !dbg !12
2: ; preds = %1, %0 2: ; preds = %1, %0
Show All 29 Lines

llvm/test/DebugInfo/debugify-original-no-dbg-info.ll

; RUN: opt -verify-debuginfo-preserve -instcombine -S -o - < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify-debuginfo-preserve -instcombine -S -o - < %s 2>&1 | FileCheck %s
; CHECK: ModuleDebugify (original debuginfo): Skipping module without debug info ; CHECK: ModuleDebugify (original debuginfo): Skipping module without debug info
; CHECK-NEXT: CheckModuleDebugify (original debuginfo): Skipping module without debug info ; CHECK-NEXT: CheckModuleDebugify (original debuginfo): Skipping module without debug info
; ModuleID = 'no-dbg-info.c' ; ModuleID = 'no-dbg-info.c'
source_filename = "no-dbg-info.c" source_filename = "no-dbg-info.c"
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"
Show All 14 Lines

llvm/test/DebugInfo/debugify-report-missing-locs-only.ll

; RUN: opt -check-debugify < %s -S -o - 2>&1 | FileCheck %s -implicit-check-not "WARNING: Instruction with empty DebugLoc in function bar" ; RUN: opt -temporarily-allow-old-pass-syntax -check-debugify < %s -S -o - 2>&1 | FileCheck %s -implicit-check-not "WARNING: Instruction with empty DebugLoc in function bar"
; CHECK: WARNING: Instruction with empty DebugLoc in function foo -- ret void ; CHECK: WARNING: Instruction with empty DebugLoc in function foo -- ret void
define void @foo() !dbg !6 { define void @foo() !dbg !6 {
ret void ret void
} }
define i32 @bar() !dbg !9 { define i32 @bar() !dbg !9 {
ret i32 0, !dbg !15 ret i32 0, !dbg !15
Show All 21 Lines

llvm/test/DebugInfo/debugify.ll

; RUN: opt -debugify -S -o - < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -debugify -S -o - < %s | FileCheck %s
; RUN: opt -passes=debugify -S -o - < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -passes=debugify -S -o - < %s | FileCheck %s
; RUN: opt -debugify -debugify -S -o - < %s 2>&1 | \ ; RUN: opt -temporarily-allow-old-pass-syntax -debugify -debugify -S -o - < %s 2>&1 | \
; RUN: FileCheck %s -check-prefix=CHECK-REPEAT ; RUN: FileCheck %s -check-prefix=CHECK-REPEAT
; RUN: opt -passes=debugify,debugify -S -o - < %s 2>&1 | \ ; RUN: opt -temporarily-allow-old-pass-syntax -passes=debugify,debugify -S -o - < %s 2>&1 | \
; RUN: FileCheck %s -check-prefix=CHECK-REPEAT ; RUN: FileCheck %s -check-prefix=CHECK-REPEAT
; RUN: opt -debugify -check-debugify -S -o - < %s | \ ; RUN: opt -temporarily-allow-old-pass-syntax -debugify -check-debugify -S -o - < %s | \
; RUN: FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL" ; RUN: FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL"
; RUN: opt -passes=debugify,check-debugify -S -o - < %s | \ ; RUN: opt -temporarily-allow-old-pass-syntax -passes=debugify,check-debugify -S -o - < %s | \
; RUN: FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL" ; RUN: FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL"
; RUN: opt -enable-debugify -passes=verify -S -o - < %s | \ ; RUN: opt -temporarily-allow-old-pass-syntax -enable-debugify -passes=verify -S -o - < %s | \
; RUN: FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL" ; RUN: FileCheck %s -implicit-check-not="CheckModuleDebugify: FAIL"
; RUN: opt -debugify -strip -check-debugify -S -o - < %s 2>&1 | \ ; RUN: opt -temporarily-allow-old-pass-syntax -debugify -strip -check-debugify -S -o - < %s 2>&1 | \
; RUN: FileCheck %s -check-prefix=CHECK-WARN ; RUN: FileCheck %s -check-prefix=CHECK-WARN
; RUN: opt -enable-debugify -strip -S -o - < %s 2>&1 | \ ; RUN: opt -temporarily-allow-old-pass-syntax -enable-debugify -strip -S -o - < %s 2>&1 | \
; RUN: FileCheck %s -check-prefix=CHECK-WARN ; RUN: FileCheck %s -check-prefix=CHECK-WARN
; RUN: opt -enable-debugify -S -o - < %s 2>&1 | FileCheck %s -check-prefix=PASS ; RUN: opt -temporarily-allow-old-pass-syntax -enable-debugify -S -o - < %s 2>&1 | FileCheck %s -check-prefix=PASS
; Verify that debugify can be safely used with piping ; Verify that debugify can be safely used with piping
; RUN: opt -enable-debugify -O1 < %s | opt -O2 -o /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax -enable-debugify -O1 < %s | opt -temporarily-allow-old-pass-syntax -O2 -o /dev/null
; RUN: opt -debugify -mem2reg -check-debugify < %s | opt -O2 -o /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax -debugify -mem2reg -check-debugify < %s | opt -temporarily-allow-old-pass-syntax -O2 -o /dev/null
; CHECK-LABEL: define void @foo ; CHECK-LABEL: define void @foo
define void @foo() { define void @foo() {
; CHECK: ret void, !dbg ![[RET1:.*]] ; CHECK: ret void, !dbg ![[RET1:.*]]
ret void ret void
} }
; CHECK-LABEL: define i32 @bar ; CHECK-LABEL: define i32 @bar
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/DebugInfo/duplicate_dbgvalue.ll

; RUN: opt -instcombine -S -o - < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S -o - < %s | FileCheck %s
; CHECK-LABEL: %3 = load i32, ptr %i1_311 ; CHECK-LABEL: %3 = load i32, ptr %i1_311
; CHECK: call void @llvm.dbg.value(metadata i32 %3 ; CHECK: call void @llvm.dbg.value(metadata i32 %3
; Next instruction should not be duplicate dbg.value intrinsic. ; Next instruction should not be duplicate dbg.value intrinsic.
; CHECK-NEXT: @f90io_sc_i_ldw ; CHECK-NEXT: @f90io_sc_i_ldw
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;program main ;program main
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

llvm/test/DebugInfo/limit-arglist-size.ll

; RUN: opt -S -instcombine %s -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -instcombine %s -o - | FileCheck %s
; For performance reasons, we currently limit the number of values that can be ; For performance reasons, we currently limit the number of values that can be
; referenced by a dbg.value to 16. This test checks that we do not exceed this ; referenced by a dbg.value to 16. This test checks that we do not exceed this
; limit during salvaging. ; limit during salvaging.
; CHECK: DIArgList(i32 undef ; CHECK: DIArgList(i32 undef
; CHECK-NOT: DW_OP_LLVM_arg, 16 ; CHECK-NOT: DW_OP_LLVM_arg, 16
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

llvm/test/DebugInfo/pr34672.ll

; RUN: opt -verify %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify %s 2>&1 | FileCheck %s
; CHECK: invalid type ref ; CHECK: invalid type ref
; CHECK-NOT: invalid type ref ; CHECK-NOT: invalid type ref
@global = common global i32 0, align 4, !dbg !2 @global = common global i32 0, align 4, !dbg !2
!llvm.dbg.cu = !{!0} !llvm.dbg.cu = !{!0}
!llvm.module.flags = !{!5, !6} !llvm.module.flags = !{!5, !6}
!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "adrian", emissionKind: FullDebug) !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "adrian", emissionKind: FullDebug)
!1 = !DIFile(filename: "broken.c", directory: "/") !1 = !DIFile(filename: "broken.c", directory: "/")
!2 = !DIGlobalVariableExpression(var: !3, expr: !DIExpression()) !2 = !DIGlobalVariableExpression(var: !3, expr: !DIExpression())
!3 = !DIGlobalVariable(name: "g", scope: !0, file: !1, line: 1, type: !1, isLocal: false, isDefinition: true) !3 = !DIGlobalVariable(name: "g", scope: !0, file: !1, line: 1, type: !1, isLocal: false, isDefinition: true)
!5 = !{i32 2, !"Dwarf Version", i32 4} !5 = !{i32 2, !"Dwarf Version", i32 4}
!6 = !{i32 1, !"Debug Info Version", i32 3} !6 = !{i32 1, !"Debug Info Version", i32 3}

llvm/test/DebugInfo/return-same-line-merge.ll

; RUN: opt -simplifycfg -S < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -simplifycfg -S < %s | FileCheck %s
; ;
; Simplified from the following code: ; Simplified from the following code:
; int foo() { ; int foo() {
; if(c) { return a; } else { return b; } ; if(c) { return a; } else { return b; }
; } ; }
define i32 @foo(i32 %c, i32 %a, i32 %b) !dbg !4 { define i32 @foo(i32 %c, i32 %a, i32 %b) !dbg !4 {
; CHECK: define i32 @foo({{.*}}) !dbg [[FOO_SUBPROGRAM:![0-9]+]] ; CHECK: define i32 @foo({{.*}}) !dbg [[FOO_SUBPROGRAM:![0-9]+]]
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
Show All 30 Lines

llvm/test/DebugInfo/salvage-duplicate-values.ll

; RUN: opt %s -dce -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -dce -S | FileCheck %s
; Tests the results of salvaging variadic dbg.values that use the same SSA value ; Tests the results of salvaging variadic dbg.values that use the same SSA value
; multiple times. ; multiple times.
; CHECK: call void @llvm.dbg.value(metadata !DIArgList(i32 %a, i32 %a), ; CHECK: call void @llvm.dbg.value(metadata !DIArgList(i32 %a, i32 %a),
; CHECK-SAME: ![[VAR_C:[0-9]+]], ; CHECK-SAME: ![[VAR_C:[0-9]+]],
; CHECK-SAME: !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_plus_uconst, 5, DW_OP_LLVM_arg, 1, DW_OP_plus_uconst, 5, DW_OP_plus, DW_OP_stack_value)) ; CHECK-SAME: !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_plus_uconst, 5, DW_OP_LLVM_arg, 1, DW_OP_plus_uconst, 5, DW_OP_plus, DW_OP_stack_value))
Show All 40 Lines

llvm/test/DebugInfo/salvage-gep.ll

; RUN: opt %s -dce -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -dce -S | FileCheck %s
; Tests the salvaging of GEP instructions, specifically struct indexing, ; Tests the salvaging of GEP instructions, specifically struct indexing,
; non-constant array indexing, and non-constant array indexing into an array of ; non-constant array indexing, and non-constant array indexing into an array of
; a type with width 0. ; a type with width 0.
%struct.S = type { i32, i32 } %struct.S = type { i32, i32 }
%zero = type [0 x [10 x i32]] %zero = type [0 x [10 x i32]]
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

llvm/test/DebugInfo/salvage-limit-expr-size.ll

; RUN: opt %s -dce -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -dce -S | FileCheck %s
;; Tests that a DIExpression will only be salvaged up to a certain length, and ;; Tests that a DIExpression will only be salvaged up to a certain length, and
;; will produce an undef value if an expression would need to exceed that length. ;; will produce an undef value if an expression would need to exceed that length.
define i32 @"?multiply@@YAHHH@Z"(i32 %a, i32 %b) !dbg !8 { define i32 @"?multiply@@YAHHH@Z"(i32 %a, i32 %b) !dbg !8 {
entry: entry:
%add.1 = add nsw i32 %a, 5, !dbg !14 %add.1 = add nsw i32 %a, 5, !dbg !14
%add.2 = add nsw i32 %a, %b, !dbg !14 %add.2 = add nsw i32 %a, %b, !dbg !14
Show All 38 Lines

llvm/test/DebugInfo/salvage-nonconst-binop.ll

; RUN: opt %s -dce -S | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -dce -S | FileCheck %s
; Tests the salvaging of binary operators that use more than one non-constant ; Tests the salvaging of binary operators that use more than one non-constant
; SSA value. ; SSA value.
; CHECK: call void @llvm.dbg.value(metadata !DIArgList(i32 %a, i32 %b), ; CHECK: call void @llvm.dbg.value(metadata !DIArgList(i32 %a, i32 %b),
; CHECK-SAME: ![[VAR_C:[0-9]+]], ; CHECK-SAME: ![[VAR_C:[0-9]+]],
; CHECK-SAME: !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus, DW_OP_stack_value)) ; CHECK-SAME: !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus, DW_OP_stack_value))
Show All 36 Lines

llvm/test/DebugInfo/simplify-cfg-preserve-dbg-values.ll

; RUN: opt %s -simplifycfg -verify -S -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -simplifycfg -verify -S -o - | FileCheck %s
; ;
; Verify that SimplifyCFG does not invalidate operands for ; Verify that SimplifyCFG does not invalidate operands for
; llvm.dbg.value intrinsics. ; llvm.dbg.value intrinsics.
; ;
; Reduced from the following example, compiled with ; Reduced from the following example, compiled with
; -O1 -g -fno-exceptions -fno-discard-value-names: ; -O1 -g -fno-exceptions -fno-discard-value-names:
; ;
; void test() { ; void test() {
▲ Show 20 Lines • Show All 123 Lines • Show Last 20 Lines

llvm/test/DebugInfo/unrolled-loop-remainder.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 -loop-unroll -unroll-runtime -unroll-allow-remainder -unroll-count=4 -unroll-remainder -S %s -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -loop-unroll -unroll-runtime -unroll-allow-remainder -unroll-count=4 -unroll-remainder -S %s -o - | 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@b = common local_unnamed_addr global i32 0, align 4, !dbg !0 @b = common local_unnamed_addr global i32 0, align 4, !dbg !0
@a = common local_unnamed_addr global ptr null, align 8, !dbg !6 @a = common local_unnamed_addr global ptr null, align 8, !dbg !6
; Test that loop remainder unrolling doesn't corrupt debuginfo. This example ; Test that loop remainder unrolling doesn't corrupt debuginfo. This example
; used to cause an assert, but also test that the unrolled backwards branches ; used to cause an assert, but also test that the unrolled backwards branches
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

llvm/test/DebugInfo/verify-di-preserve.ll

; RUN: opt %s -verify-debuginfo-preserve -instcombine -disable-output 2>&1 | FileCheck --check-prefix=VERIFY %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -verify-debuginfo-preserve -instcombine -disable-output 2>&1 | FileCheck --check-prefix=VERIFY %s
; VERIFY: CheckModuleDebugify (original debuginfo): ; VERIFY: CheckModuleDebugify (original debuginfo):
; RUN: opt %s -verify-each-debuginfo-preserve -O2 -disable-output 2>&1 | FileCheck --check-prefix=VERIFY-EACH %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -verify-each-debuginfo-preserve -O2 -disable-output 2>&1 | FileCheck --check-prefix=VERIFY-EACH %s
; VERIFY-EACH: DeadArgumentEliminationPass ; VERIFY-EACH: DeadArgumentEliminationPass
; VERIFY-EACH: GlobalDCEPass ; VERIFY-EACH: GlobalDCEPass
; ModuleID = 'm.c' ; ModuleID = 'm.c'
source_filename = "m.c" source_filename = "m.c"
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"
Show All 39 Lines

llvm/test/Feature/OperandBundles/inliner-conservative.ll

; RUN: opt -S -inline < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -inline < %s | FileCheck %s
; Check that the inliner does not inline through arbitrary unknown ; Check that the inliner does not inline through arbitrary unknown
; operand bundles. ; operand bundles.
define i32 @callee() { define i32 @callee() {
entry: entry:
ret i32 2 ret i32 2
} }
define i32 @caller() { define i32 @caller() {
; CHECK: @caller( ; CHECK: @caller(
entry: entry:
; CHECK: call i32 @callee() [ "unknown"() ] ; CHECK: call i32 @callee() [ "unknown"() ]
%x = call i32 @callee() [ "unknown"() ] %x = call i32 @callee() [ "unknown"() ]
ret i32 %x ret i32 %x
} }

llvm/test/Feature/OperandBundles/inliner-funclet-wineh.ll

; RUN: opt -S -always-inline -mtriple=x86_64-windows-msvc < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -always-inline -mtriple=x86_64-windows-msvc < %s | FileCheck %s
; WinEH requires funclet tokens on nounwind intrinsics if they can lower to ; WinEH requires funclet tokens on nounwind intrinsics if they can lower to
; regular function calls in the course of IR transformations. ; regular function calls in the course of IR transformations.
; ;
; Test that the inliner propagates funclet tokens to such intrinsics when ; Test that the inliner propagates funclet tokens to such intrinsics when
; inlining into EH funclets, i.e.: llvm.objc.storeStrong inherits the "funclet" ; inlining into EH funclets, i.e.: llvm.objc.storeStrong inherits the "funclet"
; token from inlined_fn. ; token from inlined_fn.
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

llvm/test/Feature/OperandBundles/merge-func.ll

; RUN: opt -S -mergefunc < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -mergefunc < %s | FileCheck %s
; Minor note: functions need to be at least three instructions long ; Minor note: functions need to be at least three instructions long
; to be considered by -mergefunc. ; to be considered by -mergefunc.
declare i32 @foo(...) declare i32 @foo(...)
define i32 @f() { define i32 @f() {
; CHECK-LABEL: @f( ; CHECK-LABEL: @f(
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

llvm/test/Feature/global_pv.ll

; RUN: opt -instcombine -S < %s | llvm-as ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -S < %s | llvm-as
; RUN: opt -instcombine -globalopt -S < %s | llvm-as ; RUN: opt -temporarily-allow-old-pass-syntax -instcombine -globalopt -temporarily-allow-old-pass-syntax -S < %s | llvm-as
@G1 = global i32 zeroinitializer @G1 = global i32 zeroinitializer
@G2 = global i32 zeroinitializer @G2 = global i32 zeroinitializer
@g = global <2 x i32*> zeroinitializer @g = global <2 x i32*> zeroinitializer
%0 = type { i32, void ()*, i8* } %0 = type { i32, void ()*, i8* }
@llvm.global_ctors = appending global [1 x %0] [%0 { i32 65535, void ()* @test, i8* null }] @llvm.global_ctors = appending global [1 x %0] [%0 { i32 65535, void ()* @test, i8* null }]
define internal void @test() { define internal void @test() {
%A = insertelement <2 x i32*> undef, i32* @G1, i32 0 %A = insertelement <2 x i32*> undef, i32* @G1, i32 0
%B = insertelement <2 x i32*> %A, i32* @G2, i32 1 %B = insertelement <2 x i32*> %A, i32* @G2, i32 1
store <2 x i32*> %B, <2 x i32*>* @g store <2 x i32*> %B, <2 x i32*>* @g
ret void ret void
} }

llvm/test/LTO/X86/keep-used-puts-during-instcombine.ll

; RUN: opt -S -instcombine <%s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -instcombine <%s | FileCheck %s
; rdar://problem/16165191 ; rdar://problem/16165191
; llvm.compiler.used functions should not be renamed ; llvm.compiler.used functions should not be renamed
target triple = "x86_64-apple-darwin11" target triple = "x86_64-apple-darwin11"
@llvm.compiler.used = appending global [1 x ptr] [ @llvm.compiler.used = appending global [1 x ptr] [
ptr @puts ptr @puts
], section "llvm.metadata" ], section "llvm.metadata"
Show All 26 Lines

llvm/test/Other/2002-02-24-InlineBrokePHINodes.ll

; Inlining used to break PHI nodes. This tests that they are correctly updated ; Inlining used to break PHI nodes. This tests that they are correctly updated
; when a node is split around the call instruction. The verifier caught the error. ; when a node is split around the call instruction. The verifier caught the error.
; ;
; RUN: opt < %s -inline ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline
; ;
define i64 @test(i64 %X) { define i64 @test(i64 %X) {
ret i64 %X ret i64 %X
} }
define i64 @fib(i64 %n) { define i64 @fib(i64 %n) {
; <label>:0 ; <label>:0
Show All 11 Lines

llvm/test/Other/2007-09-10-PassManager.ll

; RUN: opt < %s -simple-loop-unswitch -indvars -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax < %s -simple-loop-unswitch -indvars -disable-output
; Require SCEV before LCSSA. ; Require SCEV before LCSSA.
define void @foo() { define void @foo() {
entry: entry:
%i = alloca i32, align 4 ; <i32*> [#uses=5] %i = alloca i32, align 4 ; <i32*> [#uses=5]
%"alloca point" = bitcast i32 0 to i32 ; <i32> [#uses=0] %"alloca point" = bitcast i32 0 to i32 ; <i32> [#uses=0]
store i32 0, i32* %i, align 4 store i32 0, i32* %i, align 4
br label %bb3 br label %bb3
Show All 23 Lines

llvm/test/Other/2008-02-14-PassManager.ll

; RUN: opt < %s -loop-unroll -loop-rotate -simplifycfg -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax < %s -loop-unroll -loop-rotate -simplifycfg -disable-output
; PR2028 ; PR2028
define i32 @test1() { define i32 @test1() {
ret i32 0 ret i32 0
} }

llvm/test/Other/2008-06-04-FieldSizeInPacked.ll

; RUN: opt < %s -instcombine -S | grep true ; RUN: opt -temporarily-allow-old-pass-syntax < %s -instcombine -S | grep true
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" 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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
%packed = type <{ x86_fp80, i8 }> %packed = type <{ x86_fp80, i8 }>
%unpacked = type { x86_fp80, i8 } %unpacked = type { x86_fp80, i8 }
define i1 @q() nounwind { define i1 @q() nounwind {
entry: entry:
%char_p = getelementptr %packed, %packed* null, i32 0, i32 1 ; <i8*> [#uses=1] %char_p = getelementptr %packed, %packed* null, i32 0, i32 1 ; <i8*> [#uses=1]
%char_u = getelementptr %unpacked, %unpacked* null, i32 0, i32 1 ; <i8*> [#uses=1] %char_u = getelementptr %unpacked, %unpacked* null, i32 0, i32 1 ; <i8*> [#uses=1]
%res = icmp eq i8* %char_p, %char_u ; <i1> [#uses=1] %res = icmp eq i8* %char_p, %char_u ; <i1> [#uses=1]
ret i1 %res ret i1 %res
} }

llvm/test/Other/2008-10-06-RemoveDeadPass.ll

; RUN: opt < %s -inline -internalize -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -internalize -disable-output
define void @foo() nounwind { define void @foo() nounwind {
ret void ret void
} }
define void @main(...) nounwind { define void @main(...) nounwind {
call void @foo() call void @foo()
ret void ret void
} }

llvm/test/Other/2009-06-05-no-implicit-float.ll

; RUN: opt < %s -verify -S | grep noimplicitfloat ; RUN: opt -temporarily-allow-old-pass-syntax < %s -verify -S | grep noimplicitfloat
declare void @f() noimplicitfloat declare void @f() noimplicitfloat

llvm/test/Other/X86/debugcounter-divrempairs.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt < %s -div-rem-pairs -debug-counter=div-rem-pairs-transform-skip=1,div-rem-pairs-transform-count=1 \ ; RUN: opt -temporarily-allow-old-pass-syntax < %s -div-rem-pairs -debug-counter=div-rem-pairs-transform-skip=1,div-rem-pairs-transform-count=1 \
; RUN: -S -mtriple=x86_64-unknown-unknown | FileCheck %s ; RUN: -S -mtriple=x86_64-unknown-unknown | FileCheck %s
;; Test that, with debug counters on, we only skip the first div-rem-pairs opportunity, optimize one after it, ;; Test that, with debug counters on, we only skip the first div-rem-pairs opportunity, optimize one after it,
;; and then ignore all the others. There is 1 optimization opportunity in f1, 2 in f2, and another 1 in f3, ;; and then ignore all the others. There is 1 optimization opportunity in f1, 2 in f2, and another 1 in f3,
;; only the first one in f2 will be performed. ;; only the first one in f2 will be performed.
define i64 @f1(i64 %a, i64 %b) { define i64 @f1(i64 %a, i64 %b) {
; CHECK-LABEL: @f1( ; CHECK-LABEL: @f1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
if: if:
%div = sdiv i32 %a, %b %div = sdiv i32 %a, %b
br label %end br label %end
end: end:
%ret = phi i32 [ %div, %if ], [ 3, %entry ] %ret = phi i32 [ %div, %if ], [ 3, %entry ]
ret i32 %ret ret i32 %ret
} }
No newline at end of file

llvm/test/Other/X86/debugcounter-partiallyinlinelibcalls.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -S -debug-counter=partially-inline-libcalls-transform-skip=1,partially-inline-libcalls-transform-count=1 \ ; RUN: opt -temporarily-allow-old-pass-syntax -S -debug-counter=partially-inline-libcalls-transform-skip=1,partially-inline-libcalls-transform-count=1 \
; RUN: -partially-inline-libcalls -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s ; RUN: -partially-inline-libcalls -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s
;; Test that, with debug counters on, we will skip the first optimization opportunity, perform next 1, ;; Test that, with debug counters on, we will skip the first optimization opportunity, perform next 1,
;; and ignore all the others left. ;; and ignore all the others left.
define float @f1(float %val) { define float @f1(float %val) {
; CHECK-LABEL: @f1( ; CHECK-LABEL: @f1(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: [[RES:%.*]] = tail call float @sqrtf(float [[VAL:%.*]]) ; CHECK-NEXT: [[RES:%.*]] = tail call float @sqrtf(float [[VAL:%.*]])
Show All 34 Lines

llvm/test/Other/cfg-printer-branch-weights-percent.ll

;RUN: opt < %s -dot-cfg -cfg-weights -cfg-dot-filename-prefix=%t 2>/dev/null > /dev/null ;RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg -cfg-weights -cfg-dot-filename-prefix=%t 2>/dev/null > /dev/null
;RUN: FileCheck %s -input-file=%t.f.dot ;RUN: FileCheck %s -input-file=%t.f.dot
define void @f(i32) { define void @f(i32) {
entry: entry:
%check = icmp sgt i32 %0, 0 %check = icmp sgt i32 %0, 0
br i1 %check, label %if, label %exit, !prof !0 br i1 %check, label %if, label %exit, !prof !0
; CHECK: label="0.50%" ; CHECK: label="0.50%"
Show All 10 Lines

llvm/test/Other/cfg-printer-branch-weights.ll

;RUN: opt < %s -dot-cfg -cfg-weights -cfg-raw-weights -cfg-dot-filename-prefix=%t 2>/dev/null > /dev/null ;RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg -cfg-weights -cfg-raw-weights -cfg-dot-filename-prefix=%t 2>/dev/null > /dev/null
;RUN: FileCheck %s -input-file=%t.f.dot ;RUN: FileCheck %s -input-file=%t.f.dot
define void @f(i32) { define void @f(i32) {
entry: entry:
%check = icmp sgt i32 %0, 0 %check = icmp sgt i32 %0, 0
br i1 %check, label %if, label %exit, !prof !0 br i1 %check, label %if, label %exit, !prof !0
; CHECK: label="W:7" ; CHECK: label="W:7"
Show All 10 Lines

llvm/test/Other/cfg-printer-filter.ll

; RUN: rm -f %t.other.dot %t-only.other.dot ; RUN: rm -f %t.other.dot %t-only.other.dot
;; Both f and func are dumped because their names contain the pattern 'f' as a substring. ;; Both f and func are dumped because their names contain the pattern 'f' as a substring.
; RUN: opt < %s -dot-cfg -cfg-dot-filename-prefix=%t -cfg-func-name=f 2>/dev/null > /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg -cfg-dot-filename-prefix=%t -cfg-func-name=f 2>/dev/null > /dev/null
; RUN: FileCheck %s -input-file=%t.f.dot -check-prefix=F ; RUN: FileCheck %s -input-file=%t.f.dot -check-prefix=F
; RUN: FileCheck %s -input-file=%t.func.dot -check-prefix=Func ; RUN: FileCheck %s -input-file=%t.func.dot -check-prefix=Func
; RUN: not test -f %t.other.dot ; RUN: not test -f %t.other.dot
; RUN: opt < %s -dot-cfg-only -cfg-dot-filename-prefix=%t-only -cfg-func-name=f 2>/dev/null > /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg-only -cfg-dot-filename-prefix=%t-only -cfg-func-name=f 2>/dev/null > /dev/null
; RUN: FileCheck %s -input-file=%t-only.f.dot -check-prefix=F ; RUN: FileCheck %s -input-file=%t-only.f.dot -check-prefix=F
; RUN: FileCheck %s -input-file=%t-only.func.dot -check-prefix=Func ; RUN: FileCheck %s -input-file=%t-only.func.dot -check-prefix=Func
; RUN: not test -f %t-only.other.dot ; RUN: not test -f %t-only.other.dot
; F: digraph "CFG for 'f' function" ; F: digraph "CFG for 'f' function"
define void @f(i32) { define void @f(i32) {
entry: entry:
%check = icmp sgt i32 %0, 0 %check = icmp sgt i32 %0, 0
Show All 23 Lines

llvm/test/Other/cfg_deopt_unreach.ll

; RUN: rm -rf %t ; RUN: rm -rf %t
; RUN: mkdir -p %t ; RUN: mkdir -p %t
; RUN: opt < %s -dot-cfg -cfg-hide-unreachable-paths -cfg-dot-filename-prefix=%t/unreach 2>/dev/null > /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg -cfg-hide-unreachable-paths -cfg-dot-filename-prefix=%t/unreach 2>/dev/null > /dev/null
; RUN: FileCheck %s -input-file=%t/unreach.callee.dot -check-prefix=UNREACH ; RUN: FileCheck %s -input-file=%t/unreach.callee.dot -check-prefix=UNREACH
; RUN: opt < %s -dot-cfg -cfg-hide-deoptimize-paths -cfg-dot-filename-prefix=%t/deopt 2>/dev/null > /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg -cfg-hide-deoptimize-paths -cfg-dot-filename-prefix=%t/deopt -temporarily-allow-old-pass-syntax 2>/dev/null > /dev/null
; RUN: FileCheck %s -input-file=%t/deopt.callee.dot -check-prefix=DEOPT ; RUN: FileCheck %s -input-file=%t/deopt.callee.dot -check-prefix=DEOPT
; RUN: opt < %s -dot-cfg -cfg-dot-filename-prefix=%t/no-flags 2>/dev/null > /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg -cfg-dot-filename-prefix=%t/no-flags 2>/dev/null > /dev/null
; RUN: FileCheck %s -input-file=%t/no-flags.callee.dot -check-prefix=NO-FLAGS ; RUN: FileCheck %s -input-file=%t/no-flags.callee.dot -check-prefix=NO-FLAGS
; RUN: opt < %s -dot-cfg -cfg-hide-unreachable-paths -cfg-hide-deoptimize-paths -cfg-dot-filename-prefix=%t/both-flags 2>/dev/null > /dev/null ; RUN: opt -temporarily-allow-old-pass-syntax < %s -dot-cfg -cfg-hide-unreachable-paths -cfg-hide-deoptimize-paths -cfg-dot-filename-prefix=%t/both-flags 2>/dev/null > /dev/null
; RUN: FileCheck %s -input-file=%t/both-flags.callee.dot -check-prefix=BOTH-FLAGS ; RUN: FileCheck %s -input-file=%t/both-flags.callee.dot -check-prefix=BOTH-FLAGS
declare i8 @llvm.experimental.deoptimize.i8(...) declare i8 @llvm.experimental.deoptimize.i8(...)
define i8 @callee(i1* %c) alwaysinline { define i8 @callee(i1* %c) alwaysinline {
%c0 = load volatile i1, i1* %c %c0 = load volatile i1, i1* %c
br i1 %c0, label %lleft, label %lright br i1 %c0, label %lleft, label %lright
; NO-FLAGS: label="{lleft: \l %v0 = call i8 (...) @llvm.experimental.deoptimize.i8(i32 1) [ \"deopt\"(i32 1)\l... ]\l ret i8 %v0\l}" ; NO-FLAGS: label="{lleft: \l %v0 = call i8 (...) @llvm.experimental.deoptimize.i8(i32 1) [ \"deopt\"(i32 1)\l... ]\l ret i8 %v0\l}"
Show All 14 Lines

llvm/test/Other/constant-fold-gep.ll

; "PLAIN" - No optimizations. This tests the default target layout ; "PLAIN" - No optimizations. This tests the default target layout
; constant folder. ; constant folder.
; RUN: opt -S -o - < %s | FileCheck --check-prefix=PLAIN %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -o - < %s | FileCheck --check-prefix=PLAIN %s
; "OPT" - Optimizations but no targetdata. This tests default target layout ; "OPT" - Optimizations but no targetdata. This tests default target layout
; folding in the optimizers. ; folding in the optimizers.
; RUN: opt -S -o - -instcombine -globalopt < %s | FileCheck --check-prefix=OPT %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -o - -instcombine -globalopt -temporarily-allow-old-pass-syntax < %s | FileCheck --check-prefix=OPT %s
; "TO" - Optimizations and targetdata. This tests target-dependent ; "TO" - Optimizations and targetdata. This tests target-dependent
; folding in the optimizers. ; folding in the optimizers.
; RUN: opt -S -o - -instcombine -globalopt -data-layout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" < %s | FileCheck --check-prefix=TO %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -o - -instcombine -globalopt -temporarily-allow-old-pass-syntax -data-layout="e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64" < %s | FileCheck --check-prefix=TO %s
; "SCEV" - ScalarEvolution with default target layout ; "SCEV" - ScalarEvolution with default target layout
; RUN: opt -passes='print<scalar-evolution>' < %s -disable-output 2>&1 | FileCheck --check-prefix=SCEV %s ; RUN: opt -temporarily-allow-old-pass-syntax -passes='print<scalar-evolution>' < %s -disable-output 2>&1 | FileCheck --check-prefix=SCEV %s
; The automatic constant folder in opt does not have targetdata access, so ; The automatic constant folder in opt -temporarily-allow-old-pass-syntax does not have targetdata access, so
; it can't fold gep arithmetic, in general. However, the constant folder run ; it can't fold gep arithmetic, in general. However, the constant folder run
; from instcombine and global opt can use targetdata. ; from instcombine and global opt -temporarily-allow-old-pass-syntax can use targetdata.
; PLAIN: @G8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -1) ; PLAIN: @G8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -1)
; PLAIN: @G1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -1) ; PLAIN: @G1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -1)
; PLAIN: @F8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -2) ; PLAIN: @F8 = global i8* getelementptr (i8, i8* inttoptr (i32 1 to i8*), i32 -2)
; PLAIN: @F1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -2) ; PLAIN: @F1 = global i1* getelementptr (i1, i1* inttoptr (i32 1 to i1*), i32 -2)
; PLAIN: @H8 = global i8* getelementptr (i8, i8* null, i32 -1) ; PLAIN: @H8 = global i8* getelementptr (i8, i8* null, i32 -1)
; PLAIN: @H1 = global i1* getelementptr (i1, i1* null, i32 -1) ; PLAIN: @H1 = global i1* getelementptr (i1, i1* null, i32 -1)
; OPT: @G8 = local_unnamed_addr global i8* null ; OPT: @G8 = local_unnamed_addr global i8* null
▲ Show 20 Lines • Show All 460 Lines • Show Last 20 Lines

llvm/test/Other/copy-metadata-of-declaration.ll

; RUN: opt -run-twice -verify -S -o - %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -run-twice -verify -S -o - %s | FileCheck %s
; This test is used to check metadata attached to global variable declarations ; This test is used to check metadata attached to global variable declarations
; are copied when CloneModule(). This is required by out-of-tree passes. ; are copied when CloneModule(). This is required by out-of-tree passes.
; CHECK: @g = external addrspace(64) global i32, !spirv.InOut !0 ; CHECK: @g = external addrspace(64) global i32, !spirv.InOut !0
@g = external addrspace(64) global i32, !spirv.InOut !0 @g = external addrspace(64) global i32, !spirv.InOut !0
!0 = !{i32 1} !0 = !{i32 1}

llvm/test/Other/debugcounter-dce.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -dce -S -debug-counter=dce-transform-skip=1,dce-transform-count=2 < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -dce -S -debug-counter=dce-transform-skip=1,dce-transform-count=2 < %s | FileCheck %s
;; Test that, with debug counters on, we will skip the first DCE opportunity, perform next 2, ;; Test that, with debug counters on, we will skip the first DCE opportunity, perform next 2,
;; and ignore all the others left. ;; and ignore all the others left.
; CHECK-LABEL: @test ; CHECK-LABEL: @test
; CHECK-NEXT: %add1 = add i32 1, 2 ; CHECK-NEXT: %add1 = add i32 1, 2
; CHECK-NEXT: %sub1 = sub i32 %add1, 1 ; CHECK-NEXT: %sub1 = sub i32 %add1, 1
; CHECK-NEXT: %add2 = add i32 1, 2 ; CHECK-NEXT: %add2 = add i32 1, 2
; CHECK-NEXT: %add3 = add i32 1, 2 ; CHECK-NEXT: %add3 = add i32 1, 2
Show All 10 Lines

llvm/test/Other/debugcounter-newgvn.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -S -debug-counter=newgvn-vn-skip=1,newgvn-vn-count=2 -newgvn < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -debug-counter=newgvn-vn-skip=1,newgvn-vn-count=2 -newgvn < %s 2>&1 | FileCheck %s
;; Test that, with debug counters on, we don't value number the first instruction, only the second and third, ;; Test that, with debug counters on, we don't value number the first instruction, only the second and third,
;; which means we do not discover the return is constant. ;; which means we do not discover the return is constant.
define i32 @vntest() { define i32 @vntest() {
; CHECK-LABEL: @vntest( ; CHECK-LABEL: @vntest(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[A:%.*]] = add i32 1, 3 ; CHECK-NEXT: [[A:%.*]] = add i32 1, 3
; CHECK-NEXT: [[D:%.*]] = add i32 8, 8 ; CHECK-NEXT: [[D:%.*]] = add i32 8, 8
; CHECK-NEXT: ret i32 [[D]] ; CHECK-NEXT: ret i32 [[D]]
Show All 11 Lines

llvm/test/Other/heat-colors-graphs.ll

; RUN: opt %s -dot-cfg -cfg-heat-colors -cfg-dot-filename-prefix=%t -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax %s -dot-cfg -cfg-heat-colors -cfg-dot-filename-prefix=%t -disable-output
; RUN: FileCheck %s -input-file=%t.f.dot --check-prefixes=CHECK-CFG,CHECK-BOTH ; RUN: FileCheck %s -input-file=%t.f.dot --check-prefixes=CHECK-CFG,CHECK-BOTH
; RUN: opt %s -dot-callgraph -callgraph-heat-colors -callgraph-dot-filename-prefix=%t -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax %s -dot-callgraph -callgraph-heat-colors -callgraph-dot-filename-prefix=%t -disable-output
; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK-BOTH ; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK-BOTH
; CHECK-BOTH: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]" ; CHECK-BOTH: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]"
; CHECK-CFG: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]" ; CHECK-CFG: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]"
; CHECK-CFG: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]" ; CHECK-CFG: color="#[[#%x,]]", style={{[a-z]+}}, fillcolor="#[[#%x,]]"
define void @f(i32) { define void @f(i32) {
entry: entry:
Show All 10 Lines

llvm/test/Other/heat-colors-multigraph.ll

; RUN: opt %s -dot-callgraph -callgraph-multigraph -callgraph-dot-filename-prefix=%t -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax %s -dot-callgraph -callgraph-multigraph -callgraph-dot-filename-prefix=%t -disable-output
; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK-MULTIGRAPH ; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK-MULTIGRAPH
; RUN: opt %s -dot-callgraph -callgraph-dot-filename-prefix=%t -disable-output ; RUN: opt -temporarily-allow-old-pass-syntax %s -dot-callgraph -callgraph-dot-filename-prefix=%t -disable-output
; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK ; RUN: FileCheck %s -input-file=%t.callgraph.dot --check-prefix=CHECK
; CHECK-MULTIGRAPH: {external caller} ; CHECK-MULTIGRAPH: {external caller}
; CHECK-NOT: {external caller} ; CHECK-NOT: {external caller}
define void @bar() { define void @bar() {
ret void ret void
} }
define void @foo() { define void @foo() {
call void @bar() call void @bar()
ret void ret void
} }
No newline at end of file

llvm/test/Other/module-pass-printer.ll

; Check pass name is only printed once. ; Check pass name is only printed once.
; Check only one function is printed ; Check only one function is printed
; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo | FileCheck %s -check-prefix=FOO ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo | FileCheck %s -check-prefix=FOO
; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo | FileCheck %s -check-prefix=FOO ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo | FileCheck %s -check-prefix=FOO
; Check pass name is only printed once. ; Check pass name is only printed once.
; Check both functions are printed ; Check both functions are printed
; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo,bar | FileCheck %s -check-prefix=BOTH ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo,bar | FileCheck %s -check-prefix=BOTH
; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo,bar | FileCheck %s -check-prefix=BOTH ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo,bar | FileCheck %s -check-prefix=BOTH
; Check pass name is not printed if a module/SCC doesn't include any function specified in -filter-print-funcs. ; Check pass name is not printed if a module/SCC doesn't include any function specified in -filter-print-funcs.
; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY
; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY
; RUN: opt < %s 2>&1 -passes=no-op-cgscc -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -passes=no-op-cgscc -disable-output -print-after-all -filter-print-funcs=baz | FileCheck %s -allow-empty -check-prefix=EMPTY
; Check whole module is printed with user-specified wildcast switch -filter-print-funcs=* or -print-module-scope ; Check whole module is printed with user-specified wildcast switch -filter-print-funcs=* or -print-module-scope
; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all | FileCheck %s -check-prefix=ALL ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -forceattrs -disable-output -print-after-all | FileCheck %s -check-prefix=ALL
; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=* | FileCheck %s -check-prefix=ALL ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=* | FileCheck %s -check-prefix=ALL
; RUN: opt < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo -print-module-scope | FileCheck %s -check-prefix=ALL ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -forceattrs -disable-output -print-after-all -filter-print-funcs=foo -print-module-scope | FileCheck %s -check-prefix=ALL
; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all | FileCheck %s -check-prefix=ALL ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -passes=forceattrs -disable-output -print-after-all | FileCheck %s -check-prefix=ALL
; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=* | FileCheck %s -check-prefix=ALL ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=* | FileCheck %s -check-prefix=ALL
; RUN: opt < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo -print-module-scope | FileCheck %s -check-prefix=ALL ; RUN: opt -temporarily-allow-old-pass-syntax < %s 2>&1 -passes=forceattrs -disable-output -print-after-all -filter-print-funcs=foo -print-module-scope | FileCheck %s -check-prefix=ALL
; FOO: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}} ; FOO: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
; FOO: define void @foo ; FOO: define void @foo
; FOO-NOT: define void @bar ; FOO-NOT: define void @bar
; FOO-NOT: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}} ; FOO-NOT: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
; BOTH: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}} ; BOTH: IR Dump After {{Force set function attributes|ForceFunctionAttrsPass}}
; BOTH: define void @foo ; BOTH: define void @foo
Show All 20 Lines

llvm/test/Other/opt-legacy-syntax-deprecation.ll

; REQUIRES: x86-registered-target ; REQUIRES: x86-registered-target
; RUN: opt /dev/null -disable-output 2>&1 | FileCheck %s --check-prefix=OK --allow-empty ; RUN: opt -temporarily-allow-old-pass-syntax /dev/null -disable-output 2>&1 | FileCheck %s --check-prefix=OK --allow-empty
; RUN: opt /dev/null -disable-output -passes=instcombine 2>&1 | FileCheck %s --check-prefix=OK --allow-empty ; RUN: opt -temporarily-allow-old-pass-syntax /dev/null -disable-output -passes=instcombine 2>&1 | FileCheck %s --check-prefix=OK --allow-empty
; RUN: opt /dev/null -disable-output -instcombine 2>&1 | FileCheck %s --check-prefix=WARN ; RUN: opt -temporarily-allow-old-pass-syntax /dev/null -disable-output -instcombine 2>&1 | FileCheck %s --check-prefix=WARN
; RUN: opt /dev/null -disable-output -instcombine -globaldce 2>&1 | FileCheck %s --check-prefix=WARN ; RUN: opt -temporarily-allow-old-pass-syntax /dev/null -disable-output -instcombine -globaldce 2>&1 | FileCheck %s --check-prefix=WARN
; RUN: opt /dev/null -disable-output -instcombine -enable-new-pm=0 2>&1 | FileCheck %s --check-prefix=OK --allow-empty ; RUN: opt -temporarily-allow-old-pass-syntax /dev/null -disable-output -instcombine -enable-new-pm=0 2>&1 | FileCheck %s --check-prefix=OK --allow-empty
; RUN: opt /dev/null -disable-output -codegenprepare -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s --check-prefix=OK --allow-empty ; RUN: opt -temporarily-allow-old-pass-syntax /dev/null -disable-output -codegenprepare -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s --check-prefix=OK --allow-empty
; OK-NOT: deprecated ; OK-NOT: deprecated
; WARN: The `opt -passname` syntax for the new pass manager is deprecated, please use `opt -passes=<pipeline>` (or the `-p` alias for a more concise version). ; WARN: The `opt -passname` syntax for the new pass manager is deprecated, please use `opt -passes=<pipeline>` (or the `-p` alias for a more concise version).

llvm/test/Other/optimization-remarks-inline.ll

; RUN: opt < %s -inline -pass-remarks='inline' -S 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -pass-remarks='inline' -S 2>&1 | FileCheck %s
; RUN: opt < %s -inline -pass-remarks='inl.*' -S 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -pass-remarks='inl.*' -S 2>&1 | FileCheck %s
; RUN: opt < %s -inline -pass-remarks='vector' -pass-remarks='inl' -S 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -pass-remarks='vector' -pass-remarks='inl' -S 2>&1 | FileCheck %s
; These two should not yield an inline remark for the same reason. ; These two should not yield an inline remark for the same reason.
; In the first command, we only ask for vectorizer remarks, in the ; In the first command, we only ask for vectorizer remarks, in the
; second one we ask for the inliner, but we then ask for the vectorizer ; second one we ask for the inliner, but we then ask for the vectorizer
; (thus overriding the first flag). ; (thus overriding the first flag).
; RUN: opt < %s -inline -pass-remarks='vector' -S 2>&1 | FileCheck --check-prefix=REMARKS %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -pass-remarks='vector' -S 2>&1 | FileCheck --check-prefix=REMARKS %s
; RUN: opt < %s -inline -pass-remarks='inl' -pass-remarks='vector' -S 2>&1 | FileCheck --check-prefix=REMARKS %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -pass-remarks='inl' -pass-remarks='vector' -S 2>&1 | FileCheck --check-prefix=REMARKS %s
; RUN: opt < %s -inline -S 2>&1 | FileCheck --check-prefix=REMARKS %s ; RUN: opt -temporarily-allow-old-pass-syntax < %s -inline -S 2>&1 | FileCheck --check-prefix=REMARKS %s
; RUN: not opt < %s -pass-remarks='(' 2>&1 | FileCheck --check-prefix=BAD-REGEXP %s ; RUN: not opt -temporarily-allow-old-pass-syntax < %s -pass-remarks='(' 2>&1 | FileCheck --check-prefix=BAD-REGEXP %s
define i32 @foo(i32 %x, i32 %y) #0 { define i32 @foo(i32 %x, i32 %y) #0 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
%y.addr = alloca i32, align 4 %y.addr = alloca i32, align 4
store i32 %x, i32* %x.addr, align 4 store i32 %x, i32* %x.addr, align 4
store i32 %y, i32* %y.addr, align 4 store i32 %y, i32* %y.addr, align 4
%0 = load i32, i32* %x.addr, align 4 %0 = load i32, i32* %x.addr, align 4
Show All 19 Lines

llvm/test/Other/pr32085.ll

; RUN: opt -S -O1 < %s -o %t1.ll ; RUN: opt -temporarily-allow-old-pass-syntax -S -O1 < %s -o %t1.ll
; RUN: opt -S < %t1.ll -o %t2.ll ; RUN: opt -temporarily-allow-old-pass-syntax -S < %t1.ll -o %t2.ll
; RUN: opt -S -simplifycfg < %t1.ll -o %t3.ll ; RUN: opt -temporarily-allow-old-pass-syntax -S -simplifycfg < %t1.ll -o %t3.ll
;; Show that there's no difference after running another simplify CFG ;; Show that there's no difference after running another simplify CFG
; RUN: diff %t2.ll %t3.ll ; RUN: diff %t2.ll %t3.ll
; Test from LoopSink pass, leaves some single-entry single-exit basic blocks. ; Test from LoopSink pass, leaves some single-entry single-exit basic blocks.
; After LoopSink, we get a basic block .exit.loopexit which has one entry and ; After LoopSink, we get a basic block .exit.loopexit which has one entry and
; one exit, the only instruction is a branch. Make sure it doesn't show up. ; one exit, the only instruction is a branch. Make sure it doesn't show up.
; Make sure they disappear at -O1. ; Make sure they disappear at -O1.
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

llvm/test/Other/print-debug-counter.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -S -debug-counter=early-cse-skip=1,early-cse-count=1 -early-cse -earlycse-debug-hash \ ; RUN: opt -temporarily-allow-old-pass-syntax -S -debug-counter=early-cse-skip=1,early-cse-count=1 -early-cse -earlycse-debug-hash \
; RUN: -debug-counter=newgvn-vn-skip=1,newgvn-vn-count=2 -newgvn \ ; RUN: -debug-counter=newgvn-vn-skip=1,newgvn-vn-count=2 -newgvn \
; RUN: -instcombine -print-debug-counter < %s 2>&1 | FileCheck %s ; RUN: -instcombine -print-debug-counter < %s 2>&1 | FileCheck %s
;; Test debug counter prints correct info in right order. ;; Test debug counter prints correct info in right order.
; CHECK-LABEL: Counters and values: ; CHECK-LABEL: Counters and values:
; CHECK: early-cse ; CHECK: early-cse
; CHECK-SAME: {4,1,1} ; CHECK-SAME: {4,1,1}
; CHECK: instcombine-visit ; CHECK: instcombine-visit
; CHECK-SAME: {12,0,-1} ; CHECK-SAME: {12,0,-1}
Show All 21 Lines

llvm/test/Other/scalable-vector-struct-intrinsic.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 -verify < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -verify < %s 2>&1 | FileCheck %s
; Make sure we allow scalable vectors in structs for returning multiple ; Make sure we allow scalable vectors in structs for returning multiple
; values from intrinsics. ; values from intrinsics.
declare { <vscale x 2 x i32>, <vscale x 2 x i1> } @llvm.sadd.with.overflow.nxv2i32(<vscale x 2 x i32>, <vscale x 2 x i32>) declare { <vscale x 2 x i32>, <vscale x 2 x i1> } @llvm.sadd.with.overflow.nxv2i32(<vscale x 2 x i32>, <vscale x 2 x i32>)
define <vscale x 2 x i32> @foo(<vscale x 2 x i32> %x, <vscale x 2 x i32> %y) { define <vscale x 2 x i32> @foo(<vscale x 2 x i32> %x, <vscale x 2 x i32> %y) {
; CHECK-LABEL: @foo( ; CHECK-LABEL: @foo(
; CHECK-NEXT: [[A:%.*]] = call { <vscale x 2 x i32>, <vscale x 2 x i1> } @llvm.sadd.with.overflow.nxv2i32(<vscale x 2 x i32> [[X:%.*]], <vscale x 2 x i32> [[Y:%.*]]) ; CHECK-NEXT: [[A:%.*]] = call { <vscale x 2 x i32>, <vscale x 2 x i1> } @llvm.sadd.with.overflow.nxv2i32(<vscale x 2 x i32> [[X:%.*]], <vscale x 2 x i32> [[Y:%.*]])
; CHECK-NEXT: [[B:%.*]] = extractvalue { <vscale x 2 x i32>, <vscale x 2 x i1> } [[A]], 0 ; CHECK-NEXT: [[B:%.*]] = extractvalue { <vscale x 2 x i32>, <vscale x 2 x i1> } [[A]], 0
; CHECK-NEXT: ret <vscale x 2 x i32> [[B]] ; CHECK-NEXT: ret <vscale x 2 x i32> [[B]]
; ;
%a = call { <vscale x 2 x i32>, <vscale x 2 x i1> } @llvm.sadd.with.overflow.nxv2i32(<vscale x 2 x i32> %x, <vscale x 2 x i32> %y) %a = call { <vscale x 2 x i32>, <vscale x 2 x i1> } @llvm.sadd.with.overflow.nxv2i32(<vscale x 2 x i32> %x, <vscale x 2 x i32> %y)
%b = extractvalue { <vscale x 2 x i32>, <vscale x 2 x i1> } %a, 0 %b = extractvalue { <vscale x 2 x i32>, <vscale x 2 x i1> } %a, 0
ret <vscale x 2 x i32> %b ret <vscale x 2 x i32> %b
} }

llvm/test/Other/scalable-vectors-core-ir.ll

; RUN: opt -S -verify < %s | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S -verify < %s | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128" target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-gnu" target triple = "aarch64--linux-gnu"
;; Check supported instructions are accepted without dropping 'vscale'. ;; Check supported instructions are accepted without dropping 'vscale'.
;; Same order as the LangRef ;; Same order as the LangRef
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Unary Operations ;; Unary Operations
▲ Show 20 Lines • Show All 394 Lines • Show Last 20 Lines

llvm/test/Transforms/HardwareLoops/ARM/structure.ll

; RUN: opt -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops %s -S -o - | \ ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops %s -S -o - | \
; RUN: FileCheck %s ; RUN: FileCheck %s
; RUN: opt -mtriple=thumbv8.1m.main -loop-unroll -unroll-remainder=false -S < %s | \ ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=thumbv8.1m.main -loop-unroll -unroll-remainder=false -S < %s | \
; RUN: llc -mtriple=thumbv8.1m.main | FileCheck %s --check-prefix=CHECK-UNROLL ; RUN: llc -mtriple=thumbv8.1m.main | FileCheck %s --check-prefix=CHECK-UNROLL
; RUN: opt -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops \ ; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops \
; RUN: -pass-remarks-analysis=hardware-loops %s -S -o - 2>&1 | \ ; RUN: -pass-remarks-analysis=hardware-loops %s -S -o - 2>&1 | \
; RUN: FileCheck %s --check-prefix=CHECK-REMARKS ; RUN: FileCheck %s --check-prefix=CHECK-REMARKS
; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: it's not profitable to create a hardware-loop ; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: it's not profitable to create a hardware-loop
; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: nested hardware-loops not supported ; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: nested hardware-loops not supported
; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: it's not profitable to create a hardware-loop ; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: it's not profitable to create a hardware-loop
; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: it's not profitable to create a hardware-loop ; CHECK-REMARKS: remark: <unknown>:0:0: hardware-loop not created: it's not profitable to create a hardware-loop
▲ Show 20 Lines • Show All 412 Lines • Show Last 20 Lines

llvm/test/Transforms/LoadStoreVectorizer/X86/codegenprepare-produced-address-math.ll

; RUN: opt -codegenprepare -load-store-vectorizer %s -S -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -codegenprepare -load-store-vectorizer %s -S -o - | FileCheck %s
; RUN: opt -load-store-vectorizer %s -S -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -load-store-vectorizer %s -S -o - | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' %s -S -o - | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' %s -S -o - | FileCheck %s
target triple = "x86_64--" target triple = "x86_64--"
%union = type { { [4 x [4 x [4 x [16 x float]]]], [4 x [4 x [4 x [16 x float]]]], [10 x [10 x [4 x float]]] } } %union = type { { [4 x [4 x [4 x [16 x float]]]], [4 x [4 x [4 x [16 x float]]]], [10 x [10 x [4 x float]]] } }
@global_pointer = external unnamed_addr global { %union, [2000 x i8] }, align 4 @global_pointer = external unnamed_addr global { %union, [2000 x i8] }, align 4
; Function Attrs: convergent nounwind ; Function Attrs: convergent nounwind
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

llvm/test/Verifier/dbg-invalid-vector.ll

; RUN: opt -verify -disable-output <%s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify -disable-output <%s 2>&1 | FileCheck %s
; ;
; This test creates an invalid vector by defining multiple elements for the ; This test creates an invalid vector by defining multiple elements for the
; vector's DICompositeType definition. A vector should only have one element ; vector's DICompositeType definition. A vector should only have one element
; in its DICompositeType 'elements' array. ; in its DICompositeType 'elements' array.
; ;
; CHECK: invalid vector ; CHECK: invalid vector
@f.foo = private unnamed_addr constant <6 x float> zeroinitializer, align 32 @f.foo = private unnamed_addr constant <6 x float> zeroinitializer, align 32
Show All 27 Lines

llvm/test/Verifier/di-subroutine-localvar.ll

; RUN: opt %s -verify 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax %s -verify 2>&1 | FileCheck %s
; CHECK: invalid type ; CHECK: invalid type
; CHECK: !20 = !DILocalVariable(name: "f", scope: !21, file: !13, line: 970, type: !14) ; CHECK: !20 = !DILocalVariable(name: "f", scope: !21, file: !13, line: 970, type: !14)
; CHECK: !14 = !DISubroutineType(types: !15) ; CHECK: !14 = !DISubroutineType(types: !15)
%timespec.0.1.2.3.0.1.2 = type { i64, i64 } %timespec.0.1.2.3.0.1.2 = type { i64, i64 }
define internal i64 @init_vdso_clock_gettime(i32, %timespec.0.1.2.3.0.1.2* nonnull) unnamed_addr !dbg !142 { define internal i64 @init_vdso_clock_gettime(i32, %timespec.0.1.2.3.0.1.2* nonnull) unnamed_addr !dbg !142 {
call void @llvm.dbg.value(metadata i64 (i32, %timespec.0.1.2.3.0.1.2*)* null, metadata !162, metadata !DIExpression()), !dbg !167 call void @llvm.dbg.value(metadata i64 (i32, %timespec.0.1.2.3.0.1.2*)* null, metadata !162, metadata !DIExpression()), !dbg !167
Show All 33 Lines

llvm/test/Verifier/fp-intrinsics.ll

; RUN: opt -verify -S < %s 2>&1 | FileCheck --check-prefix=CHECK1 %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify -S < %s 2>&1 | FileCheck --check-prefix=CHECK1 %s
; RUN: sed -e s/.T2:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s ; RUN: sed -e s/.T2:// %s | not opt -temporarily-allow-old-pass-syntax -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s
; RUN: sed -e s/.T3:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK3 %s ; RUN: sed -e s/.T3:// %s | not opt -temporarily-allow-old-pass-syntax -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK3 %s
; RUN: sed -e s/.T4:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK4 %s ; RUN: sed -e s/.T4:// %s | not opt -temporarily-allow-old-pass-syntax -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK4 %s
; RUN: sed -e s/.T5:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK5 %s ; RUN: sed -e s/.T5:// %s | not opt -temporarily-allow-old-pass-syntax -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK5 %s
; Common declarations used for all runs. ; Common declarations used for all runs.
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata) declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
; Test that the verifier accepts legal code, and that the correct attributes are ; Test that the verifier accepts legal code, and that the correct attributes are
; attached to the FP intrinsic. ; attached to the FP intrinsic.
; CHECK1: declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) #[[ATTR:[0-9]+]] ; CHECK1: declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata) #[[ATTR:[0-9]+]]
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

llvm/test/Verifier/non-integral-pointers.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 -verify -S < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify -S < %s 2>&1 | FileCheck %s
target datalayout = "e-ni:4:6" target datalayout = "e-ni:4:6"
define i64 @f_0(i8 addrspace(4)* %ptr) { define i64 @f_0(i8 addrspace(4)* %ptr) {
; CHECK-LABEL: @f_0( ; CHECK-LABEL: @f_0(
; CHECK-NEXT: [[VAL:%.*]] = ptrtoint i8 addrspace(4)* [[PTR:%.*]] to i64 ; CHECK-NEXT: [[VAL:%.*]] = ptrtoint i8 addrspace(4)* [[PTR:%.*]] to i64
; CHECK-NEXT: ret i64 [[VAL]] ; CHECK-NEXT: ret i64 [[VAL]]
; ;
▲ Show 20 Lines • Show All 108 Lines • Show Last 20 Lines

llvm/test/Verifier/preallocated-valid.ll

; RUN: opt -S %s -verify ; RUN: opt -temporarily-allow-old-pass-syntax -S %s -verify
declare token @llvm.call.preallocated.setup(i32) declare token @llvm.call.preallocated.setup(i32)
declare i8* @llvm.call.preallocated.arg(token, i32) declare i8* @llvm.call.preallocated.arg(token, i32)
declare void @llvm.call.preallocated.teardown(token) declare void @llvm.call.preallocated.teardown(token)
declare i32 @__CxxFrameHandler3(...) declare i32 @__CxxFrameHandler3(...)
declare void @foo1(i32* preallocated(i32)) declare void @foo1(i32* preallocated(i32))
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

llvm/test/Verifier/recursive-struct-param.ll

; RUN: opt -verify < %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify < %s
%struct.__sFILE = type { %struct.__sFILE } %struct.__sFILE = type { %struct.__sFILE }
@.str = private unnamed_addr constant [13 x i8] c"Hello world\0A\00", align 1 @.str = private unnamed_addr constant [13 x i8] c"Hello world\0A\00", align 1
; Function Attrs: nounwind ssp ; Function Attrs: nounwind ssp
define void @test(%struct.__sFILE* %stream, i8* %str) { define void @test(%struct.__sFILE* %stream, i8* %str) {
%fputs = call i32 @fputs(i8* %str, %struct.__sFILE* %stream) %fputs = call i32 @fputs(i8* %str, %struct.__sFILE* %stream)
ret void ret void
} }
; Function Attrs: nounwind ; Function Attrs: nounwind
declare i32 @fputs(i8* nocapture, %struct.__sFILE* nocapture) declare i32 @fputs(i8* nocapture, %struct.__sFILE* nocapture)

llvm/test/Verifier/statepoint.ll

; RUN: opt -S %s -verify | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -S %s -verify | FileCheck %s
declare void @use(...) declare void @use(...)
declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token, i32, i32) declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(token, i32, i32)
declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token, i32, i32) declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(token, i32, i32)
declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...) declare token @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
declare token @llvm.experimental.gc.statepoint.p0f_isVoidp0s_structsf(i64, i32, void (%struct*)*, i32, i32, ...) declare token @llvm.experimental.gc.statepoint.p0f_isVoidp0s_structsf(i64, i32, void (%struct*)*, i32, i32, ...)
declare i32 @"personality_function"() declare i32 @"personality_function"()
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

llvm/test/Verifier/swifttailcc-musttail-valid.ll

; RUN: opt -verify %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify %s
define swifttailcc void @valid_attrs(i64* sret(i64) %ret, i8* byval(i8) %byval, i8* swiftself %self, i8* swiftasync %ctx) { define swifttailcc void @valid_attrs(i64* sret(i64) %ret, i8* byval(i8) %byval, i8* swiftself %self, i8* swiftasync %ctx) {
musttail call swifttailcc void @valid_attrs(i64* sret(i64) %ret, i8* byval(i8) %byval, i8* swiftself %self, i8* swiftasync %ctx) musttail call swifttailcc void @valid_attrs(i64* sret(i64) %ret, i8* byval(i8) %byval, i8* swiftself %self, i8* swiftasync %ctx)
ret void ret void
} }
define swifttailcc void @mismatch_parms() { define swifttailcc void @mismatch_parms() {
musttail call swifttailcc void @valid_attrs(i64* sret(i64) undef, i8* byval(i8) undef, i8* swiftself undef, i8* swiftasync undef) musttail call swifttailcc void @valid_attrs(i64* sret(i64) undef, i8* byval(i8) undef, i8* swiftself undef, i8* swiftasync undef)
ret void ret void
} }

llvm/test/Verifier/tbaa.ll

; RUN: not llvm-as < %s 2>&1 | FileCheck %s ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
; RUN: llvm-as -disable-verify < %s | opt -verify -S | FileCheck %s --check-prefix=STRIP ; RUN: llvm-as -disable-verify < %s | opt -temporarily-allow-old-pass-syntax -verify -S | FileCheck %s --check-prefix=STRIP
; STRIP-NOT: tbaa ; STRIP-NOT: tbaa
; STRIP: @f_0 ; STRIP: @f_0
; STRIP: Do no strip this ; STRIP: Do no strip this
define void @f_0(i32* %ptr) { define void @f_0(i32* %ptr) {
; This part checks for the easy syntactic verifier rules. ; This part checks for the easy syntactic verifier rules.
; CHECK: Struct tag metadata must have either 3 or 4 operands ; CHECK: Struct tag metadata must have either 3 or 4 operands
▲ Show 20 Lines • Show All 113 Lines • Show Last 20 Lines

llvm/test/Verifier/vp-intrinsics.ll

; RUN: opt --verify --disable-output %s ; RUN: opt -temporarily-allow-old-pass-syntax --verify --disable-output %s
define void @test_vp_int(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) { define void @test_vp_int(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) {
%r0 = call <8 x i32> @llvm.vp.add.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r0 = call <8 x i32> @llvm.vp.add.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r1 = call <8 x i32> @llvm.vp.sub.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r1 = call <8 x i32> @llvm.vp.sub.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r2 = call <8 x i32> @llvm.vp.mul.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r2 = call <8 x i32> @llvm.vp.mul.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r3 = call <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r3 = call <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r4 = call <8 x i32> @llvm.vp.srem.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r4 = call <8 x i32> @llvm.vp.srem.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r5 = call <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r5 = call <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r6 = call <8 x i32> @llvm.vp.urem.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r6 = call <8 x i32> @llvm.vp.urem.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r7 = call <8 x i32> @llvm.vp.and.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r7 = call <8 x i32> @llvm.vp.and.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r8 = call <8 x i32> @llvm.vp.or.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r8 = call <8 x i32> @llvm.vp.or.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%r9 = call <8 x i32> @llvm.vp.xor.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %r9 = call <8 x i32> @llvm.vp.xor.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%rA = call <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %rA = call <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%rB = call <8 x i32> @llvm.vp.lshr.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %rB = call <8 x i32> @llvm.vp.lshr.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
%rC = call <8 x i32> @llvm.vp.shl.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n) %rC = call <8 x i32> @llvm.vp.shl.v8i32(<8 x i32> %i0, <8 x i32> %i1, <8 x i1> %m, i32 %n)
ret void ret void
} }
define void @test_vp_fp(<8 x double> %f0, <8 x double> %f1, <8 x i1> %m, i32 %n) { define void @test_vp_fp(<8 x double> %f0, <8 x double> %f1, <8 x i1> %m, i32 %n) {
%r0 = call <8 x double> @llvm.vp.fadd.v8f64(<8 x double> %f0, <8 x double> %f1, <8 x i1> %m, i32 %n) %r0 = call <8 x double> @llvm.vp.fadd.v8f64(<8 x double> %f0, <8 x double> %f1, <8 x i1> %m, i32 %n)
%r1 = call <8 x double> @llvm.vp.fsub.v8f64(<8 x double> %f0, <8 x double> %f1, <8 x i1> %m, i32 %n) %r1 = call <8 x double> @llvm.vp.fsub.v8f64(<8 x double> %f0, <8 x double> %f1, <8 x i1> %m, i32 %n)
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
declare <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.srem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.srem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.urem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.urem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
; bit arith ; bit arith
declare <8 x i32> @llvm.vp.and.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.and.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.or.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.or.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.xor.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.xor.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.lshr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.lshr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
declare <8 x i32> @llvm.vp.shl.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32) declare <8 x i32> @llvm.vp.shl.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)
; fp arith ; fp arith
declare <8 x double> @llvm.vp.fadd.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32) declare <8 x double> @llvm.vp.fadd.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32)
declare <8 x double> @llvm.vp.fsub.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32) declare <8 x double> @llvm.vp.fsub.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32)
declare <8 x double> @llvm.vp.fmul.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32) declare <8 x double> @llvm.vp.fmul.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32)
declare <8 x double> @llvm.vp.fdiv.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32) declare <8 x double> @llvm.vp.fdiv.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32)
declare <8 x double> @llvm.vp.frem.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32) declare <8 x double> @llvm.vp.frem.v8f64(<8 x double>, <8 x double>, <8 x i1>, i32)
; reductions ; reductions
Show All 31 Lines

llvm/test/Verifier/weak-dllimport.ll

; RUN: opt -verify < %s 2>&1 | FileCheck %s ; RUN: opt -temporarily-allow-old-pass-syntax -verify < %s 2>&1 | FileCheck %s
; CHECK-NOT: Global is marked as dllimport, but not external ; CHECK-NOT: Global is marked as dllimport, but not external
target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc19.11.0" target triple = "x86_64-pc-windows-msvc19.11.0"
@"?var_hook@@3HA" = extern_weak dllimport global i32, align 4 @"?var_hook@@3HA" = extern_weak dllimport global i32, align 4
; Function Attrs: noinline optnone uwtable ; Function Attrs: noinline optnone uwtable
Show All 19 Lines

llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/x86-loopvectorize-costmodel.ll

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+ for VF [0-9]+ For instruction:\s*%v0 = load float, float\* %in0, align 4" ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+ for VF [0-9]+ For instruction:\s*%v0 = load float, float\* %in0, align 4"
; RUN: opt -loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt -temporarily-allow-old-pass-syntax -loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,AVX512
; REQUIRES: asserts ; REQUIRES: asserts
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = global [1024 x float] zeroinitializer, align 128 @A = global [1024 x float] zeroinitializer, align 128
@B = global [1024 x i8] zeroinitializer, align 128 @B = global [1024 x i8] zeroinitializer, align 128
Show All 30 Lines

llvm/test/tools/UpdateTestChecks/update_analyze_test_checks/Inputs/x86-loopvectorize-costmodel.ll.expected

; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+ for VF [0-9]+ For instruction:\s*%v0 = load float, float\* %in0, align 4" ; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --filter "LV: Found an estimated cost of [0-9]+ for VF [0-9]+ For instruction:\s*%v0 = load float, float\* %in0, align 4"
; RUN: opt -loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,AVX512 ; RUN: opt -temporarily-allow-old-pass-syntax -loop-vectorize -vectorizer-maximize-bandwidth -S -mattr=+avx512bw --debug-only=loop-vectorize < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,AVX512
; REQUIRES: asserts ; REQUIRES: asserts
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"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@A = global [1024 x float] zeroinitializer, align 128 @A = global [1024 x float] zeroinitializer, align 128
@B = global [1024 x i8] zeroinitializer, align 128 @B = global [1024 x i8] zeroinitializer, align 128
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

llvm/test/tools/llvm-reduce/remove-function-bodies-comdat.ll

; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t ; RUN: llvm-reduce --test FileCheck --test-arg --check-prefixes=CHECK-ALL,CHECK-INTERESTINGNESS --test-arg %s --test-arg --input-file %s -o %t
; RUN: cat %t | FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s ; RUN: cat %t | FileCheck --check-prefixes=CHECK-ALL,CHECK-FINAL %s
; RUN: opt -verify %t ; RUN: opt -temporarily-allow-old-pass-syntax -verify %t
; CHECK-FINAL-NOT: = comdat ; CHECK-FINAL-NOT: = comdat
; CHECK-INTERESTINGNESS: @callee( ; CHECK-INTERESTINGNESS: @callee(
; CHECK-FINAL: declare void @callee() ; CHECK-FINAL: declare void @callee()
$foo = comdat any $foo = comdat any
define void @callee() comdat($foo) { define void @callee() comdat($foo) {
Show All 11 Lines

llvm/tools/opt/opt.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
static cl::opt<std::string> PassPipeline( static cl::opt<std::string> PassPipeline(
"passes", "passes",
cl::desc( cl::desc(
"A textual description of the pass pipeline. To have analysis passes " "A textual description of the pass pipeline. To have analysis passes "
"available before a certain pass, add 'require<foo-analysis>'.")); "available before a certain pass, add 'require<foo-analysis>'."));
static cl::alias PassPipeline2("p", cl::aliasopt(PassPipeline), static cl::alias PassPipeline2("p", cl::aliasopt(PassPipeline),
cl::desc("Alias for -passes")); cl::desc("Alias for -passes"));
static cl::opt<bool> TemporarilyAllowOldPassesSyntax(
aeubanksUnsubmitted
Not Done
ReplyInline Actions
cl::desc("Alias for -passes"));
- static cl::opt<bool> TemporairlyAllowOldPassesSyntax(
+ static cl::opt<bool> TemporarilyAllowOldPassesSyntax(
"temporarily-allow-old-pass-syntax",
aeubanks:
"temporarily-allow-old-pass-syntax",
cl::desc("Do not use in new tests. To be removed once all tests have "
"migrated."),
cl::init(false));
static cl::opt<bool> PrintPasses("print-passes", static cl::opt<bool> PrintPasses("print-passes",
cl::desc("Print available passes that can be " cl::desc("Print available passes that can be "
"specified in -passes=foo and exit")); "specified in -passes=foo and exit"));
static cl::opt<std::string> static cl::opt<std::string>
InputFilename(cl::Positional, cl::desc("<input bitcode file>"), InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
cl::init("-"), cl::value_desc("filename")); cl::init("-"), cl::value_desc("filename"));
▲ Show 20 Lines • Show All 575 Lines • ▼ Show 20 Lines if (NumOLevel > 0 &&
return 1; return 1;
} }
if (!PassList.empty()) { if (!PassList.empty()) {
errs() << "The `opt -passname` syntax for the new pass manager is " errs() << "The `opt -passname` syntax for the new pass manager is "
"deprecated, please use `opt -passes=<pipeline>` (or the `-p` " "deprecated, please use `opt -passes=<pipeline>` (or the `-p` "
"alias for a more concise version).\n"; "alias for a more concise version).\n";
errs() << "See https://llvm.org/docs/NewPassManager.html#invoking-opt " errs() << "See https://llvm.org/docs/NewPassManager.html#invoking-opt "
"for more details on the pass pipeline syntax.\n\n"; "for more details on the pass pipeline syntax.\n\n";
if (!TemporarilyAllowOldPassesSyntax)
return 1;
} }
std::string Pipeline = PassPipeline; std::string Pipeline = PassPipeline;
SmallVector<StringRef, 4> Passes; SmallVector<StringRef, 4> Passes;
if (OptLevelO0) if (OptLevelO0)
Pipeline = "default<O0>"; Pipeline = "default<O0>";
if (OptLevelO1) if (OptLevelO1)
Pipeline = "default<O1>"; Pipeline = "default<O1>";
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines