maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[mlir][ods] Rename Confined and AllAttrConstraintsOf 

Confined -> ConfinedAttr
AllAttrConstraintsOf -> AllOfAttr

To be in line with ConfinedType and AllOfType.

Reviewed By: rriddle

Differential Revision: https://reviews.llvm.org/D131822
This commit is contained in:
Jeff Niu 2022-08-12 21:22:26 -04:00
parent 5c4674d67b
commit e35ca70eb3
16 changed files with 92 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
mlir/docs/OpDefinitions.md
View File

@ -117,8 +117,8 @@ window in `value`.
let arguments = (ins
TF_FpTensor:$value,
Confined<I64ArrayAttr, [ArrayMinCount<4>]>:$ksize,
Confined<I64ArrayAttr, [ArrayMinCount<4>]>:$strides,
ConfinedAttr<I64ArrayAttr, [ArrayMinCount<4>]>:$ksize,
ConfinedAttr<I64ArrayAttr, [ArrayMinCount<4>]>:$strides,
TF_AnyStrAttrOf<["SAME", "VALID"]>:$padding,
DefaultValuedAttr<TF_ConvertDataFormatAttr, "NHWC">:$data_format
);
@ -275,11 +275,11 @@ like `"0.5f"`, and an integer array default value should be specified as like
#### Confining attributes
`Confined` is provided as a general mechanism to help modelling further
`ConfinedAttr` is provided as a general mechanism to help modelling further
constraints on attributes beyond the ones brought by value types. You can use
`Confined` to compose complex constraints out of more primitive ones. For
`ConfinedAttr` to compose complex constraints out of more primitive ones. For
example, a 32-bit integer attribute whose minimum value must be 10 can be
expressed as `Confined<I32Attr, [IntMinValue<10>]>`.
expressed as `ConfinedAttr<I32Attr, [IntMinValue<10>]>`.
Right now, the following primitive constraints are supported:
@ -1287,7 +1287,7 @@ optionality, default values, etc.:
* `DefaultValuedAttr`: specifies the
[default value](#attributes-with-default-values) for an attribute.
* `OptionalAttr`: specifies an attribute as [optional](#optional-attributes).
* `Confined`: adapts an attribute with
* `ConfinedAttr`: adapts an attribute with
[further constraints](#confining-attributes).
### Enum attributes

2
mlir/include/mlir/Dialect/Affine/IR/AffineOps.td
View File

@ -779,7 +779,7 @@ def AffinePrefetchOp : Affine_Op<"prefetch",
let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
BoolAttr:$isWrite,
Confined<I32Attr, [IntMinValue<0>,
ConfinedAttr<I32Attr, [IntMinValue<0>,
IntMaxValue<3>]>:$localityHint,
BoolAttr:$isDataCache);

4
mlir/include/mlir/Dialect/Async/IR/AsyncOps.td
View File

@ -505,7 +505,7 @@ def Async_RuntimeAddRefOp : Async_Op<"runtime.add_ref"> {
}];
let arguments = (ins Async_AnyAsyncType:$operand,
Confined<I64Attr, [IntPositive]>:$count);
ConfinedAttr<I64Attr, [IntPositive]>:$count);
let assemblyFormat = [{
$operand attr-dict `:` type($operand)
@ -520,7 +520,7 @@ def Async_RuntimeDropRefOp : Async_Op<"runtime.drop_ref"> {
}];
let arguments = (ins Async_AnyAsyncType:$operand,
Confined<I64Attr, [IntPositive]>:$count);
ConfinedAttr<I64Attr, [IntPositive]>:$count);
let assemblyFormat = [{
$operand attr-dict `:` type($operand)

2
mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td
View File

@ -1201,7 +1201,7 @@ def LLVM_GlobalOp : LLVM_Op<"mlir.global",
UnitAttr:$thread_local_,
OptionalAttr<AnyAttr>:$value,
OptionalAttr<I64Attr>:$alignment,
DefaultValuedAttr<Confined<I32Attr, [IntNonNegative]>, "0">:$addr_space,
DefaultValuedAttr<ConfinedAttr<I32Attr, [IntNonNegative]>, "0">:$addr_space,
OptionalAttr<UnnamedAddr>:$unnamed_addr,
OptionalAttr<StrAttr>:$section
);

2
mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td
View File

@ -148,7 +148,7 @@ def Linalg_YieldOp : Linalg_Op<"yield", [NoSideEffect, ReturnLike, Terminator]>,
}
def Linalg_IndexOp : Linalg_Op<"index", [NoSideEffect]>,
Arguments<(ins Confined<I64Attr, [IntMinValue<0>]>:$dim)>,
Arguments<(ins ConfinedAttr<I64Attr, [IntMinValue<0>]>:$dim)>,
Results<(outs Index:$result)> {
let summary = "linalg index operation";
let description = [{

6
mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td
View File

@ -66,7 +66,7 @@ class AllocLikeOp<string mnemonic,
// The symbolic operands (the ones in square brackets)
// bind to the symbols of the memref's layout map.
Variadic<Index>:$symbolOperands,
Confined<OptionalAttr<I64Attr>,
ConfinedAttr<OptionalAttr<I64Attr>,
[IntMinValue<0>]>:$alignment);
let results = (outs Res<AnyMemRef, "", [MemAlloc<resource>]>:$memref);
@ -123,7 +123,7 @@ def AssumeAlignmentOp : MemRef_Op<"assume_alignment"> {
optimization only, and the optimization is best-effort.
}];
let arguments = (ins AnyMemRef:$memref,
Confined<I32Attr, [IntPositive]>:$alignment);
ConfinedAttr<I32Attr, [IntPositive]>:$alignment);
let results = (outs);
let assemblyFormat = "$memref `,` $alignment attr-dict `:` type($memref)";
@ -965,7 +965,7 @@ def MemRef_PrefetchOp : MemRef_Op<"prefetch"> {
let arguments = (ins AnyMemRef:$memref, Variadic<Index>:$indices,
BoolAttr:$isWrite,
Confined<I32Attr, [IntMinValue<0>,
ConfinedAttr<I32Attr, [IntMinValue<0>,
IntMaxValue<3>]>:$localityHint,
BoolAttr:$isDataCache);

6
mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td
View File

@ -345,7 +345,7 @@ def WsLoopOp : OpenMP_Op<"wsloop", [AttrSizedOperandSegments,
OptionalAttr<ScheduleModifierAttr>:$schedule_modifier,
UnitAttr:$simd_modifier,
UnitAttr:$nowait,
Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$ordered_val,
ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$ordered_val,
OptionalAttr<OrderKindAttr>:$order_val,
UnitAttr:$inclusive);
@ -432,7 +432,7 @@ def SimdLoopOp : OpenMP_Op<"simdloop", [AttrSizedOperandSegments,
Variadic<IntLikeType>:$upperBound,
Variadic<IntLikeType>:$step,
Optional<I1>:$if_expr,
Confined<OptionalAttr<I64Attr>, [IntPositive]>:$simdlen,
ConfinedAttr<OptionalAttr<I64Attr>, [IntPositive]>:$simdlen,
UnitAttr:$inclusive
);
@ -967,7 +967,7 @@ def OrderedOp : OpenMP_Op<"ordered"> {
}];
let arguments = (ins OptionalAttr<ClauseDependAttr>:$depend_type_val,
Confined<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
ConfinedAttr<OptionalAttr<I64Attr>, [IntMinValue<0>]>:$num_loops_val,
Variadic<AnyType>:$depend_vec_vars);
let assemblyFormat = [{

2
mlir/include/mlir/Dialect/PDL/IR/PDLOps.td
View File

@ -411,7 +411,7 @@ def PDL_PatternOp : PDL_Op<"pattern", [
```
}];
let arguments = (ins Confined<I16Attr, [IntNonNegative]>:$benefit,
let arguments = (ins ConfinedAttr<I16Attr, [IntNonNegative]>:$benefit,
OptionalAttr<SymbolNameAttr>:$sym_name);
let regions = (region SizedRegion<1>:$body);
let assemblyFormat = [{

16
mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td
View File

@ -236,7 +236,7 @@ def PDLInterp_CheckOperandCountOp
}];
let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$count,
ConfinedAttr<I32Attr, [IntNonNegative]>:$count,
UnitAttr:$compareAtLeast);
let assemblyFormat = [{
`of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
@ -293,7 +293,7 @@ def PDLInterp_CheckResultCountOp
}];
let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$count,
ConfinedAttr<I32Attr, [IntNonNegative]>:$count,
UnitAttr:$compareAtLeast);
let assemblyFormat = [{
`of` $inputOp `is` (`at_least` $compareAtLeast^)? $count attr-dict
@ -552,7 +552,7 @@ def PDLInterp_ExtractOp
}];
let arguments = (ins PDL_RangeOf<PDL_AnyType>:$range,
Confined<I32Attr, [IntNonNegative]>:$index);
ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
let results = (outs PDL_AnyType:$result);
let assemblyFormat = "$index `of` $range `:` type($result) attr-dict";
@ -774,7 +774,7 @@ def PDLInterp_GetOperandOp : PDLInterp_Op<"get_operand", [NoSideEffect]> {
}];
let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$index);
ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
let results = (outs PDL_Value:$value);
let assemblyFormat = "$index `of` $inputOp attr-dict";
}
@ -809,7 +809,7 @@ def PDLInterp_GetOperandsOp : PDLInterp_Op<"get_operands", [NoSideEffect]> {
let arguments = (ins
PDL_Operation:$inputOp,
OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
OptionalAttr<ConfinedAttr<I32Attr, [IntNonNegative]>>:$index
);
let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
@ -841,7 +841,7 @@ def PDLInterp_GetResultOp : PDLInterp_Op<"get_result", [NoSideEffect]> {
}];
let arguments = (ins PDL_Operation:$inputOp,
Confined<I32Attr, [IntNonNegative]>:$index);
ConfinedAttr<I32Attr, [IntNonNegative]>:$index);
let results = (outs PDL_Value:$value);
let assemblyFormat = "$index `of` $inputOp attr-dict";
}
@ -876,7 +876,7 @@ def PDLInterp_GetResultsOp : PDLInterp_Op<"get_results", [NoSideEffect]> {
let arguments = (ins
PDL_Operation:$inputOp,
OptionalAttr<Confined<I32Attr, [IntNonNegative]>>:$index
OptionalAttr<ConfinedAttr<I32Attr, [IntNonNegative]>>:$index
);
let results = (outs PDL_InstOrRangeOf<PDL_Value>:$value);
let assemblyFormat = "($index^)? `of` $inputOp `:` type($value) attr-dict";
@ -1019,7 +1019,7 @@ def PDLInterp_RecordMatchOp
SymbolRefAttr:$rewriter,
OptionalAttr<StrAttr>:$rootKind,
OptionalAttr<StrArrayAttr>:$generatedOps,
Confined<I16Attr, [IntNonNegative]>:$benefit);
ConfinedAttr<I16Attr, [IntNonNegative]>:$benefit);
let successors = (successor AnySuccessor:$dest);
let assemblyFormat = [{
$rewriter (`(` $inputs^ `:` type($inputs) `)`)? `:`

4
mlir/include/mlir/Dialect/SCF/TransformOps/SCFTransformOps.td
View File

@ -31,7 +31,7 @@ def GetParentForOp : Op<Transform_Dialect, "loop.get_parent_for",
let arguments =
(ins PDL_Operation:$target,
DefaultValuedAttr<Confined<I64Attr, [IntPositive]>,
DefaultValuedAttr<ConfinedAttr<I64Attr, [IntPositive]>,
"1">:$num_loops);
let results = (outs PDL_Operation:$parent);
@ -166,7 +166,7 @@ def LoopUnrollOp : Op<Transform_Dialect, "loop.unroll",
}];
let arguments = (ins PDL_Operation:$target,
Confined<I64Attr, [IntPositive]>:$factor);
ConfinedAttr<I64Attr, [IntPositive]>:$factor);
let assemblyFormat = "$target attr-dict";

