[FunctionAttrs] Rename functionattrs -> function-attrs

[aeubanks]

Summary

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

[arsenm]

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

[aeubanks]

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]

Rename the other way

llvm/lib/Passes/PassRegistry.def

 CGSCC_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))
 #undef CGSCC_ANALYSIS
 
 #ifndef CGSCC_PASS
 #define CGSCC_PASS(NAME, CREATE_PASS)
 #endif
 CGSCC_PASS("argpromotion", ArgumentPromotionPass())
 CGSCC_PASS("invalidate<all>", InvalidateAllAnalysesPass())
-CGSCC_PASS("function-attrs", PostOrderFunctionAttrsPass())
+CGSCC_PASS("functionattrs", PostOrderFunctionAttrsPass())
 CGSCC_PASS("attributor-cgscc", AttributorCGSCCPass())
 CGSCC_PASS("inline", InlinerPass())
 CGSCC_PASS("openmpopt", OpenMPOptPass())
 CGSCC_PASS("coro-split", CoroSplitPass())
 CGSCC_PASS("no-op-cgscc", NoOpCGSCCPass())
 #undef CGSCC_PASS
 
 #ifndef FUNCTION_ANALYSIS

llvm/test/Other/cgscc-devirt-iteration.ll

 ; The CGSCC pass manager includes an SCC iteration utility that tracks indirect
 ; calls that are turned into direct calls (devirtualization) and re-visits the
 ; SCC to expose those calls to the SCC-based IPO passes. We trigger
 ; devirtualization here with GVN which forwards a store through a load and to
 ; an indirect call.
 ;
-; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(gvn,instcombine))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=BEFORE
-; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<1>(function-attrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER1
-; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<2>(function-attrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER2
+; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(functionattrs,function(gvn,instcombine))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=BEFORE
+; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<1>(functionattrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER1
+; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(devirt<2>(functionattrs,function(gvn,instcombine)))' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER2
 ;
 ; We also verify that the real O2 pipeline catches these cases.
 ; RUN: opt -aa-pipeline=basic-aa -passes='default<O2>' -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=AFTER --check-prefix=AFTER2
 
 declare void @readnone() readnone
 ; CHECK: Function Attrs: readnone
 ; CHECK-NEXT: declare void @readnone()
 

llvm/test/Other/cgscc-iterate-function-mutation.ll

-; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(simplify-cfg))' -S < %s | FileCheck %s
+; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(functionattrs,function(simplify-cfg))' -S < %s | FileCheck %s
 
 declare void @readnone() readnone
 declare void @unknown()
 declare void @reference_function_pointer(void()*) readnone
 
 ; The @test1_* set of functions checks that when we mutate functions with
 ; simplify-cfg to delete call edges and this ends up splitting both the SCCs
 ; and the RefSCCs that those functions are in, we re-run the CGSCC passes to

llvm/test/Other/cgscc-observe-devirt.ll

 ; Make sure that even without some external devirtualization iteration tool,
 ; the CGSCC pass manager correctly observes and re-visits SCCs that change
 ; structure due to devirtualization. We trigger devirtualization here with GVN
 ; which forwards a store through a load and to an indirect call.
 ;
-; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs)' -S < %s | FileCheck %s --check-prefix=BEFORE
-; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(gvn))' -S < %s | FileCheck %s --check-prefix=AFTER
+; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(functionattrs)' -S < %s | FileCheck %s --check-prefix=BEFORE
+; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(functionattrs,function(gvn))' -S < %s | FileCheck %s --check-prefix=AFTER
 ;
 ; Also check that adding an extra CGSCC pass after the function update but
 ; without requiring the outer manager to iterate doesn't break any invariant.
-; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(function-attrs,function(gvn),function-attrs)' -S < %s | FileCheck %s --check-prefix=AFTER
+; RUN: opt -aa-pipeline=basic-aa -passes='cgscc(functionattrs,function(gvn),functionattrs)' -S < %s | FileCheck %s --check-prefix=AFTER
 
 declare void @readnone() readnone
 declare void @unknown()
 
 ; The @test1_* checks that if we refine an indirect call to a direct call and
 ; in the process change the very structure of the call graph we also revisit
 ; that component of the graph and do so in an up-to-date fashion.
 

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

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

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

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

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

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

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

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

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

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

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

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

llvm/test/Transforms/FunctionAttrs/assume.ll

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

llvm/test/Transforms/FunctionAttrs/atomic.ll

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

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

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

llvm/test/Transforms/FunctionAttrs/convergent.ll

 ; 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
 ;
 ; RUN: opt -functionattrs -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK-INDIRECT
