[flang][windows] Run regression tests under Windows. NFCI.

[Meinersbur]

Summary

Allow the lit test test suite to run under Windows. This encompasses the following changes:

• Define lit_tools_dir for flang's test configuration
• Replace (<command> || true) idiom with not <command>
• Add REQUIRES: shell on tests that invoke a shell script

[Meinersbur]

Rebase and add REQUIRES: shell to additional tests

[Meinersbur]

ping

Is there interest in this? Windows buildbot is still failing (http://meinersbur.de:8011/#/builders/146/builds/169).

[awarzynski]

Makes a lot of sense, thanks!

[kiranchandramohan]

@Meinersbur In the longer term, to enable these tests on winodws, would porting the shell scripts to python be the right approach?

[Meinersbur]

A lot has changed since I put up this patch and I will need some time rebasing.

In D89368#2793560, @kiranchandramohan wrote:

@Meinersbur In the longer term, to enable these tests on winodws, would porting the shell scripts to python be the right approach?

LLVM (especially llvm-lit) also uses python for testing, so I think it makes a lot of sense. I think it was discussed once in a flang call.

[Meinersbur]

• Rebase

flang/test/Evaluate/folding01.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 
 ! Test intrinsic operation folding
 
 module m
 ! Check logical intrinsic operation folding
   logical, parameter :: test_not1 = .NOT..false.
   logical, parameter :: test_not2 = .NOT..NOT..true.
 

flang/test/Evaluate/folding02.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Check intrinsic function folding with host runtime library
 
 module m
   real(4), parameter :: eps4 = 0.000001_4
   real(8), parameter :: eps8 = 0.000000000000001_8
 
   ! These eps have been set so that constant folding of intrinsic
   ! functions that use host runtime can be tested independently of

flang/test/Evaluate/folding03.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Test operation folding edge case (both expected value and messages)
 ! These tests make assumptions regarding real(4) and integer(4) extrema.
 
 #define TEST_ISNAN(v) logical, parameter :: test_##v =.NOT.(v.EQ.v)
 
 module integer_tests
   integer(4), parameter :: i4_pmax = 2147483647_4
   ! Fortran grammar rule R605 prevents from writing -2147483648_4 in an

flang/test/Evaluate/folding04.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Test intrinsic function folding edge case (both expected value and messages)
 ! These tests make assumptions regarding real(4) extrema.
 
 #define TEST_ISNAN(v) logical, parameter :: test_##v =.NOT.(v.EQ.v)
 
 
 module real_tests
   ! Test real(4) intrinsic folding on edge cases (inf and NaN)

flang/test/Evaluate/folding06.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Test transformational intrinsic function folding
 
 module m
 
   type A
     real(4) x
     integer(8) i
   end type

flang/test/Evaluate/folding07.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Test numeric model inquiry intrinsics
 
 module m
 
   integer, parameter :: &
     bs1 = bit_size(0_1), &
     bs2 = bit_size(0_2), &
     bs4 = bit_size(0_4), &

flang/test/Evaluate/folding08.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Test folding of LBOUND and UBOUND
 
 module m
  contains
   function foo()
     real :: foo(2:3,4:6)
   end function
   subroutine test(n1,a1,a2)

flang/test/Evaluate/folding09.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Test folding of IS_CONTIGUOUS on simply contiguous items (9.5.4)
 ! When IS_CONTIGUOUS() is constant, it's .TRUE.
 
 module m
   real, target :: hosted(2)
  contains
   function f()
     real, pointer, contiguous :: f(:)

flang/test/Evaluate/folding10.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Tests folding of SHAPE(TRANSFER(...))
 
 module m
   logical, parameter :: test_size_1 = size(shape(transfer(123456789,0_1,size=4))) == 1
   logical, parameter :: test_size_2 = all(shape(transfer(123456789,0_1,size=4)) == [4])
   logical, parameter :: test_scalar_1 = size(shape(transfer(123456789, 0_1))) == 0
   logical, parameter :: test_vector_1 = size(shape(transfer(123456789, [0_1]))) == 1
   logical, parameter :: test_vector_2 = all(shape(transfer(123456789, [0_1])) == [4])
   logical, parameter :: test_array_1 = size(shape(transfer(123456789, reshape([0_1],[1,1])))) == 1
   logical, parameter :: test_array_2 = all(shape(transfer(123456789, reshape([0_1],[1,1]))) == [4])
   logical, parameter :: test_array_3 = all(shape(transfer([1.,2.,3.], [(0.,0.)])) == [2])
 end module

flang/test/Evaluate/folding11.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 module m
   complex, parameter :: z1 = 1. + (2., 3.)
   logical, parameter :: test_z1 = z1 == (3., 3.)
   complex, parameter :: z2 = 1 + (2., 3.)
   logical, parameter :: test_z2 = z2 == (3., 3.)
   complex, parameter :: z3 = 2. * (3., 4.)
   logical, parameter :: test_z3 = z3 == (6., 8.)
   complex, parameter :: z4 = 2 * (3., 4.)

flang/test/Evaluate/folding12.f90

 ! RUN: %S/test_folding.sh %s %t %f18
+! REQUIRES: shell
 ! Test folding of structure constructors
 module m1
   type parent_type
     integer :: parent_field
   end type parent_type
   type, extends(parent_type) :: child_type
     integer :: child_field 
   end type child_type

flang/test/Preprocessing/pp130.F90

-! RUN: (%f18 -E %s 2>&1 || true) | FileCheck %s
+! RUN: not %f18 -E %s 2>&1 | FileCheck %s
 ! CHECK: error: bad character ('&') in Fortran token
 ! #define KWM &, use for continuation w/o pasting (ifort and nag seem to continue #define)
 #define KWM &
 
       integer :: j
       j = 666
       j = j + KWM
 111
       if (j .eq. 777) then
         print *, 'pp130.F90 yes'
       else
         print *, 'pp130.F90 no', j
       end if
       end

flang/test/Semantics/acc-branch.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenacc
+! REQUIRES: shell
 
 ! Check OpenACC restruction in branch in and out of some construct
 !
 
 program openacc_clause_validity
 
   implicit none
 

flang/test/Semantics/acc-canonicalization-validity.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenacc
+! REQUIRES: shell
 
 ! Check OpenACC canonalization validity for the construct defined below:
 !   2.9 Loop
 !   2.11 Parallel Loop
 !   2.11 Kernels Loop
 !   2.11 Serial Loop
 
 program openacc_clause_validity

flang/test/Semantics/acc-clause-validity.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenacc
+! REQUIRES: shell
 
 ! Check OpenACC clause validity for the following construct and directive:
 !   2.6.5 Data
 !   2.5.1 Parallel
 !   2.5.2 Kernels
 !   2.5.3 Serial
 !   2.9 Loop
 !   2.13 Declare

flang/test/Semantics/acc-resolve01.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenacc
+! REQUIRES: shell
 
 ! Data-Mapping Attribute Clauses
 ! 2.15.14 default Clause
 
 subroutine default_none()
   integer a(3)
 
   A = 1

flang/test/Semantics/acc-resolve02.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenacc
+! REQUIRES: shell
 
 subroutine compute()
   integer :: a(3), c, i
 
   a = 1
   !ERROR: 'c' appears in more than one data-sharing clause on the same OpenACC directive
   !$acc parallel firstprivate(c) private(c)
   do i = 1, 3
     a(i) = c
   end do
   !$acc end parallel
 end subroutine compute
 
 program mm
   call compute()
 end

flang/test/Semantics/acc-symbols01.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenacc
+! REQUIRES: shell
 
 !DEF: /mm MainProgram
 program mm
   !DEF: /mm/x ObjectEntity REAL(4)
   !DEF: /mm/y ObjectEntity REAL(4)
   real x, y
   !DEF: /mm/a ObjectEntity INTEGER(4)
   !DEF: /mm/b ObjectEntity INTEGER(4)

flang/test/Semantics/allocate01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 ! Creating a symbol that allocate should accept
 module share
   real, pointer :: rp
 end module share
 
 module m

flang/test/Semantics/allocate02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C943_C944(src, src2)
 ! C943
 ! No alloc-opt shall appear more than once in a given alloc-opt-list.
   character(50) msg
   integer stat, stat2

flang/test/Semantics/allocate03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C933_a(b1, ca3, ca4, cp3, cp3mold, cp4, cp7, cp8, bsrc)
 ! If any allocate-object has a deferred type parameter, is unlimited polymorphic,
 ! or is of abstract type, either type-spec or source-expr shall appear.
 
 ! Only testing deferred type parameters here.
 

flang/test/Semantics/allocate04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 
 subroutine C933_b(n)
 ! If any allocate-object has a deferred type parameter, is unlimited polymorphic,
 ! or is of abstract type, either type-spec or source-expr shall appear.
 
 ! only testing unlimited polymorphic and abstract-type here

flang/test/Semantics/allocate05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 
 subroutine C934()
 ! If type-spec appears, it shall specify a type with which each
 ! allocate-object is type compatible.
 
   type A

flang/test/Semantics/allocate06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 
 subroutine C935(l, ac1, ac2, ac3, dc1, dc2, ec1, ec2, aa, ab, ab2, ea, eb, da, db, whatever, something, something_else)
 ! A type-param-value in a type-spec shall be an asterisk if and only if each
 ! allocate-object is a dummy argument for which the corresponding type parameter
 ! is assumed.
 

flang/test/Semantics/allocate07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C936(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
 ! If type-spec appears, the kind type parameter values of each
 ! allocate-object shall be the same as the corresponding type
 ! parameter values of the type-spec.
 
   real(kind=4), allocatable :: x1, x2(:)

flang/test/Semantics/allocate08.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C945_a(srca, srcb, srcc, src_complex, src_logical, &
   srca2, srcb2, srcc2, src_complex2, srcx, srcx2)
 ! If type-spec appears, it shall specify a type with which each
 ! allocate-object is type compatible.
 
 !second part C945, specific to SOURCE, is not checked here.

flang/test/Semantics/allocate09.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C946(param_ca_4_assumed, param_ta_4_assumed, param_ca_4_deferred)
 ! If source-expr appears, the kind type parameters of each allocate-object shall
 ! have the same values as the corresponding type parameters of source-expr.
 
   real(kind=4), allocatable :: x1, x2(:)
 

flang/test/Semantics/allocate10.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 !TODO: mixing expr and source-expr?
 !TODO: using subcomponent in source expressions
 
 subroutine C939_C942a_C945b(xsrc1a, xsrc1c, xsrc0, xsrc2a, xsrc2c, pos)
 ! C939: If an allocate-object is an array, either allocate-shape-spec-list shall
 ! appear in its allocation, or source-expr shall appear in the ALLOCATE

flang/test/Semantics/allocate11.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 ! TODO: Function Pointer in allocate and derived types!
 
 ! Rules I should know when working with coarrays and derived type:
 
 ! C736: If EXTENDS appears and the type being defined has a coarray ultimate
 ! component, its parent type shall have a coarray ultimate component.

flang/test/Semantics/allocate12.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 subroutine C941_C942b_C950(xsrc, x1, a2, b2, cx1, ca2, cb1, cb2, c1)
 ! C941: An allocate-coarray-spec shall appear if and only if the allocate-object
 ! is a coarray.
   type type0
     real, allocatable :: array(:)
   end type

flang/test/Semantics/allocate13.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in ALLOCATE statements
 
 module not_iso_fortran_env
   type event_type
   end type
   type lock_type
   end type
 end module

flang/test/Semantics/altreturn01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check calls with alt returns
 
        CALL TEST (N, *100, *200 )
        PRINT *,'Normal return'
        STOP
 100    PRINT *,'First alternate return'
        STOP
 200    PRINT *,'Secondnd alternate return'
        END

flang/test/Semantics/altreturn02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check subroutine with alt return
 
        SUBROUTINE TEST (N, *, *)
        IF ( N .EQ. 0 ) RETURN
        IF ( N .EQ. 1 ) RETURN 1
        RETURN 2
        END

flang/test/Semantics/altreturn03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for various alt return error conditions
 
        SUBROUTINE TEST (N, *, *)
        REAL :: R
        COMPLEX :: Z
        INTEGER, DIMENSION(2) :: B
        IF ( N .EQ. 0 ) RETURN
        IF ( N .EQ. 1 ) RETURN 1

flang/test/Semantics/altreturn04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Functions cannot use alt return
 
 REAL FUNCTION altreturn01(X)
 !ERROR: RETURN with expression is only allowed in SUBROUTINE subprogram
   RETURN 1
 END

flang/test/Semantics/altreturn05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test extension: RETURN from main program
 
 return !ok
 !ERROR: RETURN with expression is only allowed in SUBROUTINE subprogram
 return 0
 end

flang/test/Semantics/array-constr-values.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Confirm enforcement of constraints and restrictions in 7.8
 ! C7110, C7111, C7112, C7113, C7114, C7115
 
 subroutine arrayconstructorvalues()
   integer :: intarray(5)
   integer(KIND=8) :: k8 = 20
 
   TYPE EMPLOYEE

flang/test/Semantics/assign01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! 10.2.3.1(2) All masks and LHS of assignments in a WHERE must conform
 
 subroutine s1
   integer :: a1(10), a2(10)
   logical :: m1(10), m2(5,5)
   m1 = .true.
   m2 = .false.
   a1 = [((i),i=1,10)]

flang/test/Semantics/assign02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Pointer assignment constraints 10.2.2.2
 
 module m1
   type :: t(k)
     integer, kind :: k
   end type
   type t2
     sequence

flang/test/Semantics/assign03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Pointer assignment constraints 10.2.2.2 (see also assign02.f90)
 
 module m
   interface
     subroutine s(i)
       integer i
     end
   end interface

flang/test/Semantics/assign04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! 9.4.5
 subroutine s1
   type :: t(k, l)
     integer, kind :: k
     integer, len :: l
   end type
   type(t(1, 2)) :: x
   !ERROR: Assignment to constant 'x%k' is not allowed

flang/test/Semantics/assign06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test ASSIGN statement, assigned GOTO, and assigned format labels
 ! (see subclause 8.2.4 in Fortran 90 (*not* 2018!)
 
 program main
   call test(0)
  contains
   subroutine test(n)
     integer, intent(in) :: n

flang/test/Semantics/assign07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test ASSIGN statement, assigned GOTO, and assigned format labels
 ! (see subclause 8.2.4 in Fortran 90 (*not* 2018!)
 
 program main
   call test(0)
 2 format('no')
  contains
   subroutine test(n)

flang/test/Semantics/bad-forward-type.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Forward references to derived types (error cases)
 ! C732 A parent-type-name shall be the name of a previously defined
 ! extensible type (7.5.7).
 
 !ERROR: The derived type 'undef' was forward-referenced but not defined
 type(undef) function f1()
   call sub(f1)
 end function

flang/test/Semantics/bindings01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Confirm enforcement of constraints and restrictions in 7.5.7.3
 ! and C733, C734 and C779, C780, C782, C783, C784, and C785.
 
 module m
   !ERROR: An ABSTRACT derived type must be extensible
   type, abstract, bind(c) :: badAbstract1
   end type
   !ERROR: An ABSTRACT derived type must be extensible

flang/test/Semantics/block-data01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test BLOCK DATA subprogram (14.3)
 block data foo
   !ERROR: IMPORT is not allowed in a BLOCK DATA subprogram
   import
   real :: pi = asin(-1.0) ! ok
   !ERROR: An initialized variable in BLOCK DATA must be in a COMMON block
   integer :: notInCommon = 1
   integer :: uninitialized ! ok

flang/test/Semantics/blockconstruct01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1107 -- COMMON, EQUIVALENCE, INTENT, NAMELIST, OPTIONAL, VALUE or
 !          STATEMENT FUNCTIONS not allow in specification part
 
 subroutine s1_c1107
   common /nl/x
   block
     !ERROR: COMMON statement is not allowed in a BLOCK construct
     common /nl/y

flang/test/Semantics/blockconstruct02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1108  --  Save statement in a BLOCK construct shall not conatin a
 !            saved-entity-list that does not specify a common-block-name
 
 program  main
   integer x, y, z
   real r, s, t
   common /argmnt2/ r, s, t
   !ERROR: 'argmnt1' appears as a COMMON block in a SAVE statement but not in a COMMON statement
   save /argmnt1/
   block
     !ERROR: SAVE statement in BLOCK construct may not contain a common block name 'argmnt2'
     save /argmnt2/
   end block
 end program

flang/test/Semantics/blockconstruct03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests implemented for this standard:
 !            Block Construct
 ! C1109
 
 subroutine s5_c1109
   b1:block
   !ERROR: BLOCK construct name mismatch
   end block b2
 end
 

flang/test/Semantics/boz-literal-constants.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Confirm enforcement of constraints and restrictions in 7.7
 ! C7107, C7108, C7109
 
 subroutine bozchecks
   ! Type declaration statements
   integer :: f, realpart = B"0101", img = B"1111", resint
   logical :: resbit
   complex :: rescmplx

flang/test/Semantics/c_f_pointer.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Enforce 18.2.3.3
 
 program test
   use iso_c_binding, only: c_ptr, c_f_pointer
   type(c_ptr) :: scalarC, arrayC(1)
   type :: with_pointer
     integer, pointer :: p
   end type

flang/test/Semantics/call01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Confirm enforcement of constraints and restrictions in 15.6.2.1
 
 non_recursive function f01(n) result(res)
   integer, value :: n
   integer :: res
   if (n <= 0) then
     res = n
   else

flang/test/Semantics/call02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! 15.5.1 procedure reference constraints and restrictions
 
 subroutine s01(elem, subr)
   interface
     elemental real function elem(x)
       real, intent(in), value :: x
     end function
     subroutine subr(dummy)

flang/test/Semantics/call03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.5.2.4 constraints and restrictions for non-POINTER non-ALLOCATABLE
 ! dummy arguments.
 
 module m01
   type :: t
   end type
   type :: pdt(n)
     integer, len :: n

flang/test/Semantics/call04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 8.5.10 & 8.5.18 constraints on dummy argument declarations
 
 module m
 
   type :: hasCoarray
     real, allocatable :: a(:)[:]
   end type
   type, extends(hasCoarray) :: extendsHasCoarray

flang/test/Semantics/call05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.5.2.5 constraints and restrictions for POINTER & ALLOCATABLE
 ! arguments when both sides of the call have the same attributes.
 
 module m
 
   type :: t
   end type
   type, extends(t) :: t2

flang/test/Semantics/call06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.5.2.6 constraints and restrictions for ALLOCATABLE
 ! dummy arguments.
 
 module m
 
   real, allocatable :: cov[:], com[:,:]
 
  contains

flang/test/Semantics/call07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.5.2.7 constraints and restrictions for POINTER dummy arguments.
 
 module m
   real :: coarray(10)[*]
  contains
 
   subroutine s01(p)
     real, pointer, contiguous, intent(in) :: p(:)

flang/test/Semantics/call08.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.5.2.8 coarray dummy arguments
 
 module m
 
   real :: c1[*]
   real, volatile :: c2[*]
 
  contains

flang/test/Semantics/call09.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.5.2.9(2,3,5) dummy procedure requirements
 
 module m
  contains
 
   integer function intfunc(x)
     integer, intent(in) :: x
     intfunc = x

flang/test/Semantics/call10.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.7 (C1583-C1590, C1592-C1599) constraints and restrictions
 ! for pure procedures.
 ! (C1591 is tested in call11.f90; C1594 in call12.f90.)
 
 module m
 
   type :: impureFinal
    contains

flang/test/Semantics/call11.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.7 C1591 & others: contexts requiring pure subprograms
 
 module m
 
   type :: t
    contains
     procedure, nopass :: tbp_pure => pure
     procedure, nopass :: tbp_impure => impure

flang/test/Semantics/call12.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.7 C1594 - prohibited assignments in pure subprograms
 
 module used
   real :: useassociated
 end module
 
 module m
   type :: t

flang/test/Semantics/call13.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 15.4.2.2 constraints and restrictions for calls to implicit
 ! interfaces
 
 subroutine s(assumedRank, coarray, class, classStar, typeStar)
   type :: t
   end type
 
   real :: assumedRank(..), coarray[*]

flang/test/Semantics/call14.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test 8.5.18 constraints on the VALUE attribute
 
 module m
   type :: hasCoarray
     real, allocatable :: coarray[:]
   end type
  contains
   !ERROR: VALUE attribute may apply only to a dummy data object

flang/test/Semantics/call15.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C711 An assumed-type actual argument that corresponds to an assumed-rank 
 ! dummy argument shall be assumed-shape or assumed-rank.
 subroutine s(arg1, arg2, arg3)
   type(*), dimension(..) :: arg1 ! assumed rank
   type(*), dimension(:) :: arg2 ! assumed shape
   type(*) :: arg3
 
   call inner(arg1) ! OK, assumed rank

flang/test/Semantics/case01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test SELECT CASE Constraints: C1145, C1146, C1147, C1148, C1149
 program selectCaseProg
    implicit none
    ! local variable declaration
    character :: grade1 = 'B'
    integer :: grade2 = 3
    logical :: grade3 = .false.
    real :: grade4 = 2.0

flang/test/Semantics/coarrays01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test selector and team-value in CHANGE TEAM statement
 
 ! OK
 subroutine s1
   use iso_fortran_env, only: team_type
   type(team_type) :: t
   real :: y[10,*]
   change team(t, x[10,*] => y)

flang/test/Semantics/complex01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C718 Each named constant in a complex literal constant shall be of type 
 ! integer or real.
 subroutine s()
   integer :: ivar = 35
   integer, parameter :: iconst = 35
   real :: rvar = 68.9
   real, parameter :: rconst = 68.9
   character :: cvar = 'hello'

flang/test/Semantics/computed-goto01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check that a basic computed goto compiles
 
 INTEGER, DIMENSION (2) :: B
 
 GOTO (100) 1
 GOTO (100) I
 GOTO (100) I+J
 GOTO (100) B(1)

flang/test/Semantics/computed-goto02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check that computed goto express must be a scalar integer expression
 ! TODO: PGI, for example, accepts a float & converts the value to int.
 
 REAL R
 COMPLEX Z
 LOGICAL L
 INTEGER, DIMENSION (2) :: B
 

flang/test/Semantics/critical01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !C1117
 
 subroutine test1(a, i)
   integer i
   real a(10)
   one: critical
     if (a(i) < 0.0) then
       a(i) = 20.20

flang/test/Semantics/critical02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !C1118
 
 subroutine test1
   critical
     !ERROR: RETURN statement is not allowed in a CRITICAL construct
     return
   end critical
 end subroutine test1

flang/test/Semantics/critical03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !C1119
 
 subroutine test1(a, i)
   integer i
   real a(10)
   critical
     if (a(i) < 0.0) then
       a(i) = 20.20

flang/test/Semantics/data01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !Test for checking data constraints, C882-C887
 module m1
   type person
     integer :: age
     character(len=25) :: name
   end type
   integer, parameter::digits(5) = ( /-11,-22,-33,44,55/ )
   integer ::notConstDigits(5)

flang/test/Semantics/data02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check that expressions are analyzed in data statements
 
 subroutine s1
   type :: t
     character(1) :: c
   end type
   type(t) :: x
   !ERROR: Value in structure constructor of type INTEGER(4) is incompatible with component 'c' of type CHARACTER(KIND=1,LEN=1_4)

flang/test/Semantics/data03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !Testing data constraints : C874 - C875, C878 - C881 
 module m
     integer, target :: modarray(1)
   contains
     function f(i)
       integer, intent(in) :: i
       integer, pointer :: f
       f => modarray(i)

flang/test/Semantics/data04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !Testing data constraints : C876, C877
 module m
   integer :: first
   contains
     subroutine h
       integer a,b
       !C876
       !ERROR: Host-associated object 'first' must not be initialized in a DATA statement

flang/test/Semantics/data06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! DATA statement errors
 subroutine s1
   type :: t1
     integer :: j = 666
   end type t1
   type(t1) :: t1x
   !ERROR: Default-initialized 't1x' must not be initialized in a DATA statement
   data t1x%j / 777 /

flang/test/Semantics/data07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
  contains
   subroutine s1
     !ERROR: DATA statement initializations affect 'jb(5_8)' more than once
     integer :: ja(10), jb(10)
     data (ja(k),k=1,9,2) / 5*1 / ! ok
     data (ja(k),k=10,2,-2) / 5*2 / ! ok
     data (jb(k),k=1,9,2) / 5*1 / ! ok
     data (jb(k),k=2,10,3) / 3*2 / ! conflict at 5
   end subroutine
 end module

flang/test/Semantics/deallocate01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test that DEALLOCATE works
 
 INTEGER, PARAMETER :: maxvalue=1024
 
 Type dt
   Integer :: l = 3
 End Type
 Type t

flang/test/Semantics/deallocate04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for type errors in DEALLOCATE statements
 
 INTEGER, PARAMETER :: maxvalue=1024
 
 Type dt
   Integer :: l = 3
 End Type
 Type t

flang/test/Semantics/deallocate05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in DEALLOCATE statements
 
 Module share
   Real, Pointer :: rp
 End Module share
 
 Program deallocatetest
 Use share

flang/test/Semantics/deallocate06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! Test deallocate of use- and host-associated variables
 module m1
   real, pointer :: a(:)
   real, allocatable :: b(:)
 end
 
 subroutine s1()

flang/test/Semantics/doconcurrent01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1141
 ! A reference to the procedure IEEE_SET_HALTING_MODE ! from the intrinsic 
 ! module IEEE_EXCEPTIONS, shall not ! appear within a DO CONCURRENT construct.
 !
 ! C1137
 ! An image control statement shall not appear within a DO CONCURRENT construct.
 !
 ! C1136

flang/test/Semantics/doconcurrent05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1167 -- An exit-stmt shall not appear within a DO CONCURRENT construct if 
 ! it belongs to that construct or an outer construct.
 
 subroutine do_concurrent_test1(n)
   implicit none
   integer :: n
   integer :: j,k
   mydoc: do concurrent(j=1:n)

flang/test/Semantics/doconcurrent06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1167 -- An exit-stmt shall not appear within a DO CONCURRENT construct if 
 ! it belongs to that construct or an outer construct.
 
 subroutine do_concurrent_test1(n)
   implicit none
   integer :: i1,i2,i3,i4,i5,i6,n
   mytest1: if (n>0) then
   nc1:       do concurrent(i1=1:n)

flang/test/Semantics/doconcurrent08.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1140 -- A statement that might result in the deallocation of a polymorphic 
 ! entity shall not appear within a DO CONCURRENT construct.
 module m1
   ! Base type with scalar components
   type :: Base
     integer :: baseField1
   end type
 

flang/test/Semantics/dosemantics01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1131 -- check valid and invalid DO loop naming
 
 PROGRAM C1131
   IMPLICIT NONE
   ! Valid construct
   validDo: DO WHILE (.true.)
       PRINT *, "Hello"
     END DO ValidDo

flang/test/Semantics/dosemantics02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1121 -- any procedure referenced in a concurrent header must be pure
 
 ! Also, check that the step expressions are not zero.  This is prohibited by
 ! Section 11.1.7.4.1, paragraph 1.
 
 SUBROUTINE do_concurrent_c1121(i,n)
   IMPLICIT NONE
   INTEGER :: i, n, flag

flang/test/Semantics/dosemantics03.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -Mstandard -Werror
+! REQUIRES: shell
 
 ! Issue 458 -- semantic checks for a normal DO loop.  The DO variable
 ! and the initial, final, and step expressions must be INTEGER if the
 ! options for standard conformance and turning warnings into errors
 ! are both in effect.  This test turns on the options for standards
 ! conformance and turning warnings into errors.  This produces error
 ! messages for the cases where REAL and DOUBLE PRECISION variables
 ! and expressions are used in the DO controls.

flang/test/Semantics/dosemantics04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1123 -- Expressions in DO CONCURRENT header cannot reference variables
 ! declared in the same header
 PROGRAM dosemantics04
   IMPLICIT NONE
   INTEGER :: a, i, j, k, n
 
   !ERROR: DO CONCURRENT mask expression references variable 'n' in LOCAL locality-spec
   DO CONCURRENT (INTEGER *2 :: i = 1:10, i < j + n) LOCAL(n)

flang/test/Semantics/dosemantics05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test DO loop semantics for constraint C1130 --
 ! The constraint states that "If the locality-spec DEFAULT ( NONE ) appears in a
 ! DO CONCURRENT statement; a variable that is a local or construct entity of a
 ! scope containing the DO CONCURRENT construct; and that appears in the block of
 ! the construct; shall have its locality explicitly specified by that
 ! statement."
 
 module m

flang/test/Semantics/dosemantics06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1131, C1133 -- check valid and invalid DO loop naming
 ! C1131 (R1119) If the do-stmt of a do-construct specifies a do-construct-name,
 ! the corresponding end-do shall be an end-do-stmt specifying the same
 ! do-construct-name. If the do-stmt of a do-construct does not specify a
 ! do-construct-name, the corresponding end-do shall not specify a
 ! do-construct-name.
 !
 ! C1133 (R1119) If the do-stmt is a label-do-stmt, the corresponding end-do

flang/test/Semantics/dosemantics07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !C1132
 ! If the do-stmt is a nonlabel-do-stmt, the corresponding end-do shall be an
 ! end-do-stmt.
 subroutine s1()
   do while (.true.)
     print *, "Hello"
   continue
 !ERROR: expected 'END DO'
 end subroutine s1

flang/test/Semantics/dosemantics08.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1138 -- 
 ! A branch (11.2) within a DO CONCURRENT construct shall not have a branch
 ! target that is outside the construct.
 
 subroutine s1()
   do concurrent (i=1:10)
 !ERROR: Control flow escapes from DO CONCURRENT
     goto 99
   end do
 
 99 print *, "Hello"
 
 end subroutine s1

flang/test/Semantics/dosemantics09.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !C1129 
 !A variable that is referenced by the scalar-mask-expr of a
 !concurrent-header or by any concurrent-limit or concurrent-step in that
 !concurrent-header shall not appear in a LOCAL locality-spec in the same DO
 !CONCURRENT statement.
 
 subroutine s1()
 

flang/test/Semantics/dosemantics10.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1134 A CYCLE statement must be within a DO construct
 !
 ! C1166 An EXIT statement must be within a DO construct
 
 subroutine s1()
 ! this one's OK
   do i = 1,10
     cycle

flang/test/Semantics/dosemantics11.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1135 A cycle-stmt shall not appear within a CHANGE TEAM, CRITICAL, or DO 
 ! CONCURRENT construct if it belongs to an outer construct.
 !
 ! C1167 -- An exit-stmt shall not appear within a DO CONCURRENT construct if 
 ! it belongs to that construct or an outer construct.
 !
 ! C1168 -- An exit-stmt shall not appear within a CHANGE TEAM or CRITICAL 
 ! construct if it belongs to an outer construct.

flang/test/Semantics/dosemantics12.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Copyright (c) 2019, NVIDIA CORPORATION.  All rights reserved.
 !
 ! Licensed under the Apache License, Version 2.0 (the "License");
 ! you may not use this file except in compliance with the License.
 ! You may obtain a copy of the License at
 !
 !     http://www.apache.org/licenses/LICENSE-2.0
 !

flang/test/Semantics/entry01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests valid and invalid ENTRY statements
 
 module m1
   !ERROR: ENTRY may appear only in a subroutine or function
   entry badentryinmodule
   interface
     module subroutine separate
     end subroutine

flang/test/Semantics/equivalence01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   integer i, j
   real r(2)
   !ERROR: Equivalence set must have more than one object
   equivalence(i, j),(r(1))
 end
 
 subroutine s2

flang/test/Semantics/expr-errors01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1003 - can't parenthesize function call returning procedure pointer
 module m1
   type :: dt
     procedure(frpp), pointer, nopass :: pp
   end type dt
  contains
   subroutine boring
   end subroutine boring

flang/test/Semantics/expr-errors02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test specification expressions
 
 module m
   type :: t(n)
     integer, len :: n = 1
     character(len=n) :: c
   end type
   interface

flang/test/Semantics/final01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test FINAL subroutine constraints C786-C789
 module m1
   external :: external
   intrinsic :: sin
   real :: object
   procedure(valid), pointer :: pointer
   type :: parent(kind1, len1)
     integer, kind :: kind1 = 1

flang/test/Semantics/forall01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine forall1
   real :: a(9)
   !ERROR: 'i' is already declared in this scoping unit
   !ERROR: Cannot redefine FORALL variable 'i'
   forall (i=1:8, i=1:9)  a(i) = i
   !ERROR: 'i' is already declared in this scoping unit
   !ERROR: Cannot redefine FORALL variable 'i'
   forall (i=1:8, i=1:9)

flang/test/Semantics/if_arith01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check that a basic arithmetic if compiles.
 
 if ( A ) 100, 200, 300
 100 CONTINUE
 200 CONTINUE
 300 CONTINUE
 END

flang/test/Semantics/if_arith02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check that only labels are allowed in arithmetic if statements.
 ! TODO: Revisit error message "expected 'ASSIGN'" etc.
 ! TODO: Revisit error message "expected one of '0123456789'"
 
 ! TODO: BUG: Note that labels 500 and 600 do not exist and
 ! ought to be flagged as errors. This oversight may be the
 ! result of disabling semantic checking after syntax errors.
 

flang/test/Semantics/if_arith03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
-
+! REQUIRES: shell
 
 !ERROR: Label '600' was not found
 if ( A ) 100, 200, 600
 100 CONTINUE
 200 CONTINUE
 300 CONTINUE
 
 !ERROR: Label '601' was not found

flang/test/Semantics/if_arith04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Make sure arithmetic if expressions are non-complex numeric exprs.
 
 INTEGER I
 COMPLEX Z
 LOGICAL L
 INTEGER, DIMENSION (2) :: B
 
 if ( I ) 100, 200, 300

flang/test/Semantics/if_construct01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Simple check that if constructs are ok.
 
 if (a < b) then
   a = 1
 end if
 
 if (a < b) then
   a = 2

flang/test/Semantics/if_construct02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check that if constructs only accept scalar logical expressions.
 ! TODO: expand the test to check this restriction for more types.
 
 INTEGER :: I
 LOGICAL, DIMENSION (2) :: B
 
 !ERROR: Must be a scalar value, but is a rank-1 array
 if ( B ) then

flang/test/Semantics/if_stmt01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Simple check that if statements are ok.
 
 IF (A > 0.0) A = LOG (A)
 END

flang/test/Semantics/if_stmt02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !ERROR: IF statement is not allowed in IF statement
 IF (A > 0.0) IF (B < 0.0) A = LOG (A)
 END

flang/test/Semantics/if_stmt03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check that non-logical expressions are not allowed.
 ! Check that non-scalar expressions are not allowed.
 ! TODO: Insure all non-logicals are prohibited.
 
 LOGICAL, DIMENSION (2) :: B
 
 !ERROR: Must have LOGICAL type, but is REAL(4)
 IF (A) A = LOG (A)
 !ERROR: Must be a scalar value, but is a rank-1 array
 IF (B) A = LOG (A)
 
 END

flang/test/Semantics/implicit01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   implicit none
   !ERROR: More than one IMPLICIT NONE statement
   implicit none(type)
 end subroutine
 
 subroutine s2
   implicit none(external)
   !ERROR: More than one IMPLICIT NONE statement
   implicit none
 end subroutine

flang/test/Semantics/implicit02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   implicit none
   !ERROR: IMPLICIT statement after IMPLICIT NONE or IMPLICIT NONE(TYPE) statement
   implicit integer(a-z)
 end subroutine
 
 subroutine s2
   implicit none(type)
   !ERROR: IMPLICIT statement after IMPLICIT NONE or IMPLICIT NONE(TYPE) statement
   implicit integer(a-z)
 end subroutine

flang/test/Semantics/implicit03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   implicit integer(a-z)
   !ERROR: IMPLICIT NONE statement after IMPLICIT statement
   implicit none
 end subroutine
 
 subroutine s2
   implicit integer(a-z)
   !ERROR: IMPLICIT NONE(TYPE) after IMPLICIT statement
   implicit none(type)
 end subroutine

flang/test/Semantics/implicit04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s
   parameter(a=1.0)
   !ERROR: IMPLICIT NONE statement after PARAMETER statement
   implicit none
 end subroutine

flang/test/Semantics/implicit05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s
   !ERROR: 'a' does not follow 'b' alphabetically
   implicit integer(b-a)
 end

flang/test/Semantics/implicit06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   implicit integer(a-c)
   !ERROR: More than one implicit type specified for 'c'
   implicit real(c-g)
 end
 
 subroutine s2
   implicit integer(a-c)
   implicit real(8)(d)
   !ERROR: More than one implicit type specified for 'a'
   implicit integer(f), real(a)
 end

flang/test/Semantics/implicit07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 implicit none(external)
 external x
 call x
 !ERROR: 'y' is an external procedure without the EXTERNAL attribute in a scope with IMPLICIT NONE(EXTERNAL)
 call y
 block
   !ERROR: 'z' is an external procedure without the EXTERNAL attribute in a scope with IMPLICIT NONE(EXTERNAL)
   call z
 end block
 end

flang/test/Semantics/implicit08.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   block
     !ERROR: IMPLICIT statement is not allowed in a BLOCK construct
     implicit logical(a)
   end block
 end subroutine

flang/test/Semantics/implicit09.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fimplicit-none-type-never
+! REQUIRES: shell
 subroutine s1
   implicit none
   i = j + k  ! would be error without -fimplicit-none-type-never
 end
 
 subroutine s2(a, n)
   implicit none
   real :: a(n)  ! would be error without -fimplicit-none-type-never
   integer :: n
 end

flang/test/Semantics/implicit10.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fimplicit-none-type-always
+! REQUIRES: shell
 
 !ERROR: No explicit type declared for 'f'
 function f()
   !ERROR: No explicit type declared for 'x'
   f = x
 end

flang/test/Semantics/implicit11.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! Test use of implicitly declared variable in specification expression
 
 subroutine s1()
   m = 1
 contains
   subroutine s1a()
     implicit none

flang/test/Semantics/init01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Initializer error tests
 
 subroutine objectpointers(j)
   integer, intent(in) :: j
   real, allocatable, target, save :: x1
   real, codimension[*], target, save :: x2
   real, save :: x3
   real, target :: x4

flang/test/Semantics/int-literals.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Fortran syntax considers signed int literals in complex literals
 ! to be a distinct production, not an application of unary +/- to
 ! an unsigned int literal, so they're used here to test overflow
 ! on signed int literal constants.  The literals are tested here
 ! as part of expressions that name resolution must analyze.
 
 complex, parameter :: okj1 = 127_1, okz1 = (+127_1, -128_1)
 !ERROR: Integer literal is too large for INTEGER(KIND=1)

flang/test/Semantics/io01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   character(len=20) :: access = "direcT"
   character(len=20) :: access_(2) = (/"direcT", "streaM"/)
   character(len=20) :: action_(2) = (/"reaD ", "writE"/)
   character(len=20) :: asynchronous_(2) = (/"nO ", "yeS"/)
   character(len=20) :: blank_(2) = (/"nulL", "zerO"/)
   character(len=20) :: decimal_(2) = (/'commA', 'poinT'/)
   character(len=20) :: delim_(2) = (/"nonE ", "quotE"/)
   character(len=20) :: encoding_(2) = (/"defaulT", "utF-8  "/)

flang/test/Semantics/io02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   integer :: unit10 = 10
   integer :: unit11 = 11
   integer, parameter :: const_stat = 6666
 
   integer(kind=1) :: stat1
   integer(kind=8) :: stat8
 
   character(len=55) :: msg

flang/test/Semantics/io03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   character(kind=1,len=50) internal_file
   character(kind=2,len=50) internal_file2
   character(kind=4,len=50) internal_file4
   character(kind=1,len=50) internal_fileA(20)
   character(kind=1,len=111) msg
   character(20) advance
   character(20) :: cvar;
   character, parameter :: const_internal_file = "(I6)"

flang/test/Semantics/io04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   character(kind=1,len=50) internal_file
   character(kind=1,len=100) msg
   character(20) sign
   character, parameter :: const_internal_file = "(I6)"
   integer*1 stat1, id1
   integer*2 stat2
   integer*4 stat4
   integer*8 stat8

flang/test/Semantics/io05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   character*20 c(25), cv
   character(kind=1,len=59) msg
   character, parameter :: const_round = "c'est quoi?"
   logical*2 v(5), lv
   integer*1 stat1
   integer*2 stat4
   integer*8 stat8, iv
   integer, parameter :: const_id = 1

flang/test/Semantics/io06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   character(kind=1,len=100) msg1
   character(kind=2,len=200) msg2
   character, parameter :: const_msg = 'doof'
   integer(1) stat1
   integer(2) stat2
   integer(8) stat8
 
   open(10)

flang/test/Semantics/io07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 1001 format(A)
 
      !ERROR: Format statement must be labeled
      format(A)
 
 2001 format(3I8, 3Z8)
 2002 format(3I8, Z8)
 2003 format(  3  I  8  ,  3  Z  8  )

flang/test/Semantics/io08.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   write(*,*)
   write(*,'()')
   write(*,'(A)')
   write(*,'(2X:2X)')
   write(*,'(2X/2X)')
   write(*,'(3/2X)')
   write(*,'(3PF5.2)')
   write(*,'(+3PF5.2)')

flang/test/Semantics/io09.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
   !ERROR: String edit descriptor in READ format expression
   read(*,'("abc")')
 
   !ERROR: String edit descriptor in READ format expression
   !ERROR: Unterminated format expression
   read(*,'("abc)')
 
   !ERROR: 'H' edit descriptor in READ format expression

flang/test/Semantics/io10.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -Mstandard
+! REQUIRES: shell
 
   write(*, '(B0)')
   write(*, '(B3)')
 
   !WARNING: Expected 'B' edit descriptor 'w' value
   write(*, '(B)')
 
   !WARNING: Expected 'EN' edit descriptor 'w' value

flang/test/Semantics/kinds01.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
  !DEF: /MainProgram1/jk1 ObjectEntity INTEGER(1)
  integer(kind=1) jk1
  !DEF: /MainProgram1/js1 ObjectEntity INTEGER(1)
  integer*1 js1
  !DEF: /MainProgram1/jk2 ObjectEntity INTEGER(2)
  integer(kind=2) jk2
  !DEF: /MainProgram1/js2 ObjectEntity INTEGER(2)
  integer*2 js2

flang/test/Semantics/kinds02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C712 The value of scalar-int-constant-expr shall be nonnegative and 
 ! shall specify a representation method that exists on the processor.
 ! C714 The value of kind-param shall be nonnegative.
 ! C715 The value of kind-param shall specify a representation method that 
 ! exists on the processor.
 ! C719 The value of scalar-int-constant-expr shall be nonnegative and shall 
 ! specify a representation method that exists on the processor.
 ! C725 The optional comma in a length-selector is permitted only if no 

flang/test/Semantics/kinds03.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
  !DEF: /MainProgram1/ipdt DerivedType
  !DEF: /MainProgram1/ipdt/k TypeParam INTEGER(4)
  type :: ipdt(k)
   !REF: /MainProgram1/ipdt/k
   integer, kind :: k
   !REF: /MainProgram1/ipdt/k
   !DEF: /MainProgram1/ipdt/x ObjectEntity INTEGER(int(int(k,kind=4),kind=8))
   integer(kind=k) :: x

flang/test/Semantics/kinds04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C716 If both kind-param and exponent-letter appear, exponent-letter 
 ! shall be E.
 ! C717 The value of kind-param shall specify an approximation method that 
 ! exists on the processor.
 subroutine s(var)
   real :: realvar1 = 4.0E6_4
   real :: realvar2 = 4.0D6
   real :: realvar3 = 4.0Q6

flang/test/Semantics/misc-declarations.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Miscellaneous constraint and requirement checking on declarations:
 ! - 8.5.6.2 & 8.5.6.3 constraints on coarrays
 ! - 8.5.19 constraints on the VOLATILE attribute
 
 module m
   !ERROR: 'mustbedeferred' is an ALLOCATABLE coarray and must have a deferred coshape
   real, allocatable :: mustBeDeferred[*]  ! C827
   !ERROR: Component 'mustbeexplicit' is a non-ALLOCATABLE coarray and must have an explicit coshape

flang/test/Semantics/missing_newline.f90

 ! RUN: echo -n "end program" > %t.f90
 ! RUN: %f18 -fparse-only %t.f90
 ! RUN: echo -ne "\rend program" > %t.f90
 ! RUN: %f18 -fparse-only %t.f90
+! REQUIRES: shell

flang/test/Semantics/modfile01.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Check correct modfile generation for type with private component.
 module m
   integer :: i
   integer, private :: j
   type :: t
     integer :: i
     integer, private :: j
   end type

flang/test/Semantics/modfile02.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Check modfile generation for private type in public API.
 
 module m
   type, private :: t1
     integer :: i
   end type
   type, private :: t2
     integer :: i

flang/test/Semantics/modfile03.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Check modfile generation with use-association.
 
 module m1
   integer :: x1
   integer, private :: x2
 end
 !Expect: m1.mod
 !module m1

flang/test/Semantics/modfile04.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! modfile with subprograms
 
 module m1
   type :: t
   end type
 contains
 
   pure subroutine s(x, y) bind(c)

flang/test/Semantics/modfile05.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Use-association with VOLATILE or ASYNCHRONOUS
 
 module m1
   real x
   integer y
   volatile z
 contains
 end

flang/test/Semantics/modfile06.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Check modfile generation for external interface
 module m
   interface
     integer function f(x)
     end function
     subroutine s(y, z)
       logical y
       complex z

flang/test/Semantics/modfile07.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Check modfile generation for generic interfaces
 module m1
   interface foo
     real function s1(x,y)
       real, intent(in) :: x
       logical, intent(in) :: y
     end function
     complex function s2(x,y)

flang/test/Semantics/modfile08.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Check modfile generation for external declarations
 module m
   real, external :: a
   logical b
   external c
   complex c
   external b, d
   procedure() :: e

flang/test/Semantics/modfile09.f90

 !RUN: %S/test_modfile.sh '%S/Inputs/modfile09-*' %t %f18
+!REQUIRES: shell

flang/test/Semantics/modfile10.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test writing procedure bindings in a derived type.
 
 module m
   interface
     subroutine a(i, j)
       integer :: i, j
     end subroutine
   end interface

flang/test/Semantics/modfile11.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   type t1(a, b, c)
     integer, kind :: a
     integer(8), len :: b, c
     integer :: d
   end type
   type, extends(t1) :: t2(e)
     integer, len :: e

flang/test/Semantics/modfile12.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   integer(8), parameter :: a = 1, b = 2_8
   parameter(n=3,l=-3,e=1.0/3.0)
   real :: x(a:2*(a+b*n)-1)
   real, dimension(8) :: y
   type t(c, d)
     integer, kind :: c = 1
     integer, len :: d = a + b

flang/test/Semantics/modfile13.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   character(2) :: z
   character(len=3) :: y
   character*4 :: x
   character :: w
   character(len=:), allocatable :: v
 contains
   subroutine s(n, a, b, c, d)

flang/test/Semantics/modfile14.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   type t1
   contains
     procedure, nopass :: s2
     procedure, nopass :: s3
     procedure :: r
     generic :: foo => s2
     generic :: read(formatted)=> r

flang/test/Semantics/modfile15.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   type :: t
     procedure(a), pointer, pass :: c
     procedure(a), pointer, pass(x) :: d
   contains
     procedure, pass(y) :: a, b
   end type
 contains

flang/test/Semantics/modfile16.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   character(2), parameter :: prefix = 'c_'
   integer, bind(c, name='c_a') :: a
   procedure(sub), bind(c, name=prefix//'b'), pointer :: b
   type, bind(c) :: t
     real :: c
   end type
   real :: d

flang/test/Semantics/modfile17.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Tests parameterized derived type instantiation with KIND parameters
 
 module m
   type :: capture(k1,k2,k4,k8)
     integer(kind=1), kind :: k1
     integer(kind=2), kind :: k2
     integer(kind=4), kind :: k4
     integer(kind=8), kind :: k8

flang/test/Semantics/modfile18.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Tests folding of array constructors
 
 module m
   real, parameter :: a0 = 1.0_8
   real, parameter :: a1(2) = [real::2.0, 3.0]
   real, parameter :: a2(2) = [4.0, 5.0]
   real, parameter :: a3(0) = [real::]
   real, parameter :: a4(55) = [real::((1.0*k,k=1,j),j=1,10)]

flang/test/Semantics/modfile19.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   implicit complex(8)(z)
   real :: x
   namelist /nl1/ x, y
   namelist /nl2/ y, x
   namelist /nl1/ i, z
   complex(8) :: z
   real :: y

flang/test/Semantics/modfile20.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test modfiles for entities with initialization
 module m
   integer, parameter :: k8 = 8
   integer(8), parameter :: k4 = k8/2
   integer, parameter :: k1 = 1
   integer(k8), parameter :: i = 2_k8
   real :: r = 2.0_k4
   character(10, kind=k1) :: c = k1_"asdf"

flang/test/Semantics/modfile21.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m
   logical b
   bind(C) :: /cb2/
   common //t
   common /cb/ x(2:10) /cb2/a,b,c
   common /cb/ y,z
   common w
   common u,v

flang/test/Semantics/modfile22.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test character length conversions in constructors
 
 module m
 type :: t(k)
   integer, kind :: k = 1
   character(kind=k,len=1) :: a
   character(kind=k,len=3) :: b
 end type t

flang/test/Semantics/modfile23.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test that subprogram interfaces get all of the symbols that they need.
 
 module m1
   integer(8) :: i
   type t1
     sequence
     integer :: j
   end type

flang/test/Semantics/modfile24.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test declarations with coarray-spec
 
 ! Different ways of declaring the same coarray.
 module m1
   real :: a(1:5)[1:10,1:*]
   real, dimension(5) :: b[1:10,1:*]
   real, codimension[1:10,1:*] :: c(5)
   real, codimension[1:10,1:*], dimension(5) :: d

flang/test/Semantics/modfile25.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test compile-time analysis of shapes.
 
 module m1
   integer(8), parameter :: a0s(*) = shape(3.14159)
   real :: a1(5,5,5)
   integer(8), parameter :: a1s(*) = shape(a1)
   integer(8), parameter :: a1ss(*) = shape(a1s)
   integer(8), parameter :: a1sss(*) = shape(a1ss)

flang/test/Semantics/modfile26.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Intrinsics SELECTED_INT_KIND, SELECTED_REAL_KIND, PRECISION, RANGE,
 ! RADIX, DIGITS
 
 module m1
   ! INTEGER(KIND=1)  handles  0 <= P < 3
   ! INTEGER(KIND=2)  handles  3 <= P < 5
   ! INTEGER(KIND=4)  handles  5 <= P < 10
   ! INTEGER(KIND=8)  handles 10 <= P < 19

flang/test/Semantics/modfile27.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test folding of combined array references and structure component
 ! references.
 
 module m1
   type :: t1
     integer :: ia1(2)
   end type t1
   type(t1), parameter :: t1x1(*) = [t1::t1(ia1=[1,2]),t1(ia1=[3,4])]

flang/test/Semantics/modfile28.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 
 ! Test UTF-8 support in character literals
 ! Note: Module files are encoded in UTF-8.
 
 module m
 character(kind=4,len=*), parameter :: c4 = 4_"Hi! 你好!"
 ! In CHARACTER(1) literals, codepoints > 0xff are serialized into UTF-8;
 ! each of those bytes then gets encoded into UTF-8 for the module file.

flang/test/Semantics/modfile29.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Check that implicitly typed entities get a type in the module file.
 
 module m
   public :: a
   private :: b
   protected :: i
   allocatable :: j
 end
 
 !Expect: m.mod
 !module m
 ! real(4)::a
 ! real(4),private::b
 ! integer(4),protected::i
 ! integer(4),allocatable::j
 !end

flang/test/Semantics/modfile30.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Verify miscellaneous bugs
 
 ! The function result must be declared after the dummy arguments
 module m1
 contains
   function f1(x) result(y)
     integer :: x(:)
     integer :: y(size(x))

flang/test/Semantics/modfile31.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test 7.6 enum values
 
 module m1
   integer, parameter :: x(1) = [4]
   enum, bind(C)
     enumerator :: red, green
     enumerator blue
     enumerator yellow

flang/test/Semantics/modfile32.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Resolution of generic names in expressions.
 ! Test by using generic function in a specification expression that needs
 ! to be written to a .mod file.
 
 ! Resolve based on number of arguments
 module m1
   interface f
     pure integer(8) function f1(x)

flang/test/Semantics/modfile33.f90

 ! RUN: %S/test_modfile.sh %s %t %f18 -flogical-abbreviations -fxor-operator
+! REQUIRES: shell
 
 ! Resolution of user-defined operators in expressions.
 ! Test by using generic function in a specification expression that needs
 ! to be written to a .mod file.
 
 ! Numeric operators
 module m1
   type :: t

flang/test/Semantics/modfile34.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 ! Test resolution of type-bound generics.
 
 module m1
   type :: t
   contains
     procedure, pass(x) :: add1 => add
     procedure, nopass :: add2 => add
     procedure :: add_real

flang/test/Semantics/modfile35.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 module m1
   type :: t1
   contains
     procedure, pass(x) :: p1 => f
     procedure, non_overridable :: p2 => f
     procedure, nopass :: p3 => f
     generic :: operator(+) => p1
     generic :: operator(-) => p2

flang/test/Semantics/modfile36.f90

 ! RUN: %S/test_modfile.sh %s %t %f18
+! REQUIRES: shell
 
 ! Check modfile that contains import of use-assocation of another use-association.
 
 module m1
   interface
      subroutine s(x)
        use, intrinsic :: iso_c_binding, only: c_ptr
        type(c_ptr) :: x

flang/test/Semantics/namelist01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test for checking namelist constraints, C8103-C8105
 
 module dup
   integer dupName
   integer uniqueName
 end module dup
 
 subroutine C8103a(x)

flang/test/Semantics/null01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! NULL() intrinsic function error tests
 
 subroutine test
   interface
     subroutine s0
     end subroutine
     subroutine s1(j)
       integer, intent(in) :: j

flang/test/Semantics/nullify01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test that NULLIFY works
 
 Module share
   Real, Pointer :: rp
   Procedure(Real), Pointer :: mprp
 End Module share
 
 Program nullifytest

flang/test/Semantics/nullify02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in NULLIFY statements
 
 INTEGER, PARAMETER :: maxvalue=1024
 
 Type dt
   Integer :: l = 3
 End Type
 Type t

flang/test/Semantics/num_images.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Check for semantic errors in num_images() function calls
 
 subroutine test
 
   ! correct calls, should produce no errors
   print *, num_images()
   print *, num_images(team_number=1)
   print *, num_images(1)

flang/test/Semantics/omp-atomic.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 use omp_lib
 ! Check OpenMP 2.13.6 atomic Construct
 
   a = 1.0
   !$omp parallel num_threads(4)
   !$omp atomic seq_cst, read
   b = a
 

flang/test/Semantics/omp-clause-validity01.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 use omp_lib
 ! Check OpenMP clause validity for the following directives:
 !
 !    2.5 PARALLEL construct
 !    2.7.1 Loop construct
 !    ...
 
 ! TODO: all the internal errors

flang/test/Semantics/omp-combined-constructs.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 program main
   implicit none
   integer :: N
   integer :: i
   real(8) :: a(256), b(256)
   N = 256
 

flang/test/Semantics/omp-declarative-directive.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! Check OpenMP declarative directives
 
 !TODO: all internal errors
 !      enable declare-reduction example after name resolution
 
 ! 2.8.2 declare-simd
 

flang/test/Semantics/omp-device-constructs.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 ! Check OpenMP clause validity for the following directives:
 !     2.10 Device constructs
 program main
 
   real(8) :: arrayA(256), arrayB(256)
   integer :: N
 
   arrayA = 1.414

flang/test/Semantics/omp-loop-association.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! Check the association between OpenMPLoopConstruct and DoConstruct
 
   integer :: b = 128
   integer :: c = 32
   integer, parameter :: num = 16
   N = 1024
 

flang/test/Semantics/omp-nested01.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! Check OpenMP 2.17 Nesting of Regions
 
   N = 1024
   !$omp do
   do i = 1, N
      !ERROR: A worksharing region may not be closely nested inside a worksharing, explicit task, taskloop, critical, ordered, atomic, or master region
      !$omp do
      do j = 1, N
         a = 3.14
      enddo
   enddo
 end

flang/test/Semantics/omp-resolve01.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.4 An array section designates a subset of the elements in an array. Although
 ! Substring shares similar syntax but cannot be treated as valid array section.
 
   character*8 c, b
   character a
 
   b = "HIFROMPGI"
   c = b(2:7)
   !ERROR: Substrings are not allowed on OpenMP directives or clauses
   !$omp parallel private(c(1:3))
   a = c(1:1)
   !$omp end parallel
 end

flang/test/Semantics/omp-resolve02.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! Test the effect to name resolution from illegal clause
 
   !a = 1.0
   b = 2
   !$omp parallel private(a) shared(b)
   a = 3.
   b = 4

flang/test/Semantics/omp-resolve03.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.15.3 Although variables in common blocks can be accessed by use association
 ! or host association, common block names cannot. As a result, a common block
 ! name specified in a data-sharing attribute clause must be declared to be a
 ! common block in the same scoping unit in which the data-sharing attribute
 ! clause appears.
 
   common /c/ a, b

flang/test/Semantics/omp-resolve04.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.15.3 Data-Sharing Attribute Clauses
 ! A list item that specifies a given variable may not appear in more than
 ! one clause on the same directive, except that a variable may be specified
 ! in both firstprivate and lastprivate clauses.
 
   common /c/ a, b
   integer a(3), b

flang/test/Semantics/omp-resolve05.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.15.3 Data-Sharing Attribute Clauses
 ! 2.15.3.1 default Clause
 
 subroutine default_none()
   integer a(3)
 
   A = 1

flang/test/Semantics/omp-resolve06.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 use omp_lib
 !2.11.4 Allocate Clause
 !For any list item that is specified in the allocate
 !clause on a directive, a data-sharing attribute clause
 !that may create a private copy of that list item must be
 !specified on the same directive.
 
   integer ::  N = 2

flang/test/Semantics/omp-symbol01.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! Test clauses that accept list.
 ! 2.1 Directive Format
 !   A list consists of a comma-separated collection of one or more list items.
 !   A list item is a variable, array section or common block name (enclosed in
 !   slashes).
 
 !DEF: /md Module

flang/test/Semantics/omp-symbol02.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 1.4.1 Structure of the OpenMP Memory Model
 
 ! Test implicit declaration in the OpenMP directive enclosing scope
 ! through clause; also test to avoid creating multiple symbols for
 ! the same variable
 
   !DEF: /MainProgram1/b (Implicit) ObjectEntity REAL(4)

flang/test/Semantics/omp-symbol03.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 1.4.1 Structure of the OpenMP Memory Model
 ! In the inner OpenMP region, SHARED `a` refers to the `a` in the outer OpenMP
 ! region; PRIVATE `b` refers to the new `b` in the same OpenMP region
 
   !DEF: /MainProgram1/b (Implicit) ObjectEntity REAL(4)
   b = 2
   !$omp parallel  private(a) shared(b)

flang/test/Semantics/omp-symbol04.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.15.3 Data-Sharing Attribute Clauses
 ! Both PARALLEL and DO (worksharing) directives need to create new scope,
 ! so PRIVATE `a` will have new symbol in each region
 
   !DEF: /MainProgram1/a ObjectEntity REAL(8)
   real*8 a
   !REF: /MainProgram1/a

flang/test/Semantics/omp-symbol05.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.15.2 threadprivate Directive
 ! The threadprivate directive specifies that variables are replicated,
 ! with each thread having its own copy. When threadprivate variables are
 ! referenced in the OpenMP region, we know they are already private to
 ! their threads, so no new symbol needs to be created.
 
 !DEF: /mm Module

flang/test/Semantics/omp-symbol06.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.15.3 Data-Sharing Attribute Clauses
 ! A list item that specifies a given variable may not appear in more than
 ! one clause on the same directive, except that a variable may be specified
 ! in both firstprivate and lastprivate clauses.
 
   !DEF: /MainProgram1/a (Implicit) ObjectEntity REAL(4)
   a = 1.
   !$omp parallel do  firstprivate(a) lastprivate(a)
   !DEF: /MainProgram1/Block1/i (OmpPrivate, OmpPreDetermined) HostAssoc INTEGER(4)
   do i=1,10
      !DEF: /MainProgram1/Block1/a (OmpFirstPrivate, OmpLastPrivate) HostAssoc REAL(4)
      a = 2.
   end do
 end program

flang/test/Semantics/omp-symbol07.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! Generic tests
 !   1. subroutine or function calls should not be fixed for DSA or DMA
 
 !DEF: /foo (Function) Subprogram REAL(4)
 !DEF: /foo/rnum ObjectEntity REAL(4)
 function foo(rnum)
   !REF: /foo/rnum

flang/test/Semantics/omp-symbol08.f90

 ! RUN: %S/test_symbols.sh %s %t %f18 -fopenmp
+! REQUIRES: shell
 
 ! 2.15.1.1 Predetermined rules for associated do-loops index variable
 !   a) The loop iteration variable(s) in the associated do-loop(s) of a do,
 !      parallel do, taskloop, or distribute construct is (are) private.
 !   b) The loop iteration variable in the associated do-loop of a simd construct
 !      with just one associated do-loop is linear with a linear-step that is the
 !      increment of the associated do-loop.
 !   c) The loop iteration variables in the associated do-loops of a simd

flang/test/Semantics/procinterface01.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Tests for "proc-interface" semantics.
 ! These cases are all valid.
 
 !DEF: /module1 Module
 module module1
  abstract interface
   !DEF: /module1/abstract1 PUBLIC (Function) Subprogram REAL(4)
   !DEF: /module1/abstract1/x INTENT(IN) ObjectEntity REAL(4)

flang/test/Semantics/reshape.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 !Tests for RESHAPE
 program reshaper
   ! RESHAPE with arguments SOURCE and SHAPE
   integer, parameter :: array1(2,3) = RESHAPE([(n, n=1,6)], [2,3])
   ! RESHAPE with arguments SOURCE, SHAPE, and PAD
   integer :: array2(2,3) = RESHAPE([(n, n=1,4)], [2,3], [99])
   ! RESHAPE with arguments SOURCE, SHAPE, PAD, and ORDER

flang/test/Semantics/resolve01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 integer :: x
 !ERROR: The type of 'x' has already been declared
 real :: x
 integer(8) :: i
 parameter(i=1,j=2,k=3)
 integer :: j
 !ERROR: The type of 'k' has already been implicitly declared
 real :: k
 end

flang/test/Semantics/resolve02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s
   !ERROR: Declaration of 'x' conflicts with its use as internal procedure
   real :: x
 contains
   subroutine x
   end
 end
 
 module m
   !ERROR: Declaration of 'x' conflicts with its use as module procedure
   real :: x
 contains
   subroutine x
   end
 end

flang/test/Semantics/resolve03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 implicit none
 integer :: x
 !ERROR: No explicit type declared for 'y'
 y = x
 end

flang/test/Semantics/resolve04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 !ERROR: No explicit type declared for 'f'
 function f()
   implicit none
 end
 
 !ERROR: No explicit type declared for 'y'
 subroutine s(x, y)
   implicit none

flang/test/Semantics/resolve05.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 program p
   integer :: p ! this is ok
 end
 module m
   integer :: m ! this is ok
 end
 submodule(m) sm
   integer :: sm ! this is ok

flang/test/Semantics/resolve06.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 implicit none
 allocatable :: x
 integer :: x
 !ERROR: No explicit type declared for 'y'
 allocatable :: y
 end

flang/test/Semantics/resolve07.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   integer :: x(2)
   !ERROR: The dimensions of 'x' have already been declared
   allocatable :: x(:)
   real :: y[1:*]
   !ERROR: The codimensions of 'y' have already been declared
   allocatable :: y[:]
 end

flang/test/Semantics/resolve08.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 integer :: g(10)
 f(i) = i + 1  ! statement function
 g(i) = i + 2  ! mis-parsed array assignment
 !ERROR: 'h' has not been declared as an array
 h(i) = i + 3
 end

flang/test/Semantics/resolve09.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 integer :: y
 procedure() :: a
 procedure(real) :: b
 call a  ! OK - can be function or subroutine
 !ERROR: Cannot call subroutine 'a' like a function
 c = a()
 !ERROR: Cannot call function 'b' like a subroutine
 call b

flang/test/Semantics/resolve10.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   public
   type t
     integer, private :: i
   end type
   !ERROR: The default accessibility of this module has already been declared
   private  !C869
 end

flang/test/Semantics/resolve11.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   public i
   integer, private :: j
   !ERROR: The accessibility of 'i' has already been specified as PUBLIC
   private i
   !The accessibility of 'j' has already been specified as PRIVATE
   private j
 end

flang/test/Semantics/resolve12.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m1
 end
 
 subroutine sub
 end
 
 use m1
 !ERROR: Error reading module file for module 'm2'
 use m2
 !ERROR: 'sub' is not a module
 use sub
 end

flang/test/Semantics/resolve13.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m1
   integer :: x
   integer, private :: y
   interface operator(.foo.)
     module procedure ifoo
   end interface
   interface operator(-)
     module procedure ifoo

flang/test/Semantics/resolve14.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m1
   integer :: x
   integer :: y
   integer :: z
   integer, parameter :: k1 = selected_int_kind(9)
 end
 module m2
   real :: y

flang/test/Semantics/resolve15.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   real :: var
   interface i
     !ERROR: 'var' is not a subprogram
     procedure :: sub, var
     !ERROR: Procedure 'bad' not found
     procedure :: bad
   end interface

flang/test/Semantics/resolve16.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   interface
     subroutine sub0
     end
     !ERROR: A PROCEDURE statement is only allowed in a generic interface block
     procedure :: sub1, sub2
   end interface
 contains
   subroutine sub1
   end
   subroutine sub2
   end
 end

flang/test/Semantics/resolve17.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   integer :: foo
   !Note: PGI, Intel, and GNU allow this; NAG and Sun do not
   !ERROR: 'foo' is already declared in this scoping unit
   interface foo
   end interface
 end module
 

flang/test/Semantics/resolve18.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m1
   implicit none
 contains
   subroutine foo(x)
     real :: x
   end subroutine
 end module
 

flang/test/Semantics/resolve19.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   interface a
     subroutine s(x)
       real :: x
     end subroutine
     !ERROR: 's' is already declared in this scoping unit
     subroutine s(x)
       integer :: x

flang/test/Semantics/resolve20.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   abstract interface
     subroutine foo
     end subroutine
   end interface
 
   procedure() :: a
   procedure(integer) :: b

flang/test/Semantics/resolve21.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   type :: t
     integer :: i
     integer :: s1
     integer :: t
   end type
   !ERROR: 't' is already declared in this scoping unit
   integer :: t

flang/test/Semantics/resolve22.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   !OK: interface followed by type with same name
   interface t
   end interface
   type t
   end type
   type(t) :: x
   x = t()

flang/test/Semantics/resolve23.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   type :: t
     real :: y
   end type
 end module
 
 use m
 implicit type(t)(x)
 z = x%y  !OK: x is type(t)
 !ERROR: 'w' is not an object of derived type; it is implicitly typed
 z = w%y
 end

flang/test/Semantics/resolve24.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine test1
   !ERROR: Generic interface 'foo' has both a function and a subroutine
   interface foo
     subroutine s1(x)
     end subroutine
     subroutine s2(x, y)
     end subroutine
     function f()

flang/test/Semantics/resolve25.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   interface foo
     real function s1(x)
       real x
     end
     !ERROR: 's2' is not a module procedure
     module procedure s2
     !ERROR: Procedure 's3' not found

flang/test/Semantics/resolve26.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m1
   interface
     module subroutine s()
     end subroutine
   end interface
 end
 
 module m2

flang/test/Semantics/resolve27.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   interface
     module subroutine s()
     end subroutine
   end interface
 end
 
 submodule(m) s1

flang/test/Semantics/resolve28.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s
   type t
   end type
   interface
     subroutine s1
       import, none
       !ERROR: IMPORT,NONE must be the only IMPORT statement in a scope
       import, all

flang/test/Semantics/resolve29.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   type t1
   end type
   type t3
   end type
   interface
     subroutine s1(x)
       !ERROR: 't1' from host is not accessible

flang/test/Semantics/resolve30.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   integer x
   block
     import, none
     !ERROR: 'x' from host scoping unit is not accessible due to IMPORT
     x = 1
   end block
 end

flang/test/Semantics/resolve31.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C735 If EXTENDS appears, SEQUENCE shall not appear.
 ! C738 The same private-or-sequence shall not appear more than once in a
 ! given derived-type-def .
 !
 ! C740 If SEQUENCE appears,
 !  the type shall have at least one component,
 !  each data component shall be declared to be of an intrinsic type or of a sequence type,
 !  the derived type shall not have any type parameter,

flang/test/Semantics/resolve32.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m2
   public s2, s4
   private s3
 contains
   subroutine s2
   end
   subroutine s3
   end

flang/test/Semantics/resolve33.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Derived type parameters
 ! C731 The same type-param-name shall not appear more than once in a given
 ! derived-type-stmt.
 ! C741 A type-param-name in a type-param-def-stmt in a derived-type-def shall
 ! be one of the type-paramnames in the derived-type-stmt of that
 ! derived-type-def.
 ! C742 Each type-param-name in the derived-type-stmt in a derived-type-def
 ! shall appear exactly once as a type-param-name in a type-param-def-stmt 

flang/test/Semantics/resolve34.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Extended derived types
 
 module m1
   type :: t1
     integer :: x
     !ERROR: Component 'x' is already declared in this derived type
     real :: x
   end type

flang/test/Semantics/resolve35.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Construct names
 
 subroutine s1
   real :: foo
   !ERROR: 'foo' is already declared in this scoping unit
   foo: block
   end block foo
 end

flang/test/Semantics/resolve36.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! C1568 The procedure-name shall have been declared to be a separate module
 ! procedure in the containing program unit or an ancestor of that program unit.
 module m1
   interface
     module subroutine sub1(arg1)
       integer, intent(inout) :: arg1
     end subroutine

flang/test/Semantics/resolve37.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C701 The type-param-value for a kind type parameter shall be a constant
 ! expression.  This constraint looks like a mistake in the standard.
 integer, parameter :: k = 8
 real, parameter :: l = 8.0
 integer :: n = 2
 !ERROR: Must be a constant value
 parameter(m=n)
 integer(k) :: x

flang/test/Semantics/resolve38.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C772
 module m1
   type t1
   contains
     procedure, nopass :: s1
     !ERROR: Binding name 's2' not found in this derived type
     generic :: g1 => s2
   end type

flang/test/Semantics/resolve39.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   implicit none
   real(8) :: x = 2.0
   !ERROR: The associate name 'a' is already used in this associate statement
   associate(a => x, b => x+1, a => x+2)
     x = b
   end associate
   !ERROR: No explicit type declared for 'b'

flang/test/Semantics/resolve40.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   namelist /nl/x
   block
     !ERROR: NAMELIST statement is not allowed in a BLOCK construct
     namelist /nl/y
   end block
 end
 

flang/test/Semantics/resolve41.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
   implicit none
   real, parameter :: a = 8.0
   !ERROR: Must have INTEGER type, but is REAL(4)
   integer :: aa = 2_a
   integer :: b = 8
   ! C713 A scalar-int-constant-name shall be a named constant of type integer.
   !ERROR: Must be a constant value

flang/test/Semantics/resolve42.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1
   !ERROR: Array 'z' without ALLOCATABLE or POINTER attribute must have explicit shape
   common x, y(4), z(:)
 end
 
 subroutine s2
   common /c1/ x, y, z
   !ERROR: 'y' is already in a COMMON block

flang/test/Semantics/resolve43.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Error tests for structure constructors.
 ! Errors caught by expression resolution are tested elsewhere; these are the
 ! errors meant to be caught by name resolution, as well as acceptable use
 ! cases.
 ! Type parameters are used to make the parses unambiguous.
 
 module module1
   type :: type1(j)

flang/test/Semantics/resolve44.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Error tests for recursive use of derived types.
 ! C744 If neither the POINTER nor the ALLOCATABLE attribute is specified, the
 ! declaration-type-spec in the component-def-stmt shall specify an intrinsic
 ! type or a previously defined derived type.
 
 program main
   type :: recursive1
     !ERROR: Recursive use of the derived type requires POINTER or ALLOCATABLE

flang/test/Semantics/resolve45.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 function f1(x, y)
   integer x
   !ERROR: SAVE attribute may not be applied to dummy argument 'x'
   !ERROR: SAVE attribute may not be applied to dummy argument 'y'
   save x,y
   integer y
   !ERROR: SAVE attribute may not be applied to function result 'f1'
   save f1

flang/test/Semantics/resolve46.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C1030 - pointers to intrinsic procedures
 program main
   intrinsic :: cos ! a specific & generic intrinsic name
   intrinsic :: alog10 ! a specific intrinsic name, not generic
   intrinsic :: null ! a weird special case
   intrinsic :: bessel_j0 ! generic intrinsic, not specific
   intrinsic :: amin0
   !ERROR: 'haltandcatchfire' is not a known intrinsic procedure

flang/test/Semantics/resolve47.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m1
   !ERROR: Logical constant '.true.' may not be used as a defined operator
   interface operator(.TRUE.)
   end interface
   !ERROR: Logical constant '.false.' may not be used as a defined operator
   generic :: operator(.false.) => bar
 end
 

flang/test/Semantics/resolve48.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test correct use-association of a derived type.
 module m1
   implicit none
   type :: t
   end type
 end module
 module m2
   use m1, only: t

flang/test/Semantics/resolve49.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test section subscript
 program p1
   real :: a(10,10)
   real :: b(5,5)
   real :: c
   integer :: n
   n = 2
   b = a(1:10:n,1:n+3)

flang/test/Semantics/resolve50.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test coarray association in CHANGE TEAM statement
 
 subroutine s1
   use iso_fortran_env
   type(team_type) :: t
   complex :: x[*]
   real :: y[*]
   real :: z

flang/test/Semantics/resolve51.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test SELECT TYPE errors: C1157
 
 subroutine s1()
   type :: t
   end type
   procedure(f) :: ff
   !ERROR: Selector is not a named variable: 'associate-name =>' is required
   select type(ff())

flang/test/Semantics/resolve52.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests for C760:
 ! The passed-object dummy argument shall be a scalar, nonpointer, nonallocatable
 ! dummy data object with the same declared type as the type being defined;
 ! all of its length type parameters shall be assumed; it shall be polymorphic
 ! (7.3.2.3) if and only if the type being defined is extensible (7.5.7).
 ! It shall not have the VALUE attribute.
 !
 ! C757 If the procedure pointer component has an implicit interface or has no

flang/test/Semantics/resolve53.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! 15.4.3.4.5 Restrictions on generic declarations
 ! Specific procedures of generic interfaces must be distinguishable.
 
 module m1
   !ERROR: Generic 'g' may not have specific procedures 's2' and 's4' as their interfaces are not distinguishable
   interface g
     procedure s1
     procedure s2

flang/test/Semantics/resolve54.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests based on examples in C.10.6
 
 ! C.10.6(10)
 module m1
   interface GOOD1
     function F1A(X)
       real :: F1A, X
     end function

flang/test/Semantics/resolve55.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests for C1128:
 ! A variable-name that appears in a LOCAL or LOCAL_INIT locality-spec shall not
 ! have the ALLOCATABLE; INTENT (IN); or OPTIONAL attribute; shall not be of
 ! finalizable type; shall not be a nonpointer polymorphic dummy argument; and
 ! shall not be a coarray or an assumed-size array.
 
 subroutine s1()
 ! Cannot have ALLOCATABLE variable in a locality spec

flang/test/Semantics/resolve56.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test that associations constructs can be correctly combined. The intrinsic
 ! functions are not what is tested here, they are only use to reveal the types
 ! of local variables.
 
   implicit none
   real res
   complex zres
   integer ires

flang/test/Semantics/resolve57.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests for the last sentence of C1128:
 !A variable-name that is not permitted to appear in a variable definition
 !context shall not appear in a LOCAL or LOCAL_INIT locality-spec.
 
 subroutine s1(arg)
   real, intent(in) :: arg
 
   ! This is not OK because "arg" is "intent(in)"

flang/test/Semantics/resolve58.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1(x, y)
   !ERROR: Array pointer 'x' must have deferred shape or assumed rank
   real, pointer :: x(1:)  ! C832
   !ERROR: Allocatable array 'y' must have deferred shape or assumed rank
   real, dimension(1:,1:), allocatable :: y  ! C832
 end
 
 subroutine s2(a, b, c)

flang/test/Semantics/resolve59.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Testing 15.6.2.2 point 4 (What function-name refers to depending on the
 ! presence of RESULT).
 
 
 module m_no_result
 ! Without RESULT, it refers to the result object (no recursive
 ! calls possible)
 contains

flang/test/Semantics/resolve60.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Testing 7.6 enum
 
   ! OK
   enum, bind(C)
     enumerator :: red, green
     enumerator blue, pink
     enumerator yellow
     enumerator :: purple = 2

flang/test/Semantics/resolve61.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 program p1
   integer(8) :: a, b, c, d
   pointer(a, b)
   !ERROR: 'b' cannot be a Cray pointer as it is already a Cray pointee
   pointer(b, c)
   !ERROR: 'a' cannot be a Cray pointee as it is already a Cray pointer
   pointer(d, a)
 end

flang/test/Semantics/resolve62.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Resolve generic based on number of arguments
 subroutine s1
   interface f
     real function f1(x)
       optional :: x
     end
     real function f2(x, y)
     end

flang/test/Semantics/resolve63.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Invalid operand types when user-defined operator is available
 module m1
   type :: t
   end type
   interface operator(==)
     logical function eq_tt(x, y)
       import :: t
       type(t), intent(in) :: x, y

flang/test/Semantics/resolve64.f90

 ! RUN: %S/test_errors.sh %s %t %f18 -flogical-abbreviations -fxor-operator
+! REQUIRES: shell
 
 ! Like m4 in resolve63 but compiled with different options.
 ! Alternate operators are enabled so treat these as intrinsic.
 module m4
 contains
   subroutine s1(x, y, z)
     logical :: x
     real :: y, z

flang/test/Semantics/resolve65.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test restrictions on what subprograms can be used for defined assignment.
 
 module m1
   implicit none
   type :: t
   contains
     !ERROR: Defined assignment procedure 'binding' must be a subroutine
     generic :: assignment(=) => binding

flang/test/Semantics/resolve66.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test that user-defined assignment is used in the right places
 
 module m1
   type t1
   end type
   type t2
   end type
   interface assignment(=)

flang/test/Semantics/resolve67.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test restrictions on what subprograms can be used for defined operators.
 ! See: 15.4.3.4.2
 
 module m1
   interface operator(+)
     !ERROR: OPERATOR(+) procedure 'add1' must be a function
     subroutine add1(x, y, z)
       real, intent(out) :: x

flang/test/Semantics/resolve68.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test resolution of type-bound generics.
 
 module m1
   type :: t
   contains
     procedure, pass(x) :: add1 => add
     procedure, nopass :: add2 => add
     procedure :: add_real

flang/test/Semantics/resolve69.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1()
   ! C701 (R701) The type-param-value for a kind type parameter shall be a
   ! constant expression.
   !
   ! C702 (R701) A colon shall not be used as a type-param-value except in the 
   ! declaration of an entity that has the POINTER or ALLOCATABLE attribute.
   !
   ! C704 (R703) In a declaration-type-spec, every type-param-value that is 

flang/test/Semantics/resolve70.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C703 (R702) The derived-type-spec shall not specify an abstract type (7.5.7).
 ! This constraint refers to the derived-type-spec in a type-spec.  A type-spec
 ! can appear in an ALLOCATE statement, an ac-spec for an array constructor, and
 ! in the type specifier of a TYPE GUARD statement
 !
 ! C706 TYPE(derived-type-spec) shall not specify an abstract type (7.5.7).
 !   This is for a declaration-type-spec
 !

flang/test/Semantics/resolve71.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C708 An entity declared with the CLASS keyword shall be a dummy argument 
 ! or have the ALLOCATABLE or POINTER attribute.
 subroutine s()
   type :: parentType
   end type
 
   class(parentType), pointer :: pvar
   class(parentType), allocatable :: avar

flang/test/Semantics/resolve72.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C709 An assumed-type entity shall be a dummy data object that does not have 
 ! the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and 
 ! is not an explicit-shape array.
 subroutine s()
   !ERROR: Assumed-type entity 'starvar' must be a dummy argument
   type(*) :: starVar
 
     contains

flang/test/Semantics/resolve73.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C721 A type-param-value of * shall be used only
 ! * to declare a dummy argument,
 ! * to declare a named constant,
 ! * in the type-spec of an ALLOCATE statement wherein each allocate-object is 
 !   a dummy argument of type CHARACTER with an assumed character length,
 ! * in the type-spec or derived-type-spec of a type guard statement (11.1.11), 
 !   or
 ! * in an external function, to declare the character length parameter of the function result.

flang/test/Semantics/resolve74.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C722 A function name shall not be declared with an asterisk type-param-value 
 ! unless it is of type CHARACTER and is the name of a dummy function or the 
 ! name of the result of an external function.
 subroutine s()
 
   type derived(param)
     integer, len :: param
   end type

flang/test/Semantics/resolve75.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C726 The length specified for a character statement function or for a 
 ! statement function dummy argument of type character shall be a constant 
 ! expression.
 subroutine s()
   implicit character(len=3) (c)
   implicit character(len=*) (d)
   stmtFunc1 (x) = x * 32
   cStmtFunc2 (x) = "abc"
   !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
   cStmtFunc3 (dummy) = "abc"
   !ERROR: An assumed (*) type parameter may be used only for a (non-statement function) dummy argument, associate name, named constant, or external function result
   dStmtFunc3 (x) = "abc"
 end subroutine s

flang/test/Semantics/resolve76.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! 15.6.2.5(3)
 
 module m1
   implicit logical(a-b)
   interface
     module subroutine sub1(a, b)
       real, intent(in) :: a

flang/test/Semantics/resolve77.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests valid and invalid usage of forward references to procedures
 ! in specification expressions.
 module m
   interface ifn2
     module procedure if2
   end interface
   interface ifn3
     module procedure if3

flang/test/Semantics/resolve78.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
 ! C743 No component-attr-spec shall appear more than once in a 
 ! given component-def-stmt.
 !
 ! R737 data-component-def-stmt ->
 !        declaration-type-spec [[, component-attr-spec-list] ::]
 !        component-decl-list
 !  component-attr-spec values are:

flang/test/Semantics/resolve79.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
 ! C755 The same proc-component-attr-spec shall not appear more than once in a 
 ! given proc-component-def-stmt.
 ! C759 PASS and NOPASS shall not both appear in the same 
 ! proc-component-attr-spec-list.
 !
 ! R741 proc-component-def-stmt ->
 !        PROCEDURE ( [proc-interface] ) , proc-component-attr-spec-list

flang/test/Semantics/resolve80.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
 !C778 The same binding-attr shall not appear more than once in a given
 !binding-attr-list.
 !
 !R749 type-bound-procedure-stmt
 !  PROCEDURE [ [ ,binding-attr-list] :: ]type-bound-proc-decl-list
 !  or PROCEDURE (interface-name),binding-attr-list::binding-name-list
 !

flang/test/Semantics/resolve81.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C801 The same attr-spec shall not appear more than once in a given
 ! type-declaration-stmt.
 !
 ! R801 type-declaration-stmt ->
 !        declaration-type-spec [[, attr-spec]... ::] entity-decl-list
 !  attr-spec values are:
 !    PUBLIC, PRIVATE, ALLOCATABLE, ASYNCHRONOUS, CODIMENSION, CONTIGUOUS, 
 !    DIMENSION (array-spec), EXTERNAL, INTENT (intent-spec), INTRINSIC, 

flang/test/Semantics/resolve82.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C815 An entity shall not be explicitly given any attribute more than once in 
 ! a scoping unit.
 !
 ! R1512 procedure-declaration-stmt ->
 !         PROCEDURE ( [proc-interface] ) [[, proc-attr-spec]... ::]
 !         proc-decl-list
 !  proc-attr-spec values are:
 !    PUBLIC, PRIVATE, BIND(C), INTENT (intent-spec), OPTIONAL, POINTER, 

flang/test/Semantics/resolve83.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
 
   ! For C1543
   interface intFace
     !WARNING: Attribute 'MODULE' cannot be used more than once
     module pure module real function moduleFunc()
     end function moduleFunc
   end interface

flang/test/Semantics/resolve84.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C729 A derived type type-name shall not be DOUBLEPRECISION or the same as 
 ! the name of any intrinsic type defined in this document.
 subroutine s()
   ! This one's OK
   type derived
   end type
   !ERROR: A derived type name cannot be the name of an intrinsic type
   type integer

flang/test/Semantics/resolve85.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m
 ! C730 The same type-attr-spec shall not appear more than once in a given 
 ! derived-type-stmt.
 !
 ! R727 derived-type-stmt ->
 !        TYPE [[, type-attr-spec-list] ::] type-name [( type-param-name-list )]
 !  type-attr-spec values are:
 !    ABSTRACT, PUBLIC, PRIVATE, BIND(C), EXTENDS(parent-type-name)

flang/test/Semantics/resolve86.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C736 If EXTENDS appears and the type being defined has a coarray ultimate 
 ! component, its parent type shall have a coarray ultimate component.
 !
 subroutine s()
   type coarrayParent
     real,allocatable, codimension[:] :: parentField
   end type coarrayParent
 

flang/test/Semantics/resolve87.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C737 If EXTENDS appears and the type being defined has a potential 
 ! subobject component of type EVENT_TYPE or LOCK_TYPE from the intrinsic 
 ! module ISO_FORTRAN_ENV, its parent type shall be EVENT_TYPE or LOCK_TYPE 
 ! or have a potential subobject component of type EVENT_TYPE or LOCK_TYPE.
 module not_iso_fortran_env
   type event_type
   end type
 

flang/test/Semantics/resolve88.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C746, C747, and C748
 module m
   use ISO_FORTRAN_ENV
   use ISO_C_BINDING
 
   ! C746 If a coarray-spec appears, it shall be a deferred-coshape-spec-list and
   ! the component shall have the ALLOCATABLE attribute.
 

flang/test/Semantics/resolve89.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C750 Each bound in the explicit-shape-spec shall be a specification
 ! expression in which there are no references to specification functions or
 ! the intrinsic functions ALLOCATED, ASSOCIATED, EXTENDS_TYPE_OF, PRESENT,
 ! or SAME_TYPE_AS, every specification inquiry reference is a constant
 ! expression, and the value does not depend on the value of a variable.
 !
 ! C754 Each type-param-value within a component-def-stmt shall be a colon or 
 ! a specification expression in which there are no references to specification 

flang/test/Semantics/resolve90.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C751 A component shall not have both the ALLOCATABLE and POINTER attributes.
 ! C752 If the CONTIGUOUS attribute is specified, the component shall be an 
 !   array with the POINTER attribute.
 ! C753 The * char-length option is permitted only if the component is of type 
 !   character.
 subroutine s()
   type derivedType
     !ERROR: 'pointerallocatablefield' may not have both the POINTER and ALLOCATABLE attributes

flang/test/Semantics/resolve91.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests for duplicate definitions and initializations, mostly of procedures
 module m
   procedure(real), pointer :: p
   !ERROR: The interface for procedure 'p' has already been declared
   procedure(integer), pointer :: p
 end
 
 module m1

flang/test/Semantics/resolve92.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 module m1
   implicit none
   type t
     integer :: n
   end type
   type t2
     ! t and t2 must be resolved to types in m, not components in t2

flang/test/Semantics/resolve93.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 subroutine s1()
   character(10) str
   character(10) str1
   !ERROR: Cannot reference function 'str' as data
   print *, str(1:9), str(7)
   block
     character(10) str2
     character(10) str3

flang/test/Semantics/resolve94.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! C929   No specifier shall appear more than once in a given 
 !   image-selector-spec-list.
 ! C930 TEAM and TEAM_NUMBER shall not both appear in the same
 !   image-selector-spec-list.
 ! C931 A stat-variable in an image-selector shall not be a coindexed object.
 subroutine s1()
   use ISO_FORTRAN_ENV
   type(team_type) :: team1, team2

flang/test/Semantics/resolve95.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test SELECT TYPE and ASSOCIATE errors: C1103
 
 subroutine s1()
   class(*),allocatable :: calc[:]
   integer,save :: icoa[*]
   !ERROR: Selector must not be a coindexed object
   associate(sel=>icoa[2])
   end associate
   icoa = 2
   allocate(integer::calc[*])
   !ERROR: Selector must not be a coindexed object
   select type(sel=>calc[2])
   end select
 end subroutine

flang/test/Semantics/resolve96.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! Check distinguishability for specific procedures of defined operators and
 ! assignment. These are different from names because there a normal generic
 ! is invoked the same way as a type-bound generic.
 ! E.g. for a generic name like 'foo', the generic name is invoked as 'foo(x, y)'
 ! while the type-bound generic is invoked as 'x%foo(y)'.
 ! But for 'operator(.foo.)', it is 'x .foo. y' in either case.
 ! So to check the specifics of 'operator(.foo.)' we have to consider all

flang/test/Semantics/save01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 MODULE test
 SAVE
 CONTAINS
 PURE FUNCTION pf( )
    IMPLICIT NONE
    INTEGER :: pf
    INTEGER :: mc
    !OK: SAVE statement is not inherited by the function

flang/test/Semantics/select-rank.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 !Tests for SELECT RANK Construct(R1148)
 program select_rank
    implicit none
    integer, dimension(10:30, 10:20, -1:20) :: x
    integer, parameter :: y(*) = [1,2,3,4]
    integer, dimension(5) :: z
    integer, allocatable :: a(:)

flang/test/Semantics/select-rank02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 !Shape analysis related tests for SELECT RANK Construct(R1148)
 program select_rank
    implicit none
    integer, dimension(2,3):: arr_pass
    call check(arr_pass)
 
 contains

flang/test/Semantics/selecttype01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test for checking select type constraints,
 module m1
   use ISO_C_BINDING
   type shape
     integer :: color
     logical :: filled
     integer :: x
     integer :: y

flang/test/Semantics/selecttype02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 module m1
   use ISO_C_BINDING
   type shape
     integer :: color
     logical :: filled
     integer :: x
     integer :: y
   end type shape

flang/test/Semantics/selecttype03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Test various conditions in C1158.
 implicit none
 
 type :: t1
   integer :: i
 end type
 
 type, extends(t1) :: t2

flang/test/Semantics/separate-mp01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! case 1: ma_create_new_fun' was not declared a separate module procedure
 module m1
   integer :: i
   interface ma
     module function ma_create_fun( ) result(this)
       integer this
     end function

flang/test/Semantics/separate-mp02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 
 ! When a module subprogram has the MODULE prefix the following must match
 ! with the corresponding separate module procedure interface body:
 ! - C1549: characteristics and dummy argument names
 ! - C1550: binding label
 ! - C1551: NON_RECURSIVE prefix
 
 module m1

flang/test/Semantics/spec-expr.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Tests for the 14 items that specify a "specification expression" in section
 ! 10.1.11
 
 ! a constant or subobject of a constant,
 subroutine s1()
   type dType
     integer :: field
   end type dType

flang/test/Semantics/stop01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 program main
   implicit none
   integer :: i = -1
   integer, pointer :: p_i
   integer(kind = 1) :: invalid = 0
   integer, dimension(1:100) :: iarray
   integer, dimension(:), pointer :: p_iarray
   integer, allocatable, dimension(:) :: aiarray

flang/test/Semantics/structconst01.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Error tests for structure constructors.
 ! Errors caught by name resolution are tested elsewhere; these are the
 ! errors meant to be caught by expression semantic analysis, as well as
 ! acceptable use cases.
 ! Type parameters are used here to make the parses unambiguous.
 ! C796 (R756) The derived-type-spec shall not specify an abstract type (7.5.7).
 !   This refers to a derived-type-spec used in a structure constructor
 

flang/test/Semantics/structconst02.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Error tests for structure constructors: per-component type
 ! (in)compatibility.
 
 module module1
   interface
     real function realfunc(x)
       real, value :: x
     end function realfunc

flang/test/Semantics/structconst03.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Error tests for structure constructors: C1594 violations
 ! from assigning globally-visible data to POINTER components.
 ! test/Semantics/structconst04.f90 is this same test without type
 ! parameters.
 
 module usefrom
   real, target :: usedfrom1
 end module usefrom

flang/test/Semantics/structconst04.f90

 ! RUN: %S/test_errors.sh %s %t %f18
+! REQUIRES: shell
 ! Error tests for structure constructors: C1594 violations
 ! from assigning globally-visible data to POINTER components.
 ! This test is structconst03.f90 with the type parameters removed.
 
 module usefrom
   real, target :: usedfrom1
 end module usefrom
 

flang/test/Semantics/symbol01.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Test that intent-stmt and subprogram prefix and suffix are resolved.
 
 !DEF: /m Module
 module m
  !DEF: /m/f PRIVATE, PURE, RECURSIVE (Function) Subprogram REAL(4)
  private :: f
 contains
  !DEF: /m/s BIND(C), PUBLIC, PURE (Subroutine) Subprogram

flang/test/Semantics/symbol02.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Test host association in module subroutine and internal subroutine.
 
 !DEF: /m Module
 module m
  !DEF: /m/t PUBLIC DerivedType
  type :: t
  end type
  !REF: /m/t

flang/test/Semantics/symbol03.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Test host association in internal subroutine of main program.
 
 !DEF: /main MainProgram
 program main
  !DEF: /main/x ObjectEntity INTEGER(4)
  integer x
  !DEF: /main/s (Subroutine) Subprogram
  call s

flang/test/Semantics/symbol05.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Explicit and implicit entities in blocks
 
 !DEF: /s1 (Subroutine) Subprogram
 subroutine s1
  !DEF: /s1/x ObjectEntity INTEGER(4)
  integer x
  block
   !DEF: /s1/Block1/y ObjectEntity INTEGER(4)

flang/test/Semantics/symbol06.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 !DEF: /main MainProgram
 program main
  !DEF: /main/t1 DerivedType
  type :: t1
   !DEF: /main/t1/a1 ObjectEntity INTEGER(4)
   integer :: a1
  end type
  !REF: /main/t1

flang/test/Semantics/symbol07.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 !DEF: /main MainProgram
 program main
  implicit complex(z)
  !DEF: /main/t DerivedType
  type :: t
   !DEF: /main/t/re ObjectEntity REAL(4)
   real :: re
   !DEF: /main/t/im ObjectEntity REAL(4)

flang/test/Semantics/symbol08.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 !DEF: /main MainProgram
 program main
  !DEF: /main/x POINTER ObjectEntity REAL(4)
  pointer :: x
  !REF: /main/x
  real x
  !DEF: /main/y EXTERNAL, POINTER (Function) ProcEntity REAL(4)
  pointer :: y
  !REF: /main/y
  procedure (real) :: y
  !DEF: /main/z (Implicit) ObjectEntity REAL(4)
  !REF: /main/y
  z = y()
 end program

flang/test/Semantics/symbol09.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 !DEF: /s1 (Subroutine) Subprogram
 subroutine s1
  !DEF: /s1/a ObjectEntity REAL(4)
  !DEF: /s1/b ObjectEntity REAL(4)
  real a(10), b(10)
  !DEF: /s1/i ObjectEntity INTEGER(8)
  integer(kind=8) i
  !DEF: /s1/Forall1/i ObjectEntity INTEGER(8)

flang/test/Semantics/symbol10.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 !DEF: /m1 Module
 module m1
 contains
  !DEF: /m1/foo_complex PUBLIC (Subroutine) Subprogram
  !DEF: /m1/foo_complex/z ObjectEntity COMPLEX(4)
  subroutine foo_complex (z)
   !REF: /m1/foo_complex/z
   complex z

flang/test/Semantics/symbol11.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 !DEF: /s1 (Subroutine) Subprogram
 subroutine s1
  implicit none
  !DEF: /s1/x ObjectEntity REAL(8)
  real(kind=8) :: x = 2.0
  !DEF: /s1/a ObjectEntity INTEGER(4)
  integer a
  !DEF: /s1/t DerivedType

flang/test/Semantics/symbol12.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Verify that SAVE attribute is propagated by EQUIVALENCE
 
 !DEF: /s1 (Subroutine) Subprogram
 subroutine s1
  !DEF: /s1/a SAVE ObjectEntity REAL(4)
  !DEF: /s1/b SAVE ObjectEntity REAL(4)
  !DEF: /s1/c SAVE ObjectEntity REAL(4)
  !DEF: /s1/d SAVE ObjectEntity REAL(4)

flang/test/Semantics/symbol13.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Old-style "*length" specifiers (R723)
 
 !DEF: /f1 (Function) Subprogram CHARACTER(1_8,1)
 !DEF: /f1/x1 INTENT(IN) ObjectEntity CHARACTER(2_4,1)
 !DEF: /f1/x2 INTENT(IN) ObjectEntity CHARACTER(3_4,1)
 character*1 function f1(x1, x2)
  !DEF: /f1/n PARAMETER ObjectEntity INTEGER(4)
  integer, parameter :: n = 2

flang/test/Semantics/symbol14.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! "Bare" uses of type parameters and components
 
  !DEF: /MainProgram1/t1 DerivedType
  !DEF: /MainProgram1/t1/k TypeParam INTEGER(4)
  type :: t1(k)
   !REF: /MainProgram1/t1/k
   integer, kind :: k=666
   !DEF: /MainProgram1/t1/a ObjectEntity REAL(4)

flang/test/Semantics/symbol15.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Forward references in pointer initializers and TBP bindings.
 
 !DEF: /m Module
 module m
  implicit none
  abstract interface
   !DEF: /m/iface PUBLIC (Subroutine) Subprogram
   subroutine iface

flang/test/Semantics/symbol16.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Statement functions
 
 !DEF: /p1 MainProgram
 program p1
  !DEF: /p1/f (Function, StmtFunction) Subprogram INTEGER(4)
  !DEF: /p1/i ObjectEntity INTEGER(4)
  !DEF: /p1/j ObjectEntity INTEGER(4)
  integer f, i, j

flang/test/Semantics/symbol17.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 ! Forward references to derived types (non-error cases)
 
 !DEF: /main MainProgram
 program main
  !DEF: /main/t1 DerivedType
  type :: t1
   !DEF: /main/t2 DerivedType
   !DEF: /main/t1/t1a ALLOCATABLE ObjectEntity TYPE(t2)

flang/test/Semantics/symbol18.f90

 ! RUN: %S/test_symbols.sh %s %t %f18
+! REQUIRES: shell
 
 ! Intrinsic function in type declaration statement: type is ignored
 
 !DEF: /p1 MainProgram
 program p1
  !DEF: /p1/cos INTRINSIC (Function) ProcEntity
  integer cos
  !DEF: /p1/y (Implicit) ObjectEntity REAL(4)

flang/test/lit.site.cfg.py.in

 @LIT_SITE_CFG_IN_HEADER@
 
 import sys
 
 config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.lit_tools_dir = "@LLVM_LIT_TOOLS_DIR@"
 config.flang_obj_root = "@FLANG_BINARY_DIR@"
 config.flang_src_dir = "@FLANG_SOURCE_DIR@"
 config.flang_tools_dir = "@FLANG_TOOLS_DIR@"
 config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 config.flang_llvm_tools_dir = "@CMAKE_BINARY_DIR@/bin"
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.flang_standalone_build = @FLANG_STANDALONE_BUILD@