26
mlir/include/mlir/Dialect/Tosa/IR/TosaTypesBase.td
View File

@ -167,21 +167,21 @@ class ArrayMaxCt<int n> : AttrConstraint<
CPred<"$_self.cast<::mlir::ArrayAttr>().size() <= " # n>,
"with at least " # n # " elements">;
def Tosa_Fp32ArrayAttr2 : Confined<F32ArrayAttr, [ArrayCount<2>]>;
def Tosa_Fp32ArrayAttr3 : Confined<F32ArrayAttr, [ArrayCount<3>]>;
def Tosa_Fp32ArrayAttr4 : Confined<F32ArrayAttr, [ArrayCount<4>]>;
def Tosa_Fp32ArrayAttr5 : Confined<F32ArrayAttr, [ArrayCount<5>]>;
def Tosa_Fp32ArrayAttr6 : Confined<F32ArrayAttr, [ArrayCount<6>]>;
def Tosa_Fp32ArrayAttr2 : ConfinedAttr<F32ArrayAttr, [ArrayCount<2>]>;
def Tosa_Fp32ArrayAttr3 : ConfinedAttr<F32ArrayAttr, [ArrayCount<3>]>;
def Tosa_Fp32ArrayAttr4 : ConfinedAttr<F32ArrayAttr, [ArrayCount<4>]>;
def Tosa_Fp32ArrayAttr5 : ConfinedAttr<F32ArrayAttr, [ArrayCount<5>]>;
def Tosa_Fp32ArrayAttr6 : ConfinedAttr<F32ArrayAttr, [ArrayCount<6>]>;
def Tosa_IntArrayAttr2 : Confined<I64ArrayAttr, [ArrayCount<2>]>;
def Tosa_IntArrayAttr3 : Confined<I64ArrayAttr, [ArrayCount<3>]>;
def Tosa_IntArrayAttr4 : Confined<I64ArrayAttr, [ArrayCount<4>]>;
def Tosa_IntArrayAttr5 : Confined<I64ArrayAttr, [ArrayCount<5>]>;
def Tosa_IntArrayAttr6 : Confined<I64ArrayAttr, [ArrayCount<6>]>;
def Tosa_IntArrayAttr2 : ConfinedAttr<I64ArrayAttr, [ArrayCount<2>]>;
def Tosa_IntArrayAttr3 : ConfinedAttr<I64ArrayAttr, [ArrayCount<3>]>;
def Tosa_IntArrayAttr4 : ConfinedAttr<I64ArrayAttr, [ArrayCount<4>]>;
def Tosa_IntArrayAttr5 : ConfinedAttr<I64ArrayAttr, [ArrayCount<5>]>;
def Tosa_IntArrayAttr6 : ConfinedAttr<I64ArrayAttr, [ArrayCount<6>]>;
def Tosa_IntArrayAttrUpto2 : Confined<I64ArrayAttr, [ArrayMaxCt<2>]>;
def Tosa_IntArrayAttrUpto4 : Confined<I64ArrayAttr, [ArrayMaxCt<4>]>;
def Tosa_IntArrayAttrUpto5 : Confined<I64ArrayAttr, [ArrayMaxCt<5>]>;
def Tosa_IntArrayAttrUpto2 : ConfinedAttr<I64ArrayAttr, [ArrayMaxCt<2>]>;
def Tosa_IntArrayAttrUpto4 : ConfinedAttr<I64ArrayAttr, [ArrayMaxCt<4>]>;
def Tosa_IntArrayAttrUpto5 : ConfinedAttr<I64ArrayAttr, [ArrayMaxCt<5>]>;
//===----------------------------------------------------------------------===//
// Iterable attributes.