-; RUN: opt -passes=function-attrs -S < %s | FileCheck %s
+; RUN: opt -passes=functionattrs -S < %s | FileCheck %s
 
 ; CHECK: Function Attrs
 ; CHECK-NOT: convergent
 ; CHECK-NEXT: define i32 @nonleaf()
 define i32 @nonleaf() convergent {
   %a = call i32 @leaf()
   ret i32 %a
 }

llvm/test/Transforms/FunctionAttrs/incompatible_fn_attrs.ll

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

llvm/test/Transforms/FunctionAttrs/int_sideeffect.ll

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

llvm/test/Transforms/FunctionAttrs/naked_functions.ll

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

llvm/test/Transforms/FunctionAttrs/nocapture.ll

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

llvm/test/Transforms/FunctionAttrs/nofree.ll

 ; RUN: opt < %s -functionattrs -S | FileCheck %s
-; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
+; RUN: opt < %s -passes=functionattrs -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 {
 define void @_Z4foo1Pi(i32* nocapture readnone %a) local_unnamed_addr #0 {
 entry:
   tail call void @_Z3extv()

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

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

llvm/test/Transforms/FunctionAttrs/nonnull.ll

 ; 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 -passes=function-attrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=FNATTR
+; RUN: opt -S -passes=functionattrs -enable-nonnull-arg-prop %s | FileCheck %s --check-prefixes=FNATTR
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 declare nonnull i8* @ret_nonnull()
 
 ; Return a pointer trivially nonnull (call return attribute)
 define i8* @test1() {
 ; FNATTR: define nonnull i8* @test1

llvm/test/Transforms/FunctionAttrs/norecurse.ll

 ; RUN: opt < %s -basic-aa -functionattrs -rpo-functionattrs -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(functionattrs),rpo-functionattrs' -S | FileCheck %s
 
 ; CHECK: Function Attrs
 ; CHECK-SAME: norecurse nounwind readnone
 ; CHECK-NEXT: define i32 @leaf()
 define i32 @leaf() {
   ret i32 1
 }
 

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

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

llvm/test/Transforms/FunctionAttrs/optnone.ll

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

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

 ; RUN: opt -functionattrs -S < %s | FileCheck %s
-; RUN: opt -passes=function-attrs -S < %s | FileCheck %s
+; RUN: opt -passes=functionattrs -S < %s | FileCheck %s
 
 ; This checks for an iterator wraparound bug in FunctionAttrs.  The previous
 ; "incorrect" behavior was inferring readonly for the %x argument in @caller.
 ; Inferring readonly for %x *is* actually correct, since @va_func is marked
 ; 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
 ; is possible that in the future FunctionAttrs becomes smart enough to infer
 ; readonly for %x for the right reasons, and at that point this test will have

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

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

llvm/test/Transforms/FunctionAttrs/readattrs.ll

 ; RUN: opt < %s -functionattrs -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(functionattrs)' -S | FileCheck %s
 
 @x = global i32 0
 
 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.
 ;
 ; CHECK: define void @test1_2(i8* %x1_2, i8* readonly %y1_2, i8* %z1_2)

llvm/test/Transforms/FunctionAttrs/readnone.ll

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

llvm/test/Transforms/FunctionAttrs/returned.ll

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

llvm/test/Transforms/FunctionAttrs/writeonly.ll

 ; RUN: opt < %s -functionattrs         -S | FileCheck %s
-; RUN: opt < %s -passes=function-attrs -S | FileCheck %s
+; RUN: opt < %s -passes=functionattrs -S | FileCheck %s
 
 ; CHECK: define void @nouses-argworn-funrn(i32* nocapture readnone %.aaa) #0 {
 define void @nouses-argworn-funrn(i32* writeonly %.aaa) {
 nouses-argworn-funrn_entry:
   ret void
 }
 
 ; CHECK: define void @nouses-argworn-funro(i32* nocapture readnone %.aaa, i32* nocapture readonly %.bbb) #1 {

llvm/test/Transforms/Inline/cgscc-update.ll

-; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(function-attrs,inline)' -S | FileCheck %s
+; RUN: opt < %s -aa-pipeline=basic-aa -passes='cgscc(functionattrs,inline)' -S | FileCheck %s
 ; This test runs the inliner and the function attribute deduction. It ensures
 ; that when the inliner mutates the call graph it correctly updates the CGSCC
 ; iteration so that we can compute refined function attributes. In this way it
 ; is leveraging function attribute computation to observe correct call graph
 ; updates.
 
 ; Boring unknown external function call.
 ; CHECK: declare void @unknown()

llvm/test/Transforms/PruneEH/2008-06-02-Weak.ll

 ; RUN: opt < %s -prune-eh -S | FileCheck %s
-; RUN: opt < %s -passes='function-attrs,function(simplify-cfg)' -S | FileCheck %s
+; RUN: opt < %s -passes='functionattrs,function(simplify-cfg)' -S | FileCheck %s
 
 ; We should not infer 'nounwind' for/from a weak function,
 ; since it can be overriden by throwing implementation.
 ;
 ; CHECK-LABEL: define weak void @f()
 define weak void @f() {
 entry:
         ret void

llvm/test/Transforms/PruneEH/ipo-nounwind.ll

 ; RUN: opt -S -prune-eh < %s | FileCheck %s
-; RUN: opt -S -passes='function-attrs,function(simplify-cfg)' < %s | FileCheck %s
+; RUN: opt -S -passes='functionattrs,function(simplify-cfg)' < %s | FileCheck %s
 
 declare void @may_throw()
 
 ; @callee below may be an optimized form of this function, which can
 ; throw at runtime (see r265762 for more details):
 ; 
 ; define linkonce_odr void @callee(i32* %ptr) noinline {
 ; entry:

llvm/test/Transforms/PruneEH/operand-bundles.ll

 ; RUN: opt < %s -prune-eh -S | FileCheck %s
-; RUN: opt < %s -passes='function-attrs,function(simplify-cfg)' -S | FileCheck %s
+; RUN: opt < %s -passes='functionattrs,function(simplify-cfg)' -S | FileCheck %s
 
 declare void @nounwind() nounwind
 
 define internal void @foo() {
   call void @nounwind()
   ret void
 }
 

llvm/test/Transforms/PruneEH/pr23971.ll

 ; RUN: opt -S -prune-eh < %s | FileCheck %s
-; RUN: opt -S -passes='function-attrs,function(simplify-cfg)' < %s | FileCheck %s
+; RUN: opt -S -passes='functionattrs,function(simplify-cfg)' < %s | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @f() #0 {
 entry:
   call void asm sideeffect "ret\0A\09", "~{dirflag},~{fpsr},~{flags}"()
   unreachable

llvm/test/Transforms/PruneEH/pr26263.ll

 ; PruneEH is less powerful than simplify-cfg in terms of cfg simplification,
 ; so it leaves some of the unreachable stuff hanging around.
 ; Checking it with CHECK-OLD.
 ;
 ; RUN: opt -prune-eh -S < %s | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-OLD
-; RUN: opt -passes='function-attrs,function(simplify-cfg)' -S < %s | FileCheck %s  --check-prefix=CHECK --check-prefix=CHECK-NEW
+; RUN: opt -passes='functionattrs,function(simplify-cfg)' -S < %s | FileCheck %s  --check-prefix=CHECK --check-prefix=CHECK-NEW
 
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i386-pc-windows-msvc"
 
 declare void @neverthrows() nounwind
 
 define void @test1() personality i32 (...)* @__CxxFrameHandler3 {
   invoke void @neverthrows()

llvm/test/Transforms/PruneEH/recursivetest.ll

 ; RUN: opt < %s -prune-eh -S | FileCheck %s
-; RUN: opt < %s -passes='function-attrs,function(simplify-cfg)' -S | FileCheck %s
+; RUN: opt < %s -passes='functionattrs,function(simplify-cfg)' -S | FileCheck %s
 
 ; CHECK-LABEL: define internal i32 @foo()
 define internal i32 @foo() personality i32 (...)* @__gxx_personality_v0 {
 ; CHECK-NOT: invoke i32 @foo()
   invoke i32 @foo( )
       to label %Normal unwind label %Except   ; <i32>:1 [#uses=0]
 Normal:   ; preds = %0
   ret i32 12

llvm/test/Transforms/PruneEH/seh-nounwind.ll

 ; RUN: opt -S -prune-eh < %s | FileCheck %s
-; RUN: opt -S -passes='function-attrs,function(simplify-cfg)' < %s | FileCheck %s
+; RUN: opt -S -passes='functionattrs,function(simplify-cfg)' < %s | FileCheck %s
 
 ; Don't remove invokes of nounwind functions if the personality handles async
 ; exceptions. The @div function in this test can fault, even though it can't
 ; throw a synchronous exception.
 
 define i32 @div(i32 %n, i32 %d) nounwind {
 entry:
   %div = sdiv i32 %n, %d

llvm/test/Transforms/PruneEH/simpletest.ll

 ; RUN: opt < %s -prune-eh -S | FileCheck %s
-; RUN: opt < %s -passes='function-attrs,function(simplify-cfg)' -S | FileCheck %s
+; RUN: opt < %s -passes='functionattrs,function(simplify-cfg)' -S | FileCheck %s
 
 declare void @nounwind() nounwind
 
 define internal void @foo() {
   call void @nounwind()
   ret void
 }