This is an archive of the discontinued LLVM Phabricator instance.

Differential D84694

[FunctionAttrs] Rename functionattrs -> function-attrs
ClosedPublic

Authored by aeubanks on Jul 27 2020, 12:10 PM.

Details

Reviewers
ychen
hans
asbirlea
jdoerfert
sstefan1
baziotis
arsenm
Commits
rG2ca6c422d2d0: [FunctionAttrs] Rename functionattrs -> function-attrs
Summary

To match NewPM pass name, and also for readability.
Also rename rpo-functionattrs -> rpo-function-attrs while we're here.

Diff Detail

Event Timeline

aeubanks created this revision.Jul 27 2020, 12:10 PM
Herald added a project: Restricted Project. · View Herald TranscriptJul 27 2020, 12:10 PM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
arsenm added a subscriber: arsenm.Jul 27 2020, 12:12 PM

I think this is the backwards direction. I think most passes consistently use - as a word separator, and the annoying cases do not

aeubanks added a comment.Jul 27 2020, 12:21 PM
In D84694#2176745, @arsenm wrote:

I think this is the backwards direction. I think most passes consistently use - as a word separator, and the annoying cases do not

Sure I can go the other direction, I went this way because it was more consistent with relevant passes, but I agree that a dash is better overall.
Looks like I'd only have to update 43 tests for "functionattrs" -> "function-attrs".

aeubanks updated this revision to Diff 281025.Jul 27 2020, 12:43 PM

Rename the other way

Herald added a reviewer: jdoerfert. · View Herald TranscriptJul 27 2020, 12:43 PM
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a reviewer: baziotis. · View Herald Transcript
Herald added subscribers: okura, bbn, kuter, george.burgess.iv. · View Herald Transcript
aeubanks retitled this revision from [NewPM] Rename function-attrs -> functionattrs to [FunctionAttrs] Rename functionattrs -> function-attrs.Jul 27 2020, 12:44 PM
aeubanks edited the summary of this revision. (Show Details)
aeubanks added a reviewer: arsenm.
Herald added a subscriber: wdng. · View Herald TranscriptJul 27 2020, 12:44 PM
Harbormaster failed remote builds in B65897: Diff 281011!Jul 27 2020, 2:17 PM
Harbormaster failed remote builds in B65904: Diff 281025!Jul 27 2020, 2:54 PM
arsenm accepted this revision.Jul 27 2020, 3:38 PM
This revision is now accepted and ready to land.Jul 27 2020, 3:38 PM
This revision was landed with ongoing or failed builds.Jul 28 2020, 9:09 AM
Closed by commit rG2ca6c422d2d0: [FunctionAttrs] Rename functionattrs -> function-attrs (authored by aeubanks). · Explain Why
This revision was automatically updated to reflect the committed changes.
aeubanks added a commit: rG2ca6c422d2d0: [FunctionAttrs] Rename functionattrs -> function-attrs.

Revision Contents

PathSize
llvm/
docs/
6 lines
lib/
Passes/
2 lines
Target/
6 lines
Transforms/
IPO/
16 lines
test/
Analysis/
MemorySSA/
2 lines
TypeBasedAliasAnalysis/
2 lines
2 lines
DebugInfo/
4 lines
Feature/
OperandBundles/
2 lines
2 lines
Transforms/
FunctionAttrs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
GlobalDCE/
2 lines
IndVarSimplify/
2 lines
Inline/
2 lines
InstCombine/
2 lines
LoopUnswitch/
2 lines
Reassociate/
2 lines
SimpleLoopUnswitch/
2 lines

Diff 281251

llvm/docs/Passes.rst

Show First 20 Lines • Show All 516 Lines • ▼ Show 20 Lines
instructions that are obviously dead. instructions that are obviously dead.
``-dse``: Dead Store Elimination ``-dse``: Dead Store Elimination
-------------------------------- --------------------------------
A trivial dead store elimination that only considers basic-block local A trivial dead store elimination that only considers basic-block local
redundant stores. redundant stores.
.. _passes-functionattrs: .. _passes-function-attrs:
``-functionattrs``: Deduce function attributes ``-function-attrs``: Deduce function attributes
---------------------------------------------- ----------------------------------------------
A simple interprocedural pass which walks the call-graph, looking for functions A simple interprocedural pass which walks the call-graph, looking for functions
which do not access or only read non-local memory, and marking them which do not access or only read non-local memory, and marking them
``readnone``/``readonly``. In addition, it marks function arguments (of ``readnone``/``readonly``. In addition, it marks function arguments (of
pointer type) "``nocapture``" if a call to the function does not create any pointer type) "``nocapture``" if a call to the function does not create any
copies of the pointer value that outlive the call. This more or less means copies of the pointer value that outlive the call. This more or less means
that the pointer is only dereferenced, and not returned from the function or that the pointer is only dereferenced, and not returned from the function or
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Lines
#. Multiplies with a constant power-of-two argument are transformed into #. Multiplies with a constant power-of-two argument are transformed into
shifts. shifts.
#. … etc. #. … etc.
This pass can also simplify calls to specific well-known function calls (e.g. This pass can also simplify calls to specific well-known function calls (e.g.
runtime library functions). For example, a call ``exit(3)`` that occurs within runtime library functions). For example, a call ``exit(3)`` that occurs within
the ``main()`` function can be transformed into simply ``return 3``. Whether or the ``main()`` function can be transformed into simply ``return 3``. Whether or
not library calls are simplified is controlled by the not library calls are simplified is controlled by the
:ref:`-functionattrs <passes-functionattrs>` pass and LLVM's knowledge of :ref:`-function-attrs <passes-function-attrs>` pass and LLVM's knowledge of
library calls on different targets. library calls on different targets.
.. _passes-aggressive-instcombine: .. _passes-aggressive-instcombine:
``-aggressive-instcombine``: Combine expression patterns ``-aggressive-instcombine``: Combine expression patterns
-------------------------------------------------------- --------------------------------------------------------
Combine expression patterns to form expressions with fewer, simple instructions. Combine expression patterns to form expressions with fewer, simple instructions.
▲ Show 20 Lines • Show All 585 Lines • Show Last 20 Lines

llvm/lib/Passes/PassRegistry.def