6
mlir/include/mlir/IR/OpBase.td
View File

@ -693,7 +693,7 @@ class UnrankedTensorOf<list<Type> allowedTypes>
// list, and which additionally satisfies an optional list of predicates.
//
// TODO: use `Constraint` instead of `Pred`, so we can generate a better
// default summary (a la `Confined`).
// default summary (a la `ConfinedAttr`).
class TensorOf<
list<Type> allowedTypes,
list<Pred> preds = [],
@ -1585,7 +1585,7 @@ class ConstantStrAttr<Attr attribute, string val>
// A general mechanism to further confine the given `attr` with all the
// `constraints`. This allows to compose complex constraints out of a series
// of more primitive ones.
class Confined<Attr attr, list<AttrConstraint> constraints> : Attr<
class ConfinedAttr<Attr attr, list<AttrConstraint> constraints> : Attr<
And<!listconcat([attr.predicate],
!foreach(pred, constraints, pred.predicate))>,
!foldl(/*init*/attr.summary, /*list*/constraints,
@ -1603,7 +1603,7 @@ class Confined<Attr attr, list<AttrConstraint> constraints> : Attr<
// An AttrConstraint that holds if all attr constraints specified in
// 'constraints' hold.
class AllAttrConstraintsOf<list<AttrConstraint> constraints> : AttrConstraint<
class AllAttrOf<list<AttrConstraint> constraints> : AttrConstraint<
And<!listconcat([!head(constraints).predicate],
!foreach(pred, !tail(constraints), pred.predicate))>,
!interleave(!foreach(con, constraints, con.summary), " and ")> {

2
mlir/lib/Dialect/Vector/IR/VectorOps.cpp
View File

@ -2100,7 +2100,7 @@ void InsertStridedSliceOp::build(OpBuilder &builder, OperationState &result,
result.addAttribute(getStridesAttrStrName(), stridesAttr);
}
// TODO: Should be moved to Tablegen Confined attributes.
// TODO: Should be moved to Tablegen ConfinedAttr attributes.
template <typename OpType>
static LogicalResult isIntegerArrayAttrSmallerThanShape(OpType op,
ArrayAttr arrayAttr,

14
mlir/test/lib/Dialect/Test/TestOps.td
View File

@ -170,15 +170,15 @@ def AnyAttrOfOp : TEST_Op<"any_attr_of_i32_str"> {
def NonNegIntAttrOp : TEST_Op<"non_negative_int_attr"> {
let arguments = (ins
Confined<I32Attr, [IntNonNegative]>:$i32attr,
Confined<I64Attr, [IntNonNegative]>:$i64attr
ConfinedAttr<I32Attr, [IntNonNegative]>:$i32attr,
ConfinedAttr<I64Attr, [IntNonNegative]>:$i64attr
);
}
def PositiveIntAttrOp : TEST_Op<"positive_int_attr"> {
let arguments = (ins
Confined<I32Attr, [IntPositive]>:$i32attr,
Confined<I64Attr, [IntPositive]>:$i64attr
ConfinedAttr<I32Attr, [IntPositive]>:$i32attr,
ConfinedAttr<I64Attr, [IntPositive]>:$i64attr
);
}
@ -377,7 +377,7 @@ def OpWithBitEnumVerticalBar : TEST_Op<"op_with_bit_enum_vbar"> {
def SymbolRefOp : TEST_Op<"symbol_ref_attr"> {
let arguments = (ins
Confined<FlatSymbolRefAttr, [ReferToOp<"func::FuncOp">]>:$symbol
ConfinedAttr<FlatSymbolRefAttr, [ReferToOp<"func::FuncOp">]>:$symbol
);
}
@ -1127,7 +1127,7 @@ def : Pattern<(OpNativeCodeCall6 $arg1, $arg2),
[(OpNativeCodeCall7 (BindMultipleNativeCodeCallResult:$native__0 $arg1, $arg2)),
(OpNativeCodeCall7 $native__1)]>;
// Test AllAttrConstraintsOf.
// Test AllAttrOf.
def OpAllAttrConstraint1 : TEST_Op<"all_attr_constraint_of1"> {
let arguments = (ins I64ArrayAttr:$attr);
let results = (outs I32);
@ -1144,7 +1144,7 @@ def Constraint1 : AttrConstraint<
CPred<"$_self.cast<ArrayAttr>()[1].cast<::mlir::IntegerAttr>().getInt() == 1">,
"[1] == 1">;
def : Pat<(OpAllAttrConstraint1
AllAttrConstraintsOf<[Constraint0, Constraint1]>:$attr),
AllAttrOf<[Constraint0, Constraint1]>:$attr),
(OpAllAttrConstraint2 $attr)>;
// Op for testing RewritePattern removing op with inner ops.

2
mlir/test/mlir-pdll/Parser/include/ops.td
View File

@ -10,7 +10,7 @@ def OpAllSingle : Op<Test_Dialect, "all_single"> {
let arguments = (ins
I64:$operand,
I64Attr:$attr,
Confined<I64Attr, [IntNonNegative]>:$nonNegativeAttr
ConfinedAttr<I64Attr, [IntNonNegative]>:$nonNegativeAttr
);
let results = (outs I64:$result);
}

10
mlir/test/mlir-tblgen/predicate.td
View File

@ -50,7 +50,7 @@ def OpB : NS_Op<"op_for_And_PredOpTrait", [
// CHECK: if (!(((first)) && ((second))))
def OpF : NS_Op<"op_for_int_min_val", []> {
let arguments = (ins Confined<I32Attr, [IntMinValue<10>]>:$attr);
let arguments = (ins ConfinedAttr<I32Attr, [IntMinValue<10>]>:$attr);
}
// CHECK-LABEL: OpFAdaptor::verify
@ -58,7 +58,7 @@ def OpF : NS_Op<"op_for_int_min_val", []> {
// CHECK-NEXT: "attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose minimum value is 10"
def OpFX : NS_Op<"op_for_int_max_val", []> {
let arguments = (ins Confined<I32Attr, [IntMaxValue<10>]>:$attr);
let arguments = (ins ConfinedAttr<I32Attr, [IntMaxValue<10>]>:$attr);
}
// CHECK-LABEL: OpFXAdaptor::verify
@ -66,7 +66,7 @@ def OpFX : NS_Op<"op_for_int_max_val", []> {
// CHECK-NEXT: "attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose maximum value is 10"
def OpG : NS_Op<"op_for_arr_min_count", []> {
let arguments = (ins Confined<ArrayAttr, [ArrayMinCount<8>]>:$attr);
let arguments = (ins ConfinedAttr<ArrayAttr, [ArrayMinCount<8>]>:$attr);
}
// CHECK-LABEL: OpGAdaptor::verify
@ -74,7 +74,7 @@ def OpG : NS_Op<"op_for_arr_min_count", []> {
// CHECK-NEXT: "attribute 'attr' failed to satisfy constraint: array attribute with at least 8 elements"
def OpH : NS_Op<"op_for_arr_value_at_index", []> {
let arguments = (ins Confined<ArrayAttr, [IntArrayNthElemEq<0, 8>]>:$attr);
let arguments = (ins ConfinedAttr<ArrayAttr, [IntArrayNthElemEq<0, 8>]>:$attr);
}
// CHECK-LABEL: OpHAdaptor::verify
@ -82,7 +82,7 @@ def OpH : NS_Op<"op_for_arr_value_at_index", []> {
// CHECK-NEXT: "attribute 'attr' failed to satisfy constraint: array attribute whose 0-th element must be 8"
def OpI: NS_Op<"op_for_arr_min_value_at_index", []> {
let arguments = (ins Confined<ArrayAttr, [IntArrayNthElemMinValue<0, 8>]>:$attr);
let arguments = (ins ConfinedAttr<ArrayAttr, [IntArrayNthElemMinValue<0, 8>]>:$attr);
}
// CHECK-LABEL: OpIAdaptor::verify