[opt] NewPM: `opt -passname` syntax is dead, long live `opt -passes=<pipeline>`!

[lebedev.ri]

Summary

I've done final pass, and there are no more tests to update.
All other tests (=codegen tests) are using old pass manager.

[lebedev.ri]

Commit the last batch of changes.

[lebedev.ri]

There appears to be at least one leftover, somewhere in sanitizer bot.
@vitalybuka i'm not sure where it happens? PTAL? https://lab.llvm.org/buildbot/#/builders/37/builds/18702/steps/46/logs/stdio

[lebedev.ri]

Never mind, 225ce6784ef96f004ccc5fa992f8e20ecac74a92 should deal with that.
Not sure if there are other leftovers.

[lebedev.ri]

@aeubanks poke
That change baked in tree for some more days,
and still hasn't been reverted. I think we're good.

[nikic]

LGTM

[aeubanks]

sorry, I thought I lgtm'd this patch, turns out it was the other one

thanks for doing this!

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

-; RUN: sed -e s/.T1:// %s | not opt -lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK1 %s
-; RUN: sed -e s/.T2:// %s | not opt -lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s
+; RUN: sed -e s/.T1:// %s | not opt -passes=lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK1 %s
+; RUN: sed -e s/.T2:// %s | not opt -passes=lint -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s
 
 target triple = "x86_64-pc-windows-msvc"
 
 declare void @f()
 
 ;T1: declare i8* @llvm.eh.exceptionpointer.p0i8(i32)
 ;T1:
 ;T1: define void @test1() personality i32 (...)* @__CxxFrameHandler3 {

llvm/test/Other/opt-On.ll

 ; RUN: not opt -O1 -O2 < %s 2>&1 | FileCheck %s --check-prefix=MULTIPLE
 ; RUN: not opt -O1 -passes='no-op-module' < %s 2>&1 | FileCheck %s --check-prefix=BOTH
-; RUN: not opt -O1 --gvn < %s 2>&1 | FileCheck %s --check-prefix=BOTH
+; RUN: not opt -O1 -passes=gvn < %s 2>&1 | FileCheck %s --check-prefix=BOTH
 ; RUN: opt -O0 < %s -S 2>&1 | FileCheck %s --check-prefix=OPT
 ; RUN: opt -O1 < %s -S 2>&1 | FileCheck %s --check-prefix=OPT
 ; RUN: opt -O2 < %s -S 2>&1 | FileCheck %s --check-prefix=OPT
 ; RUN: opt -O3 < %s -S 2>&1 | FileCheck %s --check-prefix=OPT
 ; RUN: opt -Os < %s -S 2>&1 | FileCheck %s --check-prefix=OPT
 ; RUN: opt -Oz < %s -S 2>&1 | FileCheck %s --check-prefix=OPT
 ; RUN: opt -O2 -debug-pass-manager -disable-output < %s 2>&1 | FileCheck %s --check-prefix=AA
 

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

 ; REQUIRES: x86-registered-target
 
-; RUN: opt -temporarily-allow-old-pass-syntax /dev/null -disable-output 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 -temporarily-allow-old-pass-syntax /dev/null -disable-output -instcombine 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 -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 -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
+; RUN: opt /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: not opt /dev/null -disable-output -instcombine 2>&1 | FileCheck %s --check-prefix=WARN
+; RUN: not opt /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 /dev/null -disable-output -codegenprepare -mtriple=x86_64-unknown-linux-gnu 2>&1 | FileCheck %s --check-prefix=OK --allow-empty
 
 ; 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 not supported, please use `opt -passes=<pipeline>` (or the `-p` alias for a more concise version).

llvm/test/Other/opt-old-new-pm-passes.ll

-; RUN: not opt -dce --passes=inline %s 2>&1 | FileCheck %s
-; CHECK: Cannot specify passes via both -foo-pass and --passes=foo-pass

llvm/test/Other/scalable-vector-array.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 ;; Arrays cannot contain scalable vectors; make sure we detect them even
 ;; when nested inside other aggregates.
 
 %ty = type { i64, [4 x <vscale x 256 x i1>] }
 ; CHECK: error: invalid array element type
 ; CHECK: %ty = type { i64, [4 x <vscale x 256 x i1>] }

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

-; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops %s -S -o - | \
+; RUN: opt -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops %s -S -o - | \
 ; RUN:     FileCheck %s
-; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=thumbv8.1m.main -loop-unroll -unroll-remainder=false -S < %s | \
+; RUN: opt -mtriple=thumbv8.1m.main -passes=loop-unroll -unroll-remainder=false -S < %s | \
 ; RUN:     llc -mtriple=thumbv8.1m.main | FileCheck %s --check-prefix=CHECK-UNROLL
-; RUN: opt -temporarily-allow-old-pass-syntax -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops \
+; RUN: opt -mtriple=thumbv8.1m.main-none-none-eabi -hardware-loops \
 ; RUN:     -pass-remarks-analysis=hardware-loops  %s -S -o - 2>&1 | \
 ; 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: 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

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

-; RUN: opt -temporarily-allow-old-pass-syntax -codegenprepare -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 -temporarily-allow-old-pass-syntax -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' %s -S -o - | FileCheck %s
+; RUN: opt -codegenprepare -load-store-vectorizer %s -S -o - | FileCheck %s
+; RUN: opt                 -passes=load-store-vectorizer %s -S -o - | FileCheck %s
+; RUN: opt -aa-pipeline=basic-aa -passes='function(load-store-vectorizer)' %s -S -o - | FileCheck %s
 
 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]]] } }
 
 @global_pointer = external unnamed_addr global { %union, [2000 x i8] }, align 4
 
 ; Function Attrs: convergent nounwind

