| // RUN: mlir-opt -split-input-file -verify-diagnostics %s |
| |
| func @unknown_clause() { |
| // expected-error@+1 {{invalid is not a valid clause}} |
| omp.parallel invalid { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @if_once(%n : i1) { |
| // expected-error@+1 {{at most one if clause can appear on the omp.parallel operation}} |
| omp.parallel if(%n : i1) if(%n : i1) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @num_threads_once(%n : si32) { |
| // expected-error@+1 {{at most one num_threads clause can appear on the omp.parallel operation}} |
| omp.parallel num_threads(%n : si32) num_threads(%n : si32) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @private_once(%n : memref<i32>) { |
| // expected-error@+1 {{at most one private clause can appear on the omp.parallel operation}} |
| omp.parallel private(%n : memref<i32>) private(%n : memref<i32>) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @firstprivate_once(%n : memref<i32>) { |
| // expected-error@+1 {{at most one firstprivate clause can appear on the omp.parallel operation}} |
| omp.parallel firstprivate(%n : memref<i32>) firstprivate(%n : memref<i32>) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @shared_once(%n : memref<i32>) { |
| // expected-error@+1 {{at most one shared clause can appear on the omp.parallel operation}} |
| omp.parallel shared(%n : memref<i32>) shared(%n : memref<i32>) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @copyin_once(%n : memref<i32>) { |
| // expected-error@+1 {{at most one copyin clause can appear on the omp.parallel operation}} |
| omp.parallel copyin(%n : memref<i32>) copyin(%n : memref<i32>) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @lastprivate_not_allowed(%n : memref<i32>) { |
| // expected-error@+1 {{lastprivate is not a valid clause for the omp.parallel operation}} |
| omp.parallel lastprivate(%n : memref<i32>) {} |
| return |
| } |
| |
| // ----- |
| |
| func @nowait_not_allowed(%n : memref<i32>) { |
| // expected-error@+1 {{nowait is not a valid clause for the omp.parallel operation}} |
| omp.parallel nowait {} |
| return |
| } |
| |
| // ----- |
| |
| func @linear_not_allowed(%data_var : memref<i32>, %linear_var : i32) { |
| // expected-error@+1 {{linear is not a valid clause for the omp.parallel operation}} |
| omp.parallel linear(%data_var = %linear_var : memref<i32>) {} |
| return |
| } |
| |
| // ----- |
| |
| func @schedule_not_allowed() { |
| // expected-error@+1 {{schedule is not a valid clause for the omp.parallel operation}} |
| omp.parallel schedule(static) {} |
| return |
| } |
| |
| // ----- |
| |
| func @collapse_not_allowed() { |
| // expected-error@+1 {{collapse is not a valid clause for the omp.parallel operation}} |
| omp.parallel collapse(3) {} |
| return |
| } |
| |
| // ----- |
| |
| func @order_not_allowed() { |
| // expected-error@+1 {{order is not a valid clause for the omp.parallel operation}} |
| omp.parallel order(concurrent) {} |
| return |
| } |
| |
| // ----- |
| |
| func @ordered_not_allowed() { |
| // expected-error@+1 {{ordered is not a valid clause for the omp.parallel operation}} |
| omp.parallel ordered(2) {} |
| } |
| |
| // ----- |
| |
| func @default_once() { |
| // expected-error@+1 {{at most one default clause can appear on the omp.parallel operation}} |
| omp.parallel default(private) default(firstprivate) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @proc_bind_once() { |
| // expected-error@+1 {{at most one proc_bind clause can appear on the omp.parallel operation}} |
| omp.parallel proc_bind(close) proc_bind(spread) { |
| } |
| |
| return |
| } |
| |
| // ----- |
| |
| func @inclusive_not_a_clause(%lb : index, %ub : index, %step : index) { |
| // expected-error @below {{inclusive is not a valid clause}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) nowait inclusive { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| func @order_value(%lb : index, %ub : index, %step : index) { |
| // expected-error @below {{attribute 'order_val' failed to satisfy constraint: OrderKind Clause}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) order(default) { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| func @shared_not_allowed(%lb : index, %ub : index, %step : index, %var : memref<i32>) { |
| // expected-error @below {{shared is not a valid clause for the omp.wsloop operation}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) shared(%var) { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| func @copyin(%lb : index, %ub : index, %step : index, %var : memref<i32>) { |
| // expected-error @below {{copyin is not a valid clause for the omp.wsloop operation}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) copyin(%var) { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| func @if_not_allowed(%lb : index, %ub : index, %step : index, %bool_var : i1) { |
| // expected-error @below {{if is not a valid clause for the omp.wsloop operation}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) if(%bool_var: i1) { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| func @num_threads_not_allowed(%lb : index, %ub : index, %step : index, %int_var : i32) { |
| // expected-error @below {{num_threads is not a valid clause for the omp.wsloop operation}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) num_threads(%int_var: i32) { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| func @default_not_allowed(%lb : index, %ub : index, %step : index) { |
| // expected-error @below {{default is not a valid clause for the omp.wsloop operation}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) default(private) { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| func @proc_bind_not_allowed(%lb : index, %ub : index, %step : index) { |
| // expected-error @below {{proc_bind is not a valid clause for the omp.wsloop operation}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) proc_bind(close) { |
| omp.yield |
| } |
| } |
| |
| // ----- |
| |
| // expected-error @below {{op expects initializer region with one argument of the reduction type}} |
| omp.reduction.declare @add_f32 : f64 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| omp.yield (%1 : f32) |
| } |
| |
| // ----- |
| |
| // expected-error @below {{expects initializer region to yield a value of the reduction type}} |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f64 |
| omp.yield (%0 : f64) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| omp.yield (%1 : f32) |
| } |
| |
| // ----- |
| |
| // expected-error @below {{expects reduction region with two arguments of the reduction type}} |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f64, %arg1: f64): |
| %1 = arith.addf %arg0, %arg1 : f64 |
| omp.yield (%1 : f64) |
| } |
| |
| // ----- |
| |
| // expected-error @below {{expects reduction region to yield a value of the reduction type}} |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| %2 = arith.extf %1 : f32 to f64 |
| omp.yield (%2 : f64) |
| } |
| |
| // ----- |
| |
| // expected-error @below {{expects atomic reduction region with two arguments of the same type}} |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| omp.yield (%1 : f32) |
| } |
| atomic { |
| ^bb2(%arg0: memref<f32>, %arg1: memref<f64>): |
| omp.yield |
| } |
| |
| // ----- |
| |
| // expected-error @below {{expects atomic reduction region arguments to be accumulators containing the reduction type}} |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| omp.yield (%1 : f32) |
| } |
| atomic { |
| ^bb2(%arg0: memref<f64>, %arg1: memref<f64>): |
| omp.yield |
| } |
| |
| // ----- |
| |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| omp.yield (%1 : f32) |
| } |
| |
| func @foo(%lb : index, %ub : index, %step : index) { |
| %c1 = arith.constant 1 : i32 |
| %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<f32> |
| %1 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<f32> |
| |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) |
| reduction(@add_f32 -> %0 : !llvm.ptr<f32>) { |
| %2 = arith.constant 2.0 : f32 |
| // expected-error @below {{accumulator is not used by the parent}} |
| omp.reduction %2, %1 : !llvm.ptr<f32> |
| omp.yield |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @foo(%lb : index, %ub : index, %step : index) { |
| %c1 = arith.constant 1 : i32 |
| %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<f32> |
| %1 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<f32> |
| |
| // expected-error @below {{expected symbol reference @foo to point to a reduction declaration}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) |
| reduction(@foo -> %0 : !llvm.ptr<f32>) { |
| %2 = arith.constant 2.0 : f32 |
| omp.reduction %2, %1 : !llvm.ptr<f32> |
| omp.yield |
| } |
| return |
| } |
| |
| // ----- |
| |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| omp.yield (%1 : f32) |
| } |
| |
| func @foo(%lb : index, %ub : index, %step : index) { |
| %c1 = arith.constant 1 : i32 |
| %0 = llvm.alloca %c1 x i32 : (i32) -> !llvm.ptr<f32> |
| |
| // expected-error @below {{accumulator variable used more than once}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) |
| reduction(@add_f32 -> %0 : !llvm.ptr<f32>, @add_f32 -> %0 : !llvm.ptr<f32>) { |
| %2 = arith.constant 2.0 : f32 |
| omp.reduction %2, %0 : !llvm.ptr<f32> |
| omp.yield |
| } |
| return |
| } |
| |
| // ----- |
| |
| omp.reduction.declare @add_f32 : f32 |
| init { |
| ^bb0(%arg: f32): |
| %0 = arith.constant 0.0 : f32 |
| omp.yield (%0 : f32) |
| } |
| combiner { |
| ^bb1(%arg0: f32, %arg1: f32): |
| %1 = arith.addf %arg0, %arg1 : f32 |
| omp.yield (%1 : f32) |
| } |
| atomic { |
| ^bb2(%arg2: !llvm.ptr<f32>, %arg3: !llvm.ptr<f32>): |
| %2 = llvm.load %arg3 : !llvm.ptr<f32> |
| llvm.atomicrmw fadd %arg2, %2 monotonic : f32 |
| omp.yield |
| } |
| |
| func @foo(%lb : index, %ub : index, %step : index, %mem : memref<1xf32>) { |
| %c1 = arith.constant 1 : i32 |
| |
| // expected-error @below {{expected accumulator ('memref<1xf32>') to be the same type as reduction declaration ('!llvm.ptr<f32>')}} |
| omp.wsloop (%iv) : index = (%lb) to (%ub) step (%step) |
| reduction(@add_f32 -> %mem : memref<1xf32>) { |
| %2 = arith.constant 2.0 : f32 |
| omp.reduction %2, %mem : memref<1xf32> |
| omp.yield |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_critical2() -> () { |
| // expected-error @below {{expected symbol reference @excl to point to a critical declaration}} |
| omp.critical(@excl) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| // expected-error @below {{the hints omp_sync_hint_uncontended and omp_sync_hint_contended cannot be combined}} |
| omp.critical.declare @mutex hint(uncontended, contended) |
| |
| // ----- |
| |
| // expected-error @below {{the hints omp_sync_hint_nonspeculative and omp_sync_hint_speculative cannot be combined}} |
| omp.critical.declare @mutex hint(nonspeculative, speculative) |
| |
| // ----- |
| |
| // expected-error @below {{invalid_hint is not a valid hint}} |
| omp.critical.declare @mutex hint(invalid_hint) |
| |
| // ----- |
| |
| func @omp_ordered1(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () { |
| omp.wsloop (%0) : i32 = (%arg1) to (%arg2) step (%arg3) ordered(1) { |
| // expected-error @below {{ordered region must be closely nested inside a worksharing-loop region with an ordered clause without parameter present}} |
| omp.ordered_region { |
| omp.terminator |
| } |
| omp.yield |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_ordered2(%arg1 : i32, %arg2 : i32, %arg3 : i32) -> () { |
| omp.wsloop (%0) : i32 = (%arg1) to (%arg2) step (%arg3) { |
| // expected-error @below {{ordered region must be closely nested inside a worksharing-loop region with an ordered clause without parameter present}} |
| omp.ordered_region { |
| omp.terminator |
| } |
| omp.yield |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_ordered3(%vec0 : i64) -> () { |
| // expected-error @below {{ordered depend directive must be closely nested inside a worksharing-loop with ordered clause with parameter present}} |
| omp.ordered depend_type("dependsink") depend_vec(%vec0 : i64) {num_loops_val = 1 : i64} |
| return |
| } |
| |
| // ----- |
| |
| func @omp_ordered4(%arg1 : i32, %arg2 : i32, %arg3 : i32, %vec0 : i64) -> () { |
| omp.wsloop (%0) : i32 = (%arg1) to (%arg2) step (%arg3) ordered(0) { |
| // expected-error @below {{ordered depend directive must be closely nested inside a worksharing-loop with ordered clause with parameter present}} |
| omp.ordered depend_type("dependsink") depend_vec(%vec0 : i64) {num_loops_val = 1 : i64} |
| |
| omp.yield |
| } |
| return |
| } |
| // ----- |
| |
| func @omp_ordered5(%arg1 : i32, %arg2 : i32, %arg3 : i32, %vec0 : i64, %vec1 : i64) -> () { |
| omp.wsloop (%0) : i32 = (%arg1) to (%arg2) step (%arg3) ordered(1) { |
| // expected-error @below {{number of variables in depend clause does not match number of iteration variables in the doacross loop}} |
| omp.ordered depend_type("dependsource") depend_vec(%vec0, %vec1 : i64, i64) {num_loops_val = 2 : i64} |
| |
| omp.yield |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_read1(%addr : memref<i32>) { |
| // expected-error @below {{the hints omp_sync_hint_nonspeculative and omp_sync_hint_speculative cannot be combined.}} |
| %1 = omp.atomic.read %addr hint(speculative, nonspeculative) : memref<i32> -> i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_read2(%addr : memref<i32>) { |
| // expected-error @below {{attribute 'memory_order' failed to satisfy constraint: MemoryOrderKind Clause}} |
| %1 = omp.atomic.read %addr memory_order(xyz) : memref<i32> -> i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_read3(%addr : memref<i32>) { |
| // expected-error @below {{memory-order must not be acq_rel or release for atomic reads}} |
| %1 = omp.atomic.read %addr memory_order(acq_rel) : memref<i32> -> i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_read4(%addr : memref<i32>) { |
| // expected-error @below {{memory-order must not be acq_rel or release for atomic reads}} |
| %1 = omp.atomic.read %addr memory_order(release) : memref<i32> -> i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_read5(%addr : memref<i32>) { |
| // expected-error @below {{at most one memory_order clause can appear on the omp.atomic.read operation}} |
| %1 = omp.atomic.read %addr memory_order(acquire) memory_order(relaxed) : memref<i32> -> i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_read6(%addr : memref<i32>) { |
| // expected-error @below {{at most one hint clause can appear on the omp.atomic.read operation}} |
| %1 = omp.atomic.read %addr hint(speculative) hint(contended) : memref<i32> -> i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_write1(%addr : memref<i32>, %val : i32) { |
| // expected-error @below {{the hints omp_sync_hint_uncontended and omp_sync_hint_contended cannot be combined}} |
| omp.atomic.write %addr, %val hint(contended, uncontended) : memref<i32>, i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_write2(%addr : memref<i32>, %val : i32) { |
| // expected-error @below {{memory-order must not be acq_rel or acquire for atomic writes}} |
| omp.atomic.write %addr, %val memory_order(acq_rel) : memref<i32>, i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_write3(%addr : memref<i32>, %val : i32) { |
| // expected-error @below {{memory-order must not be acq_rel or acquire for atomic writes}} |
| omp.atomic.write %addr, %val memory_order(acquire) : memref<i32>, i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_write4(%addr : memref<i32>, %val : i32) { |
| // expected-error @below {{at most one memory_order clause can appear on the omp.atomic.write operation}} |
| omp.atomic.write %addr, %val memory_order(release) memory_order(seq_cst) : memref<i32>, i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_write5(%addr : memref<i32>, %val : i32) { |
| // expected-error @below {{at most one hint clause can appear on the omp.atomic.write operation}} |
| omp.atomic.write %addr, %val hint(contended) hint(speculative) : memref<i32>, i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_atomic_write6(%addr : memref<i32>, %val : i32) { |
| // expected-error @below {{attribute 'memory_order' failed to satisfy constraint: MemoryOrderKind Clause}} |
| omp.atomic.write %addr, %val memory_order(xyz) : memref<i32>, i32 |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%data_var1 : memref<i32>, %data_var2 : memref<i32>, %data_var3 : memref<i32>) -> () { |
| // expected-error @below {{operand used in both private and firstprivate clauses}} |
| omp.sections private(%data_var1 : memref<i32>) firstprivate(%data_var1 : memref<i32>) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%data_var1 : memref<i32>, %data_var2 : memref<i32>, %data_var3 : memref<i32>) -> () { |
| // expected-error @below {{operand used in both private and lastprivate clauses}} |
| omp.sections private(%data_var1 : memref<i32>) lastprivate(%data_var1 : memref<i32>) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%data_var1 : memref<i32>, %data_var2 : memref<i32>, %data_var3 : memref<i32>) -> () { |
| // expected-error @below {{operand used in both private and lastprivate clauses}} |
| omp.sections private(%data_var1 : memref<i32>, %data_var2 : memref<i32>) lastprivate(%data_var3 : memref<i32>, %data_var2 : memref<i32>) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%data_var : memref<i32>) -> () { |
| // expected-error @below {{expected equal sizes for allocate and allocator variables}} |
| "omp.sections" (%data_var) ({ |
| omp.terminator |
| }) {operand_segment_sizes = dense<[0,0,0,0,1,0]> : vector<6xi32>} : (memref<i32>) -> () |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%data_var : memref<i32>) -> () { |
| // expected-error @below {{expected as many reduction symbol references as reduction variables}} |
| "omp.sections" (%data_var) ({ |
| omp.terminator |
| }) {operand_segment_sizes = dense<[0,0,0,1,0,0]> : vector<6xi32>} : (memref<i32>) -> () |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%data_var : memref<i32>) -> () { |
| // expected-error @below {{expected omp.section op or terminator op inside region}} |
| omp.sections { |
| "test.payload" () : () -> () |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%cond : i1) { |
| // expected-error @below {{if is not a valid clause for the omp.sections operation}} |
| omp.sections if(%cond) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{num_threads is not a valid clause for the omp.sections operation}} |
| omp.sections num_threads(10) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%datavar : memref<i32>) { |
| // expected-error @below {{shared is not a valid clause for the omp.sections operation}} |
| omp.sections shared(%datavar : memref<i32>) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%datavar : memref<i32>) { |
| // expected-error @below {{copyin is not a valid clause for the omp.sections operation}} |
| omp.sections copyin(%datavar : memref<i32>) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{default is not a valid clause for the omp.sections operation}} |
| omp.sections default(private) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{proc_bind is not a valid clause for the omp.sections operation}} |
| omp.sections proc_bind(close) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections(%data_var : memref<i32>, %linear_var : i32) { |
| // expected-error @below {{linear is not a valid clause for the omp.sections operation}} |
| omp.sections linear(%data_var = %linear_var : memref<i32>) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{schedule is not a valid clause for the omp.sections operation}} |
| omp.sections schedule(static, none) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{collapse is not a valid clause for the omp.sections operation}} |
| omp.sections collapse(3) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{ordered is not a valid clause for the omp.sections operation}} |
| omp.sections ordered(2) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{order is not a valid clause for the omp.sections operation}} |
| omp.sections order(concurrent) { |
| omp.terminator |
| } |
| return |
| } |
| |
| // ----- |
| |
| func @omp_sections() { |
| // expected-error @below {{failed to verify constraint: region with 1 blocks}} |
| omp.sections { |
| omp.section { |
| omp.terminator |
| } |
| omp.terminator |
| ^bb2: |
| omp.terminator |
| } |
| return |
| } |