123 lines
5.1 KiB
C++
123 lines
5.1 KiB
C++
/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
|
|
|* *|
|
|
|* Interface Definitions *|
|
|
|* *|
|
|
|* Automatically generated file, do not edit! *|
|
|
|* *|
|
|
\*===----------------------------------------------------------------------===*/
|
|
|
|
|
|
/// Returns the first operation in atomic capture region.
|
|
::mlir::Operation *mlir::accomp::AtomicCaptureOpInterface::getFirstOp() {
|
|
return getImpl()->getFirstOp(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Returns the second operation in atomic capture region.
|
|
::mlir::Operation *mlir::accomp::AtomicCaptureOpInterface::getSecondOp() {
|
|
return getImpl()->getSecondOp(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier of the required region for operation that implements
|
|
/// atomic capture interface.
|
|
::llvm::LogicalResult mlir::accomp::AtomicCaptureOpInterface::verifyRegionsCommon() {
|
|
return getImpl()->verifyRegionsCommon(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Obtains `x` which is the address of the variable that is being
|
|
/// compared and potentially updated.
|
|
::mlir::Value mlir::accomp::AtomicCompareOpInterface::getX() {
|
|
return getImpl()->getX(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Returns the first operation in the atomic compare region.
|
|
::mlir::Operation *mlir::accomp::AtomicCompareOpInterface::getFirstOp() {
|
|
return getImpl()->getFirstOp(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier for operation that implements atomic compare interface.
|
|
::llvm::LogicalResult mlir::accomp::AtomicCompareOpInterface::verifyCommon() {
|
|
return getImpl()->verifyCommon(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier of the required region for operation that implements
|
|
/// atomic compare interface.
|
|
::llvm::LogicalResult mlir::accomp::AtomicCompareOpInterface::verifyRegionsCommon() {
|
|
return getImpl()->verifyRegionsCommon(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier for operator that implements atomic compare interface.
|
|
/// Checks that the comparison operation in the region uses:
|
|
/// 1) supported predicate for integer comparison : eq, slt, or sgt
|
|
/// 2) supported predicate for float comparison : oeq, oglt or lsgt
|
|
::llvm::LogicalResult mlir::accomp::AtomicCompareOpInterface::verifyOperator() {
|
|
return getImpl()->verifyOperator(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier for operation that implements atomic read interface.
|
|
::llvm::LogicalResult mlir::accomp::AtomicReadOpInterface::verifyCommon() {
|
|
return getImpl()->verifyCommon(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Obtains `x` which is the address from where the value is atomically
|
|
/// read.
|
|
::mlir::Value mlir::accomp::AtomicReadOpInterface::getX() {
|
|
return getImpl()->getX(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Obtains `v` which is the address where the value is stored after
|
|
/// reading.
|
|
::mlir::Value mlir::accomp::AtomicReadOpInterface::getV() {
|
|
return getImpl()->getV(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Obtains `x` which is the address to which the value is atomically
|
|
/// written to / read from.
|
|
::mlir::Value mlir::accomp::AtomicUpdateOpInterface::getX() {
|
|
return getImpl()->getX(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Returns the first operation in atomic update region.
|
|
::mlir::Operation *mlir::accomp::AtomicUpdateOpInterface::getFirstOp() {
|
|
return getImpl()->getFirstOp(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Returns true if the new value is same as old value and the operation is
|
|
/// a no-op, false otherwise.
|
|
bool mlir::accomp::AtomicUpdateOpInterface::isNoOp() {
|
|
return getImpl()->isNoOp(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Returns the new value if the operation is equivalent to just a write
|
|
/// operation. Otherwise, returns nullptr.
|
|
::mlir::Value mlir::accomp::AtomicUpdateOpInterface::getWriteOpVal() {
|
|
return getImpl()->getWriteOpVal(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier for operation that implements atomic update interface.
|
|
::llvm::LogicalResult mlir::accomp::AtomicUpdateOpInterface::verifyCommon() {
|
|
return getImpl()->verifyCommon(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier of the required region for operation that implements
|
|
/// atomic update interface.
|
|
::llvm::LogicalResult mlir::accomp::AtomicUpdateOpInterface::verifyRegionsCommon() {
|
|
return getImpl()->verifyRegionsCommon(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Common verifier for operation that implements atomic write interface.
|
|
::llvm::LogicalResult mlir::accomp::AtomicWriteOpInterface::verifyCommon() {
|
|
return getImpl()->verifyCommon(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Obtains `x` which is the address to which the value is atomically
|
|
/// written to.
|
|
::mlir::Value mlir::accomp::AtomicWriteOpInterface::getX() {
|
|
return getImpl()->getX(getImpl(), getOperation());
|
|
}
|
|
|
|
/// Obtains `expr` which corresponds to the expression whose value is
|
|
/// written to `x`.
|
|
::mlir::Value mlir::accomp::AtomicWriteOpInterface::getExpr() {
|
|
return getImpl()->getExpr(getImpl(), getOperation());
|
|
}
|