llvm/test/Verifier/assume-bundles.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 declare void @llvm.assume(i1)
 
 define void @func(i32* %P, i32 %P1, i32* %P2, i32* %P3) {
 ; CHECK: tags must be valid attribute names
 ; CHECK: "adazdazd"
   call void @llvm.assume(i1 true) ["adazdazd"()]
 ; CHECK: the second argument should be a constant integral value

llvm/test/Verifier/atomics.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 ; CHECK: atomic store operand must have integer, pointer, or floating point type!
 ; CHECK: atomic load operand must have integer, pointer, or floating point type!
 
 define void @foo(x86_mmx* %P, x86_mmx %v) {
   store atomic x86_mmx %v, x86_mmx* %P unordered, align 8
   ret void
 }
 
 define x86_mmx @bar(x86_mmx* %P) {
   %v = load atomic x86_mmx, x86_mmx* %P unordered, align 8
   ret x86_mmx %v
 }

llvm/test/Verifier/callbr.ll

-; RUN: not opt -S %s -verify 2>&1 | FileCheck %s
+; RUN: not opt -S %s -passes=verify 2>&1 | FileCheck %s
 
 ; CHECK: Number of label constraints does not match number of callbr dests
 ; CHECK-NEXT: #too_few_label_constraints
 define void @too_few_label_constraints() {
   callbr void asm sideeffect "#too_few_label_constraints", "!i"()
   to label %1 [label %2, label %3]
 1:
   ret void

llvm/test/Verifier/deoptimize-intrinsic.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 declare i8 @llvm.experimental.deoptimize.i8(...)
 declare void @llvm.experimental.deoptimize.isVoid(...)
 declare cc40 void @llvm.experimental.deoptimize.double(...)
 
 declare void @unknown()
 
 define void @f_notail() {

llvm/test/Verifier/dllstorage.ll

-; RUN: not opt -verify %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify %s 2>&1 | FileCheck %s
 
 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-gnu"
 
 ; CHECK:      dllexport GlobalValue must have default or protected visibility
 ; CHECK-NEXT: ptr @dllexport_hidden
 declare hidden dllexport i32 @dllexport_hidden()
 declare protected dllexport i32 @dllexport_protected()
 
 ; CHECK-NEXT: dllimport GlobalValue must have default visibility
 ; CHECK-NEXT: ptr @dllimport_hidden
 declare hidden dllimport i32 @dllimport_hidden()
 ; CHECK-NEXT: dllimport GlobalValue must have default visibility
 ; CHECK-NEXT: ptr @dllimport_protected
 declare protected dllimport i32 @dllimport_protected()

llvm/test/Verifier/element-wise-atomic-memory-intrinsics.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 define void @test_memcpy(i8* %P, i8* %Q, i32 %A, i32 %E) {
   ; CHECK: immarg operand has non-immediate parameter
   ; CHECK: i32 %E
   ; CHECK-NEXT: call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
   call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i32(i8* align 4 %P, i8* align 4 %Q, i32 1, i32 %E)
 
   ; CHECK: element size of the element-wise atomic memory intrinsic must be a power of 2

llvm/test/Verifier/guard-intrinsic.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 declare void @llvm.experimental.guard(i1, ...)
 
 declare void @unknown()
 
 define void @f_nodeopt() {
 entry:
   call void(i1, ...) @llvm.experimental.guard(i1 undef, i32 1, i32 2)

llvm/test/Verifier/insert-extract-intrinsics-invalid.ll

-; RUN: not opt -verify -S < %s 2>&1 >/dev/null | FileCheck %s
+; RUN: not opt -passes=verify -S < %s 2>&1 >/dev/null | FileCheck %s
 
 ;
 ; Test that extractions/insertion indices are validated.
 ;
 
 ; CHECK: vector_extract index must be a constant multiple of the result type's known minimum vector length.
 define <4 x i32> @extract_idx_not_constant_multiple(<8 x i32> %vec) {
   %1 = call <4 x i32> @llvm.vector.extract.v4i32.v8i32(<8 x i32> %vec, i64 1)

llvm/test/Verifier/intrinsic-arg-overloading-struct-ret.ll

-; RUN: not opt -verify -S < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify -S < %s 2>&1 | FileCheck %s
 
 ; LD2 and LD2LANE
 
 ; CHECK: Intrinsic has incorrect return type
 ; CHECK-NEXT: llvm.aarch64.neon.ld2.v4i32
 define { <4 x i64>, <4 x i32> } @test_ld2_ret(<4 x i32>* %ptr) {
   %res = call { <4 x i64>, <4 x i32> } @llvm.aarch64.neon.ld2.v4i32(<4 x i32>* %ptr)
   ret{ <4 x i64>, <4 x i32> } %res

llvm/test/Verifier/intrinsic-bad-arg-type.ll

-; RUN: not opt -S -verify 2>&1 < %s | FileCheck %s
+; RUN: not opt -S -passes=verify 2>&1 < %s | FileCheck %s
 
 ; CHECK: Intrinsic has incorrect argument type!
 ; CHECK-NEXT: <vscale x 4 x i32> (<vscale x 4 x i32>*, i32, <4 x i1>, <vscale x 4 x i32>)* @llvm.masked.load.nxv4i32.p0nxv4i32
 
 define <vscale x 4 x i32> @masked_load(<vscale x 4 x i32>* %addr, <4 x i1> %mask, <vscale x 4 x i32> %dst) {
   %res = call <vscale x 4 x i32> @llvm.masked.load.nxv4i32.p0nxv4i32(<vscale x 4 x i32>* %addr, i32 4, <4 x i1> %mask, <vscale x 4 x i32> %dst)
   ret <vscale x 4 x i32> %res
 }
 declare <vscale x 4 x i32> @llvm.masked.load.nxv4i32.p0nxv4i32(<vscale x 4 x i32>*, i32, <4 x i1>, <vscale x 4 x i32>)

llvm/test/Verifier/invalid-eh.ll

 ; UNSUPPORTED: system-windows
 
 ; RUN: sed -e s/.T1:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK1 %s
 ; RUN: sed -e s/.T2:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK2 %s
 ; RUN: sed -e s/.T3:// %s | not llvm-as -disable-output 2>&1 | FileCheck --check-prefix=CHECK3 %s
 ; RUN: sed -e s/.T4:// %s | not llvm-as -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/.T6:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK6 %s
-; RUN: sed -e s/.T7:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK7 %s
-; RUN: sed -e s/.T8:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK8 %s
-; RUN: sed -e s/.T9:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK9 %s
-; RUN: sed -e s/.T10:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK10 %s
-; RUN: sed -e s/.T11:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK11 %s
-; RUN: sed -e s/.T12:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK12 %s
-; RUN: sed -e s/.T13:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK13 %s
-; RUN: sed -e s/.T14:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK14 %s
-; RUN: sed -e s/.T15:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK15 %s
-; RUN: sed -e s/.T16:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK16 %s
-; RUN: sed -e s/.T17:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK17 %s
-; RUN: sed -e s/.T18:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK18 %s
-; RUN: sed -e s/.T19:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK19 %s
-; RUN: sed -e s/.T20:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK20 %s
-; RUN: sed -e s/.T21:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK21 %s
-; RUN: sed -e s/.T22:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK22 %s
-; RUN: sed -e s/.T23:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK23 %s
-; RUN: sed -e s/.T24:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK24 %s
-; RUN: sed -e s/.T25:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK25 %s
-; RUN: sed -e s/.T26:// %s | not opt -verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK26 %s
+; RUN: sed -e s/.T5:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK5 %s
+; RUN: sed -e s/.T6:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK6 %s
+; RUN: sed -e s/.T7:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK7 %s
+; RUN: sed -e s/.T8:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK8 %s
+; RUN: sed -e s/.T9:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK9 %s
+; RUN: sed -e s/.T10:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK10 %s
+; RUN: sed -e s/.T11:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK11 %s
+; RUN: sed -e s/.T12:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK12 %s
+; RUN: sed -e s/.T13:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK13 %s
+; RUN: sed -e s/.T14:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK14 %s
+; RUN: sed -e s/.T15:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK15 %s
+; RUN: sed -e s/.T16:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK16 %s
+; RUN: sed -e s/.T17:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK17 %s
+; RUN: sed -e s/.T18:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK18 %s
+; RUN: sed -e s/.T19:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK19 %s
+; RUN: sed -e s/.T20:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK20 %s
+; RUN: sed -e s/.T21:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK21 %s
+; RUN: sed -e s/.T22:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK22 %s
+; RUN: sed -e s/.T23:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK23 %s
+; RUN: sed -e s/.T24:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK24 %s
+; RUN: sed -e s/.T25:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK25 %s
+; RUN: sed -e s/.T26:// %s | not opt -passes=verify -disable-output 2>&1 | FileCheck --check-prefix=CHECK26 %s
 
 declare void @g()
 
 ;T1: define void @f() {
 ;T1:   entry:
 ;T1:     catchret from undef to label %next
 ;T1:     ; CHECK1: CatchReturnInst needs to be provided a CatchPad
 ;T1:   next:

llvm/test/Verifier/invalid-splice.ll

-; RUN: not opt -verify -S < %s 2>&1 >/dev/null | FileCheck %s
+; RUN: not opt -passes=verify -S < %s 2>&1 >/dev/null | FileCheck %s
 
 ; CHECK: The splice index exceeds the range [-VL, VL-1] where VL is the known minimum number of elements in the vector
 define <2 x double> @splice_v2f64_idx_neg3(<2 x double> %a, <2 x double> %b) #0 {
   %res = call <2 x double> @llvm.experimental.vector.splice.v2f64(<2 x double> %a, <2 x double> %b, i32 -3)
   ret <2 x double> %res
 }
 
 ; CHECK: The splice index exceeds the range [-VL, VL-1] where VL is the known minimum number of elements in the vector

llvm/test/Verifier/invalid-statepoint.ll

-; RUN: not opt -verify 2>&1 < %s | FileCheck %s
+; RUN: not opt -passes=verify 2>&1 < %s | FileCheck %s
 
 declare zeroext i1 @return0i1()
 
 ; Function Attrs: nounwind
 declare token @llvm.experimental.gc.statepoint.p0f0i1f(i64, i32, i1 ()*, i32, i32, ...) #0
 
 ; Function Attrs: nounwind
 declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(token, i32, i32) #0

llvm/test/Verifier/kcfi-operand-bundles.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 define void @test_kcfi_bundle(i64 %arg0, i32 %arg1, void()* %arg2) {
 ; CHECK: Multiple kcfi operand bundles
 ; CHECK-NEXT: call void %arg2() [ "kcfi"(i32 42), "kcfi"(i32 42) ]
   call void %arg2() [ "kcfi"(i32 42), "kcfi"(i32 42) ]
 
 ; CHECK: Kcfi bundle operand must be an i32 constant
 ; CHECK-NEXT: call void %arg2() [ "kcfi"(i64 42) ]
   call void %arg2() [ "kcfi"(i64 42) ]
 
 ; CHECK-NOT: call
   call void %arg2() [ "kcfi"(i32 42) ] ; OK
   call void %arg2() [ "kcfi"(i32 42) ] ; OK
   ret void
 }

llvm/test/Verifier/llvm.fptrunc.round.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 declare half @llvm.fptrunc.round(float, metadata)
 
 define void @test_fptrunc_round_dynamic(float %a) {
 ; CHECK: unsupported rounding mode argument
   %res = call half @llvm.fptrunc.round(float %a, metadata !"round.dynamic")
 ; CHECK: unsupported rounding mode argument
   %res1 = call half @llvm.fptrunc.round(float %a, metadata !"round.test")
 ; CHECK: invalid value for llvm.fptrunc.round metadata operand (the operand should be a string)
   %res2 = call half @llvm.fptrunc.round(float %a, metadata i32 5)
   ret void
 }

llvm/test/Verifier/memcpy-inline.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
-; CHECK: alignment is not a power of two 
+; CHECK: alignment is not a power of two
 
 define void @foo(i8* %P, i8* %Q) {
   call void @llvm.memcpy.inline.p0i8.p0i8.i32(i8* align 3 %P, i8* %Q, i32 4, i1 false)
   ret void
 }
 declare void @llvm.memcpy.inline.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind

llvm/test/Verifier/memcpy.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
-; CHECK: alignment is not a power of two 
+; CHECK: alignment is not a power of two
 
 define void @foo(i8* %P, i8* %Q) {
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 3 %P, i8* %Q, i32 4, i1 false)
   ret void
 }
 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i1) nounwind

llvm/test/Verifier/memset-inline.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
-; CHECK: alignment is not a power of two 
+; CHECK: alignment is not a power of two
 
 define void @foo(i8* %P, i8 %value) {
   call void @llvm.memset.inline.p0i8.i32(i8* align 3 %P, i8 %value, i32 4, i1 false)
   ret void
 }
 declare void @llvm.memset.inline.p0i8.i32(i8* nocapture, i8, i32, i1) nounwind

llvm/test/Verifier/opaque-ptr-invalid.ll

-; RUN: not opt -verify -opaque-pointers < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify -opaque-pointers < %s 2>&1 | FileCheck %s
 
 ; CHECK: Attribute 'inalloca' does not support unsized types!
 ; CHECK-NEXT: ptr @f
 define void @f(ptr inalloca(token)) {
     ret void
 }

llvm/test/Verifier/operand-bundles.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 %0 = type opaque
 declare void @g()
 declare %0* @foo0()
 declare i8 @foo1()
 declare void @noreturn_func()
 
 ; Operand bundles uses are like regular uses, and need to be dominated

llvm/test/Verifier/preallocated-invalid.ll

-; RUN: not opt -S %s -verify 2>&1 | FileCheck %s
+; RUN: not opt -S %s -passes=verify 2>&1 | FileCheck %s
 
 declare token @llvm.call.preallocated.setup(i32)
 declare i8* @llvm.call.preallocated.arg(token, i32)
 declare void @llvm.call.preallocated.teardown(token)
 
 ; Fake LLVM intrinsic to return a token
 declare token @llvm.what()
 

llvm/test/Verifier/ptrauth-operand-bundles.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 declare void @g()
 
 define void @test_ptrauth_bundle(i64 %arg0, i32 %arg1, void()* %arg2) {
 
 ; CHECK: Multiple ptrauth operand bundles
 ; CHECK-NEXT: call void %arg2() [ "ptrauth"(i32 42, i64 100), "ptrauth"(i32 42, i64 %arg0) ]
   call void %arg2() [ "ptrauth"(i32 42, i64 100), "ptrauth"(i32 42, i64 %arg0) ]

llvm/test/Verifier/reduction-intrinsics.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 ; Reject a vector reduction with a non-vector argument.
 
 define float @reduce_vector_not_vec_arg(float %x) {
 ; CHECK: Intrinsic has incorrect argument type!
   %r0 = call float @llvm.vector.reduce.fmax.f32(float %x)
   ret float %r0
 }

llvm/test/Verifier/sat-intrinsics.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 define i32 @sadd_arg_int(float %x, i32 %y) {
 ; CHECK: Intrinsic has incorrect argument type!
   %r = call i32 @llvm.sadd.sat.i32(float %x, i32 %y)
   ret i32 %r
 }
 
 define i37 @uadd_arg_int(half %x, i37 %y) {

llvm/test/Verifier/scalable-global-vars.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 ;; Global variables cannot be scalable vectors, since we don't
 ;; know the size at compile time.
 
 ; CHECK: Globals cannot contain scalable vectors
 ; CHECK-NEXT: <vscale x 4 x i32>* @ScalableVecGlobal
 @ScalableVecGlobal = global <vscale x 4 x i32> zeroinitializer
 
 ; CHECK-NEXT: Globals cannot contain scalable vectors
 ; CHECK-NEXT: { i32, <vscale x 4 x i32> }* @ScalableVecStructGlobal
 @ScalableVecStructGlobal = global { i32,  <vscale x 4 x i32> } zeroinitializer
 
 ;; Global _pointers_ to scalable vectors are fine
 ; CHECK-NOT: Globals cannot contain scalable vectors
 @ScalableVecPtr = global <vscale x 8 x i16>* zeroinitializer

llvm/test/Verifier/scalable-vector-struct-alloca.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 define void @alloca() {
 ; CHECK: error: Cannot allocate unsized type
   %a = alloca { i32, <vscale x 1 x i32> }
   ret void
 }

llvm/test/Verifier/scalable-vector-struct-load.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 define <vscale x 1 x i32> @load({ i32, <vscale x 1 x i32> }* %x) {
 ; CHECK: error: loading unsized types is not allowed
   %a = load { i32, <vscale x 1 x i32> }, { i32, <vscale x 1 x i32> }* %x
   %b = extractvalue { i32, <vscale x 1 x i32> } %a, 1
   ret <vscale x 1 x i32> %b
 }

llvm/test/Verifier/scalable-vector-struct-store.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 define void @store({ i32, <vscale x 1 x i32> }* %x, i32 %y, <vscale x 1 x i32> %z) {
 ; CHECK: error: storing unsized types is not allowed
   %a = insertvalue { i32, <vscale x 1 x i32> } undef, i32 %y, 0
   %b = insertvalue { i32, <vscale x 1 x i32> } %a,  <vscale x 1 x i32> %z, 1
   store { i32, <vscale x 1 x i32> } %b, { i32, <vscale x 1 x i32> }* %x
   ret void
 }

llvm/test/Verifier/scatter_gather.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 ; Mask is not a vector
 ; CHECK: Intrinsic has incorrect argument type!
 define <16 x float> @gather2(<16 x float*> %ptrs, <16 x i1>* %mask, <16 x float> %passthru) {
   %res = call <16 x float> @llvm.masked.gather.v16f32.v16p0f32(<16 x float*> %ptrs, i32 4, <16 x i1>* %mask, <16 x float> %passthru)
   ret <16 x float> %res
 }
 declare <16 x float> @llvm.masked.gather.v16f32.v16p0f32(<16 x float*>, i32, <16 x i1>*, <16 x float>)

 ; Value length!= vector of pointers length
 ; CHECK: Intrinsic has incorrect argument type!
 define <8 x float> @gather8(<16 x float*> %ptrs, <8 x i1> %mask, <8 x float> %passthru) {
   %res = call <8 x float> @llvm.masked.gather.v8f32.v16p0f32(<16 x float*> %ptrs, i32 4, <8 x i1> %mask, <8 x float> %passthru)
   ret <8 x float> %res
 }
 declare <8 x float> @llvm.masked.gather.v8f32.v16p0f32(<16 x float*>, i32, <8 x i1>, <8 x float>)
 
-; Passthru type doesn't match return type 
+; Passthru type doesn't match return type
 ; CHECK: Intrinsic has incorrect argument type!
 define <16 x i32> @gather9(<16 x i32*> %ptrs, <16 x i1> %mask, <8 x i32> %passthru) {
   %res = call <16 x i32> @llvm.masked.gather.v16i32.v16p0i32(<16 x i32*> %ptrs, i32 4, <16 x i1> %mask, <8 x i32> %passthru)
   ret <16 x i32> %res
 }
 declare <16 x i32> @llvm.masked.gather.v16i32.v16p0i32(<16 x i32*>, i32, <16 x i1>, <8 x i32>)
 
 ; Mask is not a vector

llvm/test/Verifier/stepvector-intrinsic.ll

-; RUN: not opt -S -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -S -passes=verify < %s 2>&1 | FileCheck %s
 
 ; Reject stepvector intrinsics that return a scalar
 
 define i32 @stepvector_i32() {
 ; CHECK: Intrinsic has incorrect return type!
   %1 = call i32 @llvm.experimental.stepvector.i32()
   ret i32 %1
 }

llvm/test/Verifier/swifttailcc-musttail.ll

-; RUN: not opt -verify %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify %s 2>&1 | FileCheck %s
 
 declare swifttailcc void @simple()
 
 define swifttailcc void @inreg(i8* inreg) {
 ; CHECK: inreg attribute not allowed in swifttailcc musttail caller
   musttail call swifttailcc void @simple()
   ret void
 }

llvm/test/Verifier/tailcc-musttail.ll

-; RUN: not opt -verify %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify %s 2>&1 | FileCheck %s
 
 declare tailcc void @simple()
 
 define tailcc void @inreg(i8* inreg) {
 ; CHECK: inreg attribute not allowed in tailcc musttail caller
   musttail call tailcc void @simple()
   ret void
 }

llvm/test/Verifier/unsized-types-alloca.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 %X = type opaque
 
 define void @f_2() {
   %t = alloca %X
   ret void
 ; CHECK: Cannot allocate unsized type
 ; CHECK-NEXT:  %t = alloca %X
 }

llvm/test/Verifier/unsized-types-load.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 %X = type opaque
 
 define void @f_0(%X* %ptr) {
   %t = load %X, %X* %ptr
   ret void
 ; CHECK: loading unsized types is not allowed
 ; CHECK-NEXT:  %t = load %X, %X* %ptr
 }

llvm/test/Verifier/unsized-types-store.ll

-; RUN: not opt -verify < %s 2>&1 | FileCheck %s
+; RUN: not opt -passes=verify < %s 2>&1 | FileCheck %s
 
 %X = type opaque
 
 define void @f_1(%X %val, %X* %ptr) {
   store %X %val, %X* %ptr
   ret void
 ; CHECK: storing unsized types is not allowed
 ; CHECK-NEXT:  store %X %val, %X* %ptr
 }

llvm/tools/opt/opt.cpp

 static cl::opt<std::string> PassPipeline(
     "passes",
     cl::desc(
         "A textual description of the pass pipeline. To have analysis passes "
         "available before a certain pass, add 'require<foo-analysis>'."));
 static cl::alias PassPipeline2("p", cl::aliasopt(PassPipeline),
                                    cl::desc("Alias for -passes"));
 
-static cl::opt<bool> TemporarilyAllowOldPassesSyntax(
-    "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",
                                  cl::desc("Print available passes that can be "
                                           "specified in -passes=foo and exit"));
 
 static cl::opt<std::string>
 InputFilename(cl::Positional, cl::desc("<input bitcode file>"),
     cl::init("-"), cl::value_desc("filename"));
 
#endif
 
   // If `-passes=` is specified, use NPM.
   // If `-enable-new-pm` is specified and there are no codegen passes, use NPM.
   // e.g. `-enable-new-pm -sroa` will use NPM.
   // but `-enable-new-pm -codegenprepare` will still revert to legacy PM.
   const bool UseNPM = (EnableNewPassManager && !shouldForceLegacyPM()) ||
                       PassPipeline.getNumOccurrences() > 0;
 
+  if (UseNPM && !PassList.empty()) {
+    errs() << "The `opt -passname` syntax for the new pass manager is "
+              "not supported, please use `opt -passes=<pipeline>` (or the `-p` "
+              "alias for a more concise version).\n";
+    errs() << "See https://llvm.org/docs/NewPassManager.html#invoking-opt "
+              "for more details on the pass pipeline syntax.\n\n";
+    return 1;
+  }
+
   if (!UseNPM && PluginList.size()) {
     errs() << argv[0] << ": " << PassPlugins.ArgStr
            << " specified with legacy PM.\n";
     return 1;
   }
 
   // FIXME: once the legacy PM code is deleted, move runPassPipeline() here and
   // construct the PassBuilder before parsing IR so we can reuse the same
if (NumOLevel > 1) {
       return 1;
     }
     if (NumOLevel > 0 &&
         (PassPipeline.getNumOccurrences() > 0 || PassList.size() > 0)) {
       errs() << "Cannot specify -O# and --passes=/--foo-pass, use "
                 "-passes='default<O#>,other-pass'\n";
       return 1;
     }
-    if (!PassList.empty()) {
-      errs() << "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).\n";
-      errs() << "See https://llvm.org/docs/NewPassManager.html#invoking-opt "
-                "for more details on the pass pipeline syntax.\n\n";
-      if (!TemporarilyAllowOldPassesSyntax)
-        return 1;
-    }
     std::string Pipeline = PassPipeline;
 
     SmallVector<StringRef, 4> Passes;
     if (OptLevelO0)
       Pipeline = "default<O0>";
     if (OptLevelO1)
       Pipeline = "default<O1>";
     if (OptLevelO2)