Show First 20 Lines • Show All 75 Lines • ▼ Show 20 Lines
MODULE_PASS("print-profile-summary", ProfileSummaryPrinterPass(dbgs())) MODULE_PASS("print-profile-summary", ProfileSummaryPrinterPass(dbgs()))
MODULE_PASS("print-callgraph", CallGraphPrinterPass(dbgs())) MODULE_PASS("print-callgraph", CallGraphPrinterPass(dbgs()))
MODULE_PASS("print", PrintModulePass(dbgs())) MODULE_PASS("print", PrintModulePass(dbgs()))
MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(dbgs())) MODULE_PASS("print-lcg", LazyCallGraphPrinterPass(dbgs()))
MODULE_PASS("print-lcg-dot", LazyCallGraphDOTPrinterPass(dbgs())) MODULE_PASS("print-lcg-dot", LazyCallGraphDOTPrinterPass(dbgs()))
MODULE_PASS("print-stack-safety", StackSafetyGlobalPrinterPass(dbgs())) MODULE_PASS("print-stack-safety", StackSafetyGlobalPrinterPass(dbgs()))
MODULE_PASS("rewrite-statepoints-for-gc", RewriteStatepointsForGC()) MODULE_PASS("rewrite-statepoints-for-gc", RewriteStatepointsForGC())
MODULE_PASS("rewrite-symbols", RewriteSymbolPass()) MODULE_PASS("rewrite-symbols", RewriteSymbolPass())
MODULE_PASS("rpo-functionattrs", ReversePostOrderFunctionAttrsPass()) MODULE_PASS("rpo-function-attrs", ReversePostOrderFunctionAttrsPass())
MODULE_PASS("sample-profile", SampleProfileLoaderPass()) MODULE_PASS("sample-profile", SampleProfileLoaderPass())
MODULE_PASS("scc-oz-module-inliner", MODULE_PASS("scc-oz-module-inliner",
buildInlinerPipeline(OptimizationLevel::Oz, ThinLTOPhase::None, DebugLogging)) buildInlinerPipeline(OptimizationLevel::Oz, ThinLTOPhase::None, DebugLogging))
MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass()) MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())
MODULE_PASS("synthetic-counts-propagation", SyntheticCountsPropagation()) MODULE_PASS("synthetic-counts-propagation", SyntheticCountsPropagation())
MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass(nullptr, nullptr)) MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass(nullptr, nullptr))
MODULE_PASS("verify", VerifierPass()) MODULE_PASS("verify", VerifierPass())
MODULE_PASS("asan-module", ModuleAddressSanitizerPass(/*CompileKernel=*/false, false, true, false)) MODULE_PASS("asan-module", ModuleAddressSanitizerPass(/*CompileKernel=*/false, false, true, false))
▲ Show 20 Lines • Show All 268 Lines • Show Last 20 Lines

llvm/lib/Target/README.txt

Show First 20 Lines • Show All 1,535 Lines • ▼ Show 20 Lines
libanalysis' constantfolding logic. This would allow IPSCCP to be able to libanalysis' constantfolding logic. This would allow IPSCCP to be able to
handle simple things like this: handle simple things like this:
static int foo(const char *X) { return strlen(X); } static int foo(const char *X) { return strlen(X); }
int bar() { return foo("abcd"); } int bar() { return foo("abcd"); }
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
functionattrs doesn't know much about memcpy/memset. This function should be function-attrs doesn't know much about memcpy/memset. This function should be
marked readnone rather than readonly, since it only twiddles local memory, but marked readnone rather than readonly, since it only twiddles local memory, but
functionattrs doesn't handle memset/memcpy/memmove aggressively: function-attrs doesn't handle memset/memcpy/memmove aggressively:
struct X { int *p; int *q; }; struct X { int *p; int *q; };
int foo() { int foo() {
int i = 0, j = 1; int i = 0, j = 1;
struct X x, y; struct X x, y;
int **p; int **p;
y.p = &i; y.p = &i;
x.q = &j; x.q = &j;
p = __builtin_memcpy (&x, &y, sizeof (int *)); p = __builtin_memcpy (&x, &y, sizeof (int *));
return **p; return **p;
} }
This can be seen at: This can be seen at:
$ clang t.c -S -o - -mkernel -O0 -emit-llvm | opt -functionattrs -S $ clang t.c -S -o - -mkernel -O0 -emit-llvm | opt -function-attrs -S
//===---------------------------------------------------------------------===// //===---------------------------------------------------------------------===//
Missed instcombine transformation: Missed instcombine transformation:
define i1 @a(i32 %x) nounwind readnone { define i1 @a(i32 %x) nounwind readnone {
entry: entry:
%cmp = icmp eq i32 %x, 30 %cmp = icmp eq i32 %x, 30
▲ Show 20 Lines • Show All 711 Lines • Show Last 20 Lines

llvm/lib/Transforms/IPO/FunctionAttrs.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
#include "llvm/Transforms/IPO.h" #include "llvm/Transforms/IPO.h"
#include <cassert> #include <cassert>
#include <iterator> #include <iterator>
#include <map> #include <map>
#include <vector> #include <vector>
using namespace llvm; using namespace llvm;
#define DEBUG_TYPE "functionattrs" #define DEBUG_TYPE "function-attrs"
STATISTIC(NumReadNone, "Number of functions marked readnone"); STATISTIC(NumReadNone, "Number of functions marked readnone");
STATISTIC(NumReadOnly, "Number of functions marked readonly"); STATISTIC(NumReadOnly, "Number of functions marked readonly");
STATISTIC(NumWriteOnly, "Number of functions marked writeonly"); STATISTIC(NumWriteOnly, "Number of functions marked writeonly");
STATISTIC(NumNoCapture, "Number of arguments marked nocapture"); STATISTIC(NumNoCapture, "Number of arguments marked nocapture");
STATISTIC(NumReturned, "Number of arguments marked returned"); STATISTIC(NumReturned, "Number of arguments marked returned");
STATISTIC(NumReadNoneArg, "Number of arguments marked readnone"); STATISTIC(NumReadNoneArg, "Number of arguments marked readnone");
STATISTIC(NumReadOnlyArg, "Number of arguments marked readonly"); STATISTIC(NumReadOnlyArg, "Number of arguments marked readonly");
▲ Show 20 Lines • Show All 1,397 Lines • ▼ Show 20 Lines void getAnalysisUsage(AnalysisUsage &AU) const override {
getAAResultsAnalysisUsage(AU); getAAResultsAnalysisUsage(AU);
CallGraphSCCPass::getAnalysisUsage(AU); CallGraphSCCPass::getAnalysisUsage(AU);
} }
}; };
} // end anonymous namespace } // end anonymous namespace
char PostOrderFunctionAttrsLegacyPass::ID = 0; char PostOrderFunctionAttrsLegacyPass::ID = 0;
INITIALIZE_PASS_BEGIN(PostOrderFunctionAttrsLegacyPass, "functionattrs", INITIALIZE_PASS_BEGIN(PostOrderFunctionAttrsLegacyPass, "function-attrs",
"Deduce function attributes", false, false) "Deduce function attributes", false, false)
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker) INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass) INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
INITIALIZE_PASS_END(PostOrderFunctionAttrsLegacyPass, "functionattrs", INITIALIZE_PASS_END(PostOrderFunctionAttrsLegacyPass, "function-attrs",
"Deduce function attributes", false, false) "Deduce function attributes", false, false)
Pass *llvm::createPostOrderFunctionAttrsLegacyPass() { Pass *llvm::createPostOrderFunctionAttrsLegacyPass() {
return new PostOrderFunctionAttrsLegacyPass(); return new PostOrderFunctionAttrsLegacyPass();
} }
template <typename AARGetterT> template <typename AARGetterT>
static bool runImpl(CallGraphSCC &SCC, AARGetterT AARGetter) { static bool runImpl(CallGraphSCC &SCC, AARGetterT AARGetter) {
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addPreserved<CallGraphWrapperPass>(); AU.addPreserved<CallGraphWrapperPass>();
} }
}; };
} // end anonymous namespace } // end anonymous namespace
char ReversePostOrderFunctionAttrsLegacyPass::ID = 0; char ReversePostOrderFunctionAttrsLegacyPass::ID = 0;
INITIALIZE_PASS_BEGIN(ReversePostOrderFunctionAttrsLegacyPass, "rpo-functionattrs", INITIALIZE_PASS_BEGIN(ReversePostOrderFunctionAttrsLegacyPass,
"Deduce function attributes in RPO", false, false) "rpo-function-attrs", "Deduce function attributes in RPO",
false, false)
INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass) INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
INITIALIZE_PASS_END(ReversePostOrderFunctionAttrsLegacyPass, "rpo-functionattrs", INITIALIZE_PASS_END(ReversePostOrderFunctionAttrsLegacyPass,
"Deduce function attributes in RPO", false, false) "rpo-function-attrs", "Deduce function attributes in RPO",
false, false)
Pass *llvm::createReversePostOrderFunctionAttrsPass() { Pass *llvm::createReversePostOrderFunctionAttrsPass() {
return new ReversePostOrderFunctionAttrsLegacyPass(); return new ReversePostOrderFunctionAttrsLegacyPass();
} }
static bool addNoRecurseAttrsTopDown(Function &F) { static bool addNoRecurseAttrsTopDown(Function &F) {
// We check the preconditions for the function prior to calling this to avoid // We check the preconditions for the function prior to calling this to avoid
// the cost of building up a reversible post-order list. We assert them here // the cost of building up a reversible post-order list. We assert them here
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

llvm/test/Analysis/MemorySSA/pr39197.ll

; RUN: opt -mtriple=s390x-linux-gnu -mcpu=z13 -enable-mssa-loop-dependency -verify-memoryssa -sroa -globalopt -functionattrs -simplifycfg -licm -loop-unswitch %s -S | FileCheck %s ; RUN: opt -mtriple=s390x-linux-gnu -mcpu=z13 -enable-mssa-loop-dependency -verify-memoryssa -sroa -globalopt -function-attrs -simplifycfg -licm -loop-unswitch %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"
@0 = internal global i32 -9, align 4 @0 = internal global i32 -9, align 4
@1 = internal global i64 9, align 8 @1 = internal global i64 9, align 8
@g_1042 = external dso_local global [5 x i16], align 2 @g_1042 = external dso_local global [5 x i16], align 2
▲ Show 20 Lines • Show All 144 Lines • Show Last 20 Lines

llvm/test/Analysis/TypeBasedAliasAnalysis/functionattrs.ll

; RUN: opt < %s -tbaa -basic-aa -functionattrs -S | FileCheck %s ; RUN: opt < %s -tbaa -basic-aa -function-attrs -S | FileCheck %s
; FunctionAttrs should make use of TBAA. ; FunctionAttrs should make use of TBAA.
; Add the readnone attribute, since the only access is a store which TBAA ; Add the readnone attribute, since the only access is a store which TBAA
; says is to constant memory. ; says is to constant memory.
; ;
; It's unusual to see a store to constant memory, but it isn't necessarily ; It's unusual to see a store to constant memory, but it isn't necessarily
; invalid, as it's possible that this only happens after optimization on a ; invalid, as it's possible that this only happens after optimization on a
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

llvm/test/Analysis/alias-analysis-uses.ll

; RUN: opt -debug-pass=Executions -globals-aa -functionattrs -disable-output < %s 2>&1 | FileCheck %s ; RUN: opt -debug-pass=Executions -globals-aa -function-attrs -disable-output < %s 2>&1 | FileCheck %s
; CHECK: Executing Pass 'Globals Alias Analysis' ; CHECK: Executing Pass 'Globals Alias Analysis'
; CHECK-NOT: Freeing Pass 'Globals Alias Analysis' ; CHECK-NOT: Freeing Pass 'Globals Alias Analysis'
; CHECK: Executing Pass 'Deduce function attributes' ; CHECK: Executing Pass 'Deduce function attributes'
; CHECK: Freeing Pass 'Globals Alias Analysis' ; CHECK: Freeing Pass 'Globals Alias Analysis'
define void @test(i8* %p) { define void @test(i8* %p) {
ret void ret void
} }

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

; RUN: opt < %s -globals-aa -functionattrs | \ ; RUN: opt < %s -globals-aa -function-attrs | \
; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.no_dbg ; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.no_dbg
; RUN: opt < %s -debugify-each -globals-aa -functionattrs | \ ; RUN: opt < %s -debugify-each -globals-aa -function-attrs | \
; RUN: opt -S -strip -strip-dead-prototypes -strip-named-metadata > %t.with_dbg ; RUN: opt -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/Feature/OperandBundles/function-attrs.ll

; RUN: opt -S -functionattrs < %s | FileCheck %s ; RUN: opt -S -function-attrs < %s | FileCheck %s
declare void @f_readonly() readonly declare void @f_readonly() readonly
declare void @f_readnone() readnone declare void @f_readnone() readnone
define void @test_0(i32* %x) { define void @test_0(i32* %x) {
; FunctionAttrs must not infer readonly / readnone for %x ; FunctionAttrs must not infer readonly / readnone for %x
; CHECK-LABEL: define void @test_0(i32* %x) #2 { ; CHECK-LABEL: define void @test_0(i32* %x) #2 {
Show All 27 Lines

llvm/test/Feature/OperandBundles/pr26510.ll

; RUN: opt -S -globals-aa -functionattrs < %s | FileCheck %s ; RUN: opt -S -globals-aa -function-attrs < %s | FileCheck %s
; RUN: opt -S -O3 < %s | FileCheck %s ; RUN: opt -S -O3 < %s | FileCheck %s
; Apart from checking for the direct cause of the bug, we also check ; Apart from checking for the direct cause of the bug, we also check
; if any problematic aliasing rules have accidentally snuck into -O3. ; if any problematic aliasing rules have accidentally snuck into -O3.
; ;
; Since the "abc" operand bundle is not a special operand bundle that ; Since the "abc" operand bundle is not a special operand bundle that
; LLVM knows about, all of the stores and loads in @test below have to ; LLVM knows about, all of the stores and loads in @test below have to
; stay. ; stay.
Show All 18 Lines

llvm/test/Transforms/FunctionAttrs/2008-09-03-Mutual.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-SAME: readnone ; CHECK-SAME: readnone
; CHECK-NEXT: define i32 @a ; CHECK-NEXT: define i32 @a
define i32 @a() { define i32 @a() {
%tmp = call i32 @b( ) ; <i32> [#uses=1] %tmp = call i32 @b( ) ; <i32> [#uses=1]
ret i32 %tmp ret i32 %tmp
Show All 9 Lines

llvm/test/Transforms/FunctionAttrs/2008-09-03-ReadNone.ll

; RUN: opt < %s -basic-aa -functionattrs -S | FileCheck %s ; RUN: opt < %s -basic-aa -function-attrs -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s
@x = global i32 0 @x = global i32 0
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-SAME: readnone ; CHECK-SAME: readnone
; CHECK-NEXT: declare i32 @e ; CHECK-NEXT: declare i32 @e
declare i32 @e() readnone declare i32 @e() readnone
Show All 23 Lines

llvm/test/Transforms/FunctionAttrs/2008-09-03-ReadOnly.ll

; RUN: opt < %s -basic-aa -functionattrs -S | FileCheck %s ; RUN: opt < %s -basic-aa -function-attrs -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s
; CHECK: define i32 @f() #0 ; CHECK: define i32 @f() #0
define i32 @f() { define i32 @f() {
entry: entry:
%tmp = call i32 @e( ) %tmp = call i32 @e( )
ret i32 %tmp ret i32 %tmp
} }
; CHECK: declare i32 @e() #0 ; CHECK: declare i32 @e() #0
declare i32 @e() readonly declare i32 @e() readonly
; CHECK: attributes #0 = { readonly } ; CHECK: attributes #0 = { readonly }

llvm/test/Transforms/FunctionAttrs/2008-09-13-VolatileRead.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; PR2792 ; PR2792
@g = global i32 0 ; <i32*> [#uses=1] @g = global i32 0 ; <i32*> [#uses=1]
define i32 @f() { define i32 @f() {
%t = load volatile i32, i32* @g ; <i32> [#uses=1] %t = load volatile i32, i32* @g ; <i32> [#uses=1]
ret i32 %t ret i32 %t
} }
; CHECK-NOT: attributes #{{.*}} read ; CHECK-NOT: attributes #{{.*}} read

llvm/test/Transforms/FunctionAttrs/2008-12-29-Constant.ll

; RUN: opt < %s -basic-aa -functionattrs -S | FileCheck %s ; RUN: opt < %s -basic-aa -function-attrs -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes=function-attrs -S | FileCheck %s
@s = external constant i8 ; <i8*> [#uses=1] @s = external constant i8 ; <i8*> [#uses=1]
; CHECK: define i8 @f() #0 ; CHECK: define i8 @f() #0
define i8 @f() { define i8 @f() {
%tmp = load i8, i8* @s ; <i8> [#uses=1] %tmp = load i8, i8* @s ; <i8> [#uses=1]
ret i8 %tmp ret i8 %tmp
} }
; CHECK: attributes #0 = { {{.*}} readnone ; CHECK: attributes #0 = { {{.*}} readnone

llvm/test/Transforms/FunctionAttrs/2009-01-02-LocalStores.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; CHECK: define i32* @a(i32** nocapture readonly %p) ; CHECK: define i32* @a(i32** nocapture readonly %p)
define i32* @a(i32** %p) { define i32* @a(i32** %p) {
%tmp = load i32*, i32** %p %tmp = load i32*, i32** %p
ret i32* %tmp ret i32* %tmp
} }
Show All 15 Lines

llvm/test/Transforms/FunctionAttrs/2010-10-30-volatile.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; PR8279 ; PR8279
@g = constant i32 1 @g = constant i32 1
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-SAME: norecurse ; CHECK-SAME: norecurse
; CHECK-NOT: readonly ; CHECK-NOT: readonly
; CHECK-NEXT: void @foo() ; CHECK-NEXT: void @foo()
define void @foo() { define void @foo() {
%tmp = load volatile i32, i32* @g %tmp = load volatile i32, i32* @g
ret void ret void
} }

llvm/test/Transforms/FunctionAttrs/arg_returned.ll

; RUN: opt -functionattrs -S < %s | FileCheck %s --check-prefix=FNATTR ; RUN: opt -function-attrs -S < %s | FileCheck %s --check-prefix=FNATTR
; ;
; Test cases specifically designed for the "returned" argument attribute. ; Test cases specifically designed for the "returned" argument attribute.
; We use FIXME's to indicate problems and missing attributes. ; We use FIXME's to indicate problems and missing attributes.
; ;
; TEST SCC test returning an integer value argument ; TEST SCC test returning an integer value argument
; ;
; ;
▲ Show 20 Lines • Show All 672 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/assume.ll

; RUN: opt -S -o - -functionattrs %s | FileCheck %s ; RUN: opt -S -o - -function-attrs %s | FileCheck %s
; RUN: opt -S -o - -passes=function-attrs %s | FileCheck %s ; RUN: opt -S -o - -passes=function-attrs %s | FileCheck %s
; CHECK-NOT: readnone ; CHECK-NOT: readnone
declare void @llvm.assume(i1) declare void @llvm.assume(i1)

llvm/test/Transforms/FunctionAttrs/atomic.ll

; RUN: opt -basic-aa -functionattrs -S < %s | FileCheck %s ; RUN: opt -basic-aa -function-attrs -S < %s | FileCheck %s
; RUN: opt -aa-pipeline=basic-aa -passes=function-attrs -S < %s | FileCheck %s ; RUN: opt -aa-pipeline=basic-aa -passes=function-attrs -S < %s | FileCheck %s
; Atomic load/store to local doesn't affect whether a function is ; Atomic load/store to local doesn't affect whether a function is
; readnone/readonly. ; readnone/readonly.
define i32 @test1(i32 %x) uwtable ssp { define i32 @test1(i32 %x) uwtable ssp {
; CHECK: define i32 @test1(i32 %x) #0 { ; CHECK: define i32 @test1(i32 %x) #0 {
entry: entry:
%x.addr = alloca i32, align 4 %x.addr = alloca i32, align 4
Show All 15 Lines

llvm/test/Transforms/FunctionAttrs/comdat-ipo.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; See PR26774 ; See PR26774
; CHECK-LABEL: define void @bar(i8* readonly %0) { ; CHECK-LABEL: define void @bar(i8* readonly %0) {
define void @bar(i8* readonly) { define void @bar(i8* readonly) {
call void @foo(i8* %0) call void @foo(i8* %0)
ret void ret void
} }
; CHECK-LABEL: define linkonce_odr void @foo(i8* readonly %0) { ; CHECK-LABEL: define linkonce_odr void @foo(i8* readonly %0) {
define linkonce_odr void @foo(i8* readonly) { define linkonce_odr void @foo(i8* readonly) {
call void @bar(i8* %0) call void @bar(i8* %0)
ret void ret void
} }

llvm/test/Transforms/FunctionAttrs/convergent.ll

; FIXME: convert CHECK-INDIRECT into CHECK (and remove -check-prefixes) as soon ; FIXME: convert CHECK-INDIRECT into CHECK (and remove -check-prefixes) as soon
; FIXME: as new-pass-manager's handling of indirect_non_convergent_call is fixed ; FIXME: as new-pass-manager's handling of indirect_non_convergent_call is fixed
; ;
; RUN: opt -functionattrs -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK-INDIRECT ; RUN: opt -function-attrs -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK-INDIRECT
; RUN: opt -passes=function-attrs -S < %s | FileCheck %s ; RUN: opt -passes=function-attrs -S < %s | FileCheck %s
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-NOT: convergent ; CHECK-NOT: convergent
; CHECK-NEXT: define i32 @nonleaf() ; CHECK-NEXT: define i32 @nonleaf()
define i32 @nonleaf() convergent { define i32 @nonleaf() convergent {
%a = call i32 @leaf() %a = call i32 @leaf()
ret i32 %a ret i32 %a
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/incompatible_fn_attrs.ll

; RUN: opt -S -o - -functionattrs %s | FileCheck %s ; RUN: opt -S -o - -function-attrs %s | FileCheck %s
; RUN: opt -S -o - -passes=function-attrs %s | FileCheck %s ; RUN: opt -S -o - -passes=function-attrs %s | FileCheck %s
; Verify we remove argmemonly/inaccessiblememonly/inaccessiblemem_or_argmemonly ; Verify we remove argmemonly/inaccessiblememonly/inaccessiblemem_or_argmemonly
; function attributes when we derive readnone. ; function attributes when we derive readnone.
; Function Attrs: argmemonly ; Function Attrs: argmemonly
define i32* @given_argmem_infer_readnone(i32* %p) #0 { define i32* @given_argmem_infer_readnone(i32* %p) #0 {
; CHECK: define i32* @given_argmem_infer_readnone(i32* readnone returned %p) #0 { ; CHECK: define i32* @given_argmem_infer_readnone(i32* readnone returned %p) #0 {
Show All 23 Lines

llvm/test/Transforms/FunctionAttrs/int_sideeffect.ll

; RUN: opt -S < %s -functionattrs | FileCheck %s ; RUN: opt -S < %s -function-attrs | FileCheck %s
; RUN: opt -S < %s -passes=function-attrs | FileCheck %s ; RUN: opt -S < %s -passes=function-attrs | FileCheck %s
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-SAME: inaccessiblememonly ; CHECK-SAME: inaccessiblememonly
; CHECK-NEXT: declare void @llvm.sideeffect() ; CHECK-NEXT: declare void @llvm.sideeffect()
declare void @llvm.sideeffect() declare void @llvm.sideeffect()
; Don't add readnone or similar attributes when an @llvm.sideeffect() intrinsic ; Don't add readnone or similar attributes when an @llvm.sideeffect() intrinsic
Show All 20 Lines

llvm/test/Transforms/FunctionAttrs/naked_functions.ll

; RUN: opt -S -functionattrs %s | FileCheck %s ; RUN: opt -S -function-attrs %s | FileCheck %s
; RUN: opt -S -passes='function-attrs' %s | FileCheck %s ; RUN: opt -S -passes='function-attrs' %s | FileCheck %s
; Don't change the attributes of parameters of naked functions, in particular ; Don't change the attributes of parameters of naked functions, in particular
; don't mark them as readnone ; don't mark them as readnone
@g = common global i32 0, align 4 @g = common global i32 0, align 4
define i32 @bar() { define i32 @bar() {
Show All 16 Lines

llvm/test/Transforms/FunctionAttrs/nocapture.ll

; RUN: opt -functionattrs -S < %s | FileCheck %s --check-prefixes=FNATTR ; RUN: opt -function-attrs -S < %s | FileCheck %s --check-prefixes=FNATTR
; RUN: opt -passes=function-attrs -S < %s | FileCheck %s --check-prefixes=FNATTR ; RUN: opt -passes=function-attrs -S < %s | FileCheck %s --check-prefixes=FNATTR
@g = global i32* null ; <i32**> [#uses=1] @g = global i32* null ; <i32**> [#uses=1]
; FNATTR: define i32* @c1(i32* readnone returned %q) ; FNATTR: define i32* @c1(i32* readnone returned %q)
define i32* @c1(i32* %q) { define i32* @c1(i32* %q) {
ret i32* %q ret i32* %q
} }
▲ Show 20 Lines • Show All 312 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/nofree-attributor.ll

; RUN: opt -functionattrs --disable-nofree-inference=false -S < %s | FileCheck %s --check-prefix=FNATTR ; RUN: opt -function-attrs --disable-nofree-inference=false -S < %s | FileCheck %s --check-prefix=FNATTR
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"
; Test cases specifically designed for the "nofree" function attribute. ; Test cases specifically designed for the "nofree" function attribute.
; We use FIXME's to indicate problems and missing attributes. ; We use FIXME's to indicate problems and missing attributes.
; Free functions ; Free functions
declare void @free(i8* nocapture) local_unnamed_addr #1 declare void @free(i8* nocapture) local_unnamed_addr #1
▲ Show 20 Lines • Show All 197 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/nofree.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -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"
; CHECK: define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 { ; CHECK: define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 {
define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 { define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 {
entry: entry:
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/nonnull-global.ll

; RUN: opt -S -functionattrs %s | FileCheck %s ; RUN: opt -S -function-attrs %s | FileCheck %s
; RUN: opt -S -passes=function-attrs %s | FileCheck %s ; RUN: opt -S -passes=function-attrs %s | FileCheck %s
@a = external global i8, !absolute_symbol !0 @a = external global i8, !absolute_symbol !0
; CHECK-NOT: define nonnull ; CHECK-NOT: define nonnull
define i8* @foo() { define i8* @foo() {
ret i8* @a ret i8* @a
} }
!0 = !{i64 0, i64 256} !0 = !{i64 0, i64 256}

llvm/test/Transforms/FunctionAttrs/nonnull.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 -functionattrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=FNATTR ; RUN: opt -S -function-attrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=FNATTR
; RUN: opt -S -passes=function-attrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=FNATTR ; RUN: opt -S -passes=function-attrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=FNATTR
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"
declare nonnull i8* @ret_nonnull() declare nonnull i8* @ret_nonnull()
; Return a pointer trivially nonnull (call return attribute) ; Return a pointer trivially nonnull (call return attribute)
define i8* @test1() { define i8* @test1() {
▲ Show 20 Lines • Show All 764 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/norecurse.ll

; RUN: opt < %s -basic-aa -functionattrs -rpo-functionattrs -S | FileCheck %s ; RUN: opt < %s -basic-aa -function-attrs -rpo-function-attrs -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs),rpo-functionattrs' -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs),rpo-function-attrs' -S | FileCheck %s
; CHECK: Function Attrs ; CHECK: Function Attrs
; CHECK-SAME: norecurse nounwind readnone ; CHECK-SAME: norecurse nounwind readnone
; CHECK-NEXT: define i32 @leaf() ; CHECK-NEXT: define i32 @leaf()
define i32 @leaf() { define i32 @leaf() {
ret i32 1 ret i32 1
} }
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/nounwind.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; TEST 1 ; TEST 1
; CHECK: Function Attrs: norecurse nounwind readnone ; CHECK: Function Attrs: norecurse nounwind readnone
; CHECK-NEXT: define i32 @foo1() ; CHECK-NEXT: define i32 @foo1()
define i32 @foo1() { define i32 @foo1() {
ret i32 1 ret i32 1
} }
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

llvm/test/Transforms/FunctionAttrs/operand-bundles-scc.ll

; RUN: opt -S -functionattrs < %s | FileCheck %s ; RUN: opt -S -function-attrs < %s | FileCheck %s
; RUN: opt -S -passes=function-attrs < %s | FileCheck %s ; RUN: opt -S -passes=function-attrs < %s | FileCheck %s
define void @f() { define void @f() {
; CHECK-LABEL: define void @f() #0 { ; CHECK-LABEL: define void @f() #0 {
call void @g() [ "unknown"() ] call void @g() [ "unknown"() ]
ret void ret void
} }
define void @g() { define void @g() {
; CHECK-LABEL: define void @g() #0 { ; CHECK-LABEL: define void @g() #0 {
call void @f() call void @f()
ret void ret void
} }
; CHECK: attributes #0 = { nofree nounwind } ; CHECK: attributes #0 = { nofree nounwind }

llvm/test/Transforms/FunctionAttrs/optnone.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
@x = global i32 0 @x = global i32 0
define void @test_opt(i8* %p) { define void @test_opt(i8* %p) {
; CHECK-LABEL: @test_opt ; CHECK-LABEL: @test_opt
; CHECK: (i8* nocapture readnone %p) #0 { ; CHECK: (i8* nocapture readnone %p) #0 {
ret void ret void
Show All 16 Lines

llvm/test/Transforms/FunctionAttrs/out-of-bounds-iterator-bug.ll

; RUN: opt -functionattrs -S < %s | FileCheck %s ; RUN: opt -function-attrs -S < %s | FileCheck %s
; RUN: opt -passes=function-attrs -S < %s | FileCheck %s ; RUN: opt -passes=function-attrs -S < %s | FileCheck %s
; This checks for an iterator wraparound bug in FunctionAttrs. The previous ; This checks for an iterator wraparound bug in FunctionAttrs. The previous
; "incorrect" behavior was inferring readonly for the %x argument in @caller. ; "incorrect" behavior was inferring readonly for the %x argument in @caller.
; Inferring readonly for %x *is* actually correct, since @va_func is marked ; Inferring readonly for %x *is* actually correct, since @va_func is marked
; readonly, but FunctionAttrs was inferring readonly for the wrong reasons (and ; readonly, but FunctionAttrs was inferring readonly for the wrong reasons (and
; we _need_ the readonly on @va_func to trigger the problematic code path). It ; we _need_ the readonly on @va_func to trigger the problematic code path). It
; is possible that in the future FunctionAttrs becomes smart enough to infer ; is possible that in the future FunctionAttrs becomes smart enough to infer
Show All 22 Lines

llvm/test/Transforms/FunctionAttrs/read-write-scc.ll

; RUN: opt -S -functionattrs < %s | FileCheck %s ; RUN: opt -S -function-attrs < %s | FileCheck %s
; RUN: opt -S -passes=function-attrs < %s | FileCheck %s ; RUN: opt -S -passes=function-attrs < %s | FileCheck %s
@i = global i32 0 @i = global i32 0
define void @foo() { define void @foo() {
; CHECK-LABEL: define void @foo() #0 { ; CHECK-LABEL: define void @foo() #0 {
store i32 1, i32* @i store i32 1, i32* @i
call void @bar() call void @bar()
Show All 11 Lines

llvm/test/Transforms/FunctionAttrs/readattrs.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs)' -S | FileCheck %s ; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs)' -S | FileCheck %s
@x = global i32 0 @x = global i32 0
declare void @test1_1(i8* %x1_1, i8* readonly %y1_1, ...) declare void @test1_1(i8* %x1_1, i8* readonly %y1_1, ...)
; NOTE: readonly for %y1_2 would be OK here but not for the similar situation in test13. ; NOTE: readonly for %y1_2 would be OK here but not for the similar situation in test13.
; ;
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines
declare void @escape_readnone_ptr(i8** %addr, i8* readnone %ptr) declare void @escape_readnone_ptr(i8** %addr, i8* readnone %ptr)
declare void @escape_readonly_ptr(i8** %addr, i8* readonly %ptr) declare void @escape_readonly_ptr(i8** %addr, i8* readonly %ptr)
; The argument pointer %escaped_then_written cannot be marked readnone/only even ; The argument pointer %escaped_then_written cannot be marked readnone/only even
; though the only direct use, in @escape_readnone_ptr/@escape_readonly_ptr, ; though the only direct use, in @escape_readnone_ptr/@escape_readonly_ptr,
; is marked as readnone/only. However, the functions can write the pointer into ; is marked as readnone/only. However, the functions can write the pointer into
; %addr, causing the store to write to %escaped_then_written. ; %addr, causing the store to write to %escaped_then_written.
; ;
; FIXME: This test currently exposes a bug in functionattrs! ; FIXME: This test currently exposes a bug in function-attrs!
; ;
; CHECK: define void @unsound_readnone(i8* nocapture readnone %ignored, i8* readnone %escaped_then_written) ; CHECK: define void @unsound_readnone(i8* nocapture readnone %ignored, i8* readnone %escaped_then_written)
; CHECK: define void @unsound_readonly(i8* nocapture readnone %ignored, i8* readonly %escaped_then_written) ; CHECK: define void @unsound_readonly(i8* nocapture readnone %ignored, i8* readonly %escaped_then_written)
; ;
define void @unsound_readnone(i8* %ignored, i8* %escaped_then_written) { define void @unsound_readnone(i8* %ignored, i8* %escaped_then_written) {
%addr = alloca i8* %addr = alloca i8*
call void @escape_readnone_ptr(i8** %addr, i8* %escaped_then_written) call void @escape_readnone_ptr(i8** %addr, i8* %escaped_then_written)
%addr.ld = load i8*, i8** %addr %addr.ld = load i8*, i8** %addr
Show All 11 Lines

llvm/test/Transforms/FunctionAttrs/readnone.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; CHECK: define void @bar(i8* nocapture readnone %0) ; CHECK: define void @bar(i8* nocapture readnone %0)
define void @bar(i8* readonly %0) { define void @bar(i8* readonly %0) {
call void @foo(i8* %0) call void @foo(i8* %0)
ret void ret void
} }
; CHECK: define void @foo(i8* nocapture readnone %0) ; CHECK: define void @foo(i8* nocapture readnone %0)
define void @foo(i8* readonly %0) { define void @foo(i8* readonly %0) {
call void @bar(i8* %0) call void @bar(i8* %0)
ret void ret void
} }

llvm/test/Transforms/FunctionAttrs/returned.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; CHECK: define i32 @test1(i32 %p, i32 %q) ; CHECK: define i32 @test1(i32 %p, i32 %q)
define i32 @test1(i32 %p, i32 %q) { define i32 @test1(i32 %p, i32 %q) {
entry: entry:
%cmp = icmp sgt i32 %p, %q %cmp = icmp sgt i32 %p, %q
br i1 %cmp, label %cond.end, label %lor.lhs.false br i1 %cmp, label %cond.end, label %lor.lhs.false
Show All 22 Lines

llvm/test/Transforms/FunctionAttrs/writeonly.ll

; RUN: opt < %s -functionattrs -S | FileCheck %s ; RUN: opt < %s -function-attrs -S | FileCheck %s
; RUN: opt < %s -passes=function-attrs -S | FileCheck %s ; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
; CHECK: define void @nouses-argworn-funrn(i32* nocapture readnone %.aaa) #0 { ; CHECK: define void @nouses-argworn-funrn(i32* nocapture readnone %.aaa) #0 {
define void @nouses-argworn-funrn(i32* writeonly %.aaa) { define void @nouses-argworn-funrn(i32* writeonly %.aaa) {
nouses-argworn-funrn_entry: nouses-argworn-funrn_entry:
ret void ret void
} }
Show All 21 Lines

llvm/test/Transforms/GlobalDCE/crash-assertingvh.ll

; Make sure that if a pass like jump threading populates a function analysis ; Make sure that if a pass like jump threading populates a function analysis
; like LVI with asserting handles into the body of a function, those don't begin ; like LVI with asserting handles into the body of a function, those don't begin
; to assert when global DCE deletes the body of the function. ; to assert when global DCE deletes the body of the function.
; ;
; RUN: opt -disable-output < %s -passes='module(function(jump-threading),globaldce)' ; RUN: opt -disable-output < %s -passes='module(function(jump-threading),globaldce)'
; RUN: opt -disable-output < %s -passes='module(rpo-functionattrs,globaldce)' ; RUN: opt -disable-output < %s -passes='module(rpo-function-attrs,globaldce)'
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"
declare i32 @bar() declare i32 @bar()
define internal i32 @foo() { define internal i32 @foo() {
entry: entry:
Show All 10 Lines

llvm/test/Transforms/IndVarSimplify/pr38855.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 -disable-nounwind-inference=false -inline -functionattrs -indvars < %s | FileCheck %s ; RUN: opt -S -disable-nounwind-inference=false -inline -function-attrs -indvars < %s | FileCheck %s
; Check that the invalidation happens correctly and the test does not crash. ; Check that the invalidation happens correctly and the test does not crash.
define void @f2() { define void @f2() {
; CHECK-LABEL: @f2( ; CHECK-LABEL: @f2(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK-NEXT: br label [[FOR_COND:%.*]] ; CHECK-NEXT: br label [[FOR_COND:%.*]]
; CHECK: for.cond: ; CHECK: for.cond:
; CHECK-NEXT: br label [[FOR_COND]] ; CHECK-NEXT: br label [[FOR_COND]]
Show All 14 Lines

llvm/test/Transforms/Inline/delete-call.ll

; REQUIRES: asserts ; REQUIRES: asserts
; RUN: opt -S -inline -stats < %s 2>&1 | FileCheck %s ; RUN: opt -S -inline -stats < %s 2>&1 | FileCheck %s
; CHECK: Number of functions inlined ; CHECK: Number of functions inlined
; RUN: opt -S -inline -functionattrs -stats < %s 2>&1 | FileCheck -check-prefix=CHECK-FUNCTIONATTRS %s ; RUN: opt -S -inline -function-attrs -stats < %s 2>&1 | FileCheck -check-prefix=CHECK-FUNCTIONATTRS %s
; CHECK-FUNCTIONATTRS: Number of call sites deleted, not inlined ; CHECK-FUNCTIONATTRS: Number of call sites deleted, not inlined
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32" target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-n8:16:32"
target triple = "i386-apple-darwin9.8" target triple = "i386-apple-darwin9.8"
define internal i32 @test(i32 %x, i32 %y, i32 %z) nounwind { define internal i32 @test(i32 %x, i32 %y, i32 %z) nounwind {
entry: entry:
%0 = add nsw i32 %y, %z ; <i32> [#uses=1] %0 = add nsw i32 %y, %z ; <i32> [#uses=1]
Show All 13 Lines

llvm/test/Transforms/InstCombine/2009-02-11-NotInitialized.ll

; RUN: opt < %s -inline -instcombine -functionattrs | llvm-dis ; RUN: opt < %s -inline -instcombine -function-attrs | llvm-dis
; ;
; Check that nocapture attributes are added when run after an SCC pass. ; Check that nocapture attributes are added when run after an SCC pass.
; PR3520 ; PR3520
define i32 @use(i8* %x) nounwind readonly { define i32 @use(i8* %x) nounwind readonly {
; CHECK: @use(i8* nocapture %x) ; CHECK: @use(i8* nocapture %x)
%1 = tail call i64 @strlen(i8* %x) nounwind readonly %1 = tail call i64 @strlen(i8* %x) nounwind readonly
%2 = trunc i64 %1 to i32 %2 = trunc i64 %1 to i32
ret i32 %2 ret i32 %2
} }
declare i64 @strlen(i8*) nounwind readonly declare i64 @strlen(i8*) nounwind readonly
; CHECK: declare i64 @strlen(i8* nocapture) nounwind readonly ; CHECK: declare i64 @strlen(i8* nocapture) nounwind readonly

llvm/test/Transforms/LoopUnswitch/2012-04-30-LoopUnswitch-LPad-Crash.ll

; RUN: opt < %s -basic-aa -instcombine -inline -functionattrs -licm -loop-unswitch -gvn -verify ; RUN: opt < %s -basic-aa -instcombine -inline -function-attrs -licm -loop-unswitch -gvn -verify
; PR12573 ; PR12573
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
%class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379 = type { %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376*, %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 } %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379 = type { %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376*, %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 }
%class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376 = type { %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* } %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376 = type { %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* }
%class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 = type { %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377* } %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 = type { %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377* }
%class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377 = type { i8 } %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377 = type { i8 }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

llvm/test/Transforms/Reassociate/reassociate-deadinst.ll

; RUN: opt < %s -inline -functionattrs -reassociate -S | FileCheck %s ; RUN: opt < %s -inline -function-attrs -reassociate -S | FileCheck %s
; CHECK-NOT: func1 ; CHECK-NOT: func1
; CHECK-LABEL: main ; CHECK-LABEL: main
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
define internal i16 @func1() noinline #0 { define internal i16 @func1() noinline #0 {
ret i16 0 ret i16 0
} }
define void @main(i16 %argc, i16** %argv) #0 { define void @main(i16 %argc, i16** %argv) #0 {
%_tmp0 = call i16 @func1() %_tmp0 = call i16 @func1()
%_tmp2 = zext i16 %_tmp0 to i32 %_tmp2 = zext i16 %_tmp0 to i32
ret void ret void
} }
attributes #0 = { minsize nounwind optsize } attributes #0 = { minsize nounwind optsize }

llvm/test/Transforms/SimpleLoopUnswitch/2012-04-30-LoopUnswitch-LPad-Crash.ll

; RUN: opt < %s -basic-aa -instcombine -inline -functionattrs -licm -simple-loop-unswitch -gvn -verify ; RUN: opt < %s -basic-aa -instcombine -inline -function-attrs -licm -simple-loop-unswitch -gvn -verify
; PR12573 ; PR12573
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.7.0" target triple = "x86_64-apple-macosx10.7.0"
%class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379 = type { %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376*, %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 } %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379 = type { %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376*, %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 }
%class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376 = type { %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* } %class.C.23.43.67.103.139.159.179.199.239.243.247.251.263.295.303.339.347.376 = type { %class.D.22.42.66.102.138.158.178.198.238.242.246.250.262.294.302.338.346.379* }
%class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 = type { %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377* } %class.B.21.41.65.101.137.157.177.197.237.241.245.249.261.293.301.337.345.378 = type { %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377* }
%class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377 = type { i8 } %class.A.20.40.64.100.136.156.176.196.236.240.244.248.260.292.300.336.344.377 = type { i8 }
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines