//===- OpenACC.cpp - OpenACC MLIR Operations ------------------------------===// // // Part of the MLIR Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // // ============================================================================= #include "mlir/Dialect/OpenACC/OpenACC.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMTypes.h" #include "mlir/Dialect/MemRef/IR/MemRef.h" #include "mlir/IR/Builders.h" #include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/DialectImplementation.h" #include "mlir/IR/Matchers.h" #include "mlir/IR/OpImplementation.h" #include "mlir/Transforms/DialectConversion.h" #include "llvm/ADT/SmallSet.h" #include "llvm/ADT/TypeSwitch.h" usingnamespacemlir; usingnamespaceacc; #include "mlir/Dialect/OpenACC/OpenACCOpsDialect.cpp.inc" #include "mlir/Dialect/OpenACC/OpenACCOpsEnums.cpp.inc" #include "mlir/Dialect/OpenACC/OpenACCOpsInterfaces.cpp.inc" #include "mlir/Dialect/OpenACC/OpenACCTypeInterfaces.cpp.inc" #include "mlir/Dialect/OpenACCMPCommon/Interfaces/OpenACCMPOpsInterfaces.cpp.inc" namespace { struct MemRefPointerLikeModel : public PointerLikeType::ExternalModel<MemRefPointerLikeModel, MemRefType> { … }; struct LLVMPointerPointerLikeModel : public PointerLikeType::ExternalModel<LLVMPointerPointerLikeModel, LLVM::LLVMPointerType> { … }; } // namespace //===----------------------------------------------------------------------===// // OpenACC operations //===----------------------------------------------------------------------===// void OpenACCDialect::initialize() { … } //===----------------------------------------------------------------------===// // device_type support helpers //===----------------------------------------------------------------------===// static bool hasDeviceTypeValues(std::optional<mlir::ArrayAttr> arrayAttr) { … } static bool hasDeviceType(std::optional<mlir::ArrayAttr> arrayAttr, mlir::acc::DeviceType deviceType) { … } static void printDeviceTypes(mlir::OpAsmPrinter &p, std::optional<mlir::ArrayAttr> deviceTypes) { … } static std::optional<unsigned> findSegment(ArrayAttr segments, mlir::acc::DeviceType deviceType) { … } static mlir::Operation::operand_range getValuesFromSegments(std::optional<mlir::ArrayAttr> arrayAttr, mlir::Operation::operand_range range, std::optional<llvm::ArrayRef<int32_t>> segments, mlir::acc::DeviceType deviceType) { … } static mlir::Value getWaitDevnumValue(std::optional<mlir::ArrayAttr> deviceTypeAttr, mlir::Operation::operand_range operands, std::optional<llvm::ArrayRef<int32_t>> segments, std::optional<mlir::ArrayAttr> hasWaitDevnum, mlir::acc::DeviceType deviceType) { … } static mlir::Operation::operand_range getWaitValuesWithoutDevnum(std::optional<mlir::ArrayAttr> deviceTypeAttr, mlir::Operation::operand_range operands, std::optional<llvm::ArrayRef<int32_t>> segments, std::optional<mlir::ArrayAttr> hasWaitDevnum, mlir::acc::DeviceType deviceType) { … } template <typename Op> static LogicalResult checkWaitAndAsyncConflict(Op op) { … } //===----------------------------------------------------------------------===// // DataBoundsOp //===----------------------------------------------------------------------===// LogicalResult acc::DataBoundsOp::verify() { … } //===----------------------------------------------------------------------===// // PrivateOp //===----------------------------------------------------------------------===// LogicalResult acc::PrivateOp::verify() { … } //===----------------------------------------------------------------------===// // FirstprivateOp //===----------------------------------------------------------------------===// LogicalResult acc::FirstprivateOp::verify() { … } //===----------------------------------------------------------------------===// // ReductionOp //===----------------------------------------------------------------------===// LogicalResult acc::ReductionOp::verify() { … } //===----------------------------------------------------------------------===// // DevicePtrOp //===----------------------------------------------------------------------===// LogicalResult acc::DevicePtrOp::verify() { … } //===----------------------------------------------------------------------===// // PresentOp //===----------------------------------------------------------------------===// LogicalResult acc::PresentOp::verify() { … } //===----------------------------------------------------------------------===// // CopyinOp //===----------------------------------------------------------------------===// LogicalResult acc::CopyinOp::verify() { … } bool acc::CopyinOp::isCopyinReadonly() { … } //===----------------------------------------------------------------------===// // CreateOp //===----------------------------------------------------------------------===// LogicalResult acc::CreateOp::verify() { … } bool acc::CreateOp::isCreateZero() { … } //===----------------------------------------------------------------------===// // NoCreateOp //===----------------------------------------------------------------------===// LogicalResult acc::NoCreateOp::verify() { … } //===----------------------------------------------------------------------===// // AttachOp //===----------------------------------------------------------------------===// LogicalResult acc::AttachOp::verify() { … } //===----------------------------------------------------------------------===// // DeclareDeviceResidentOp //===----------------------------------------------------------------------===// LogicalResult acc::DeclareDeviceResidentOp::verify() { … } //===----------------------------------------------------------------------===// // DeclareLinkOp //===----------------------------------------------------------------------===// LogicalResult acc::DeclareLinkOp::verify() { … } //===----------------------------------------------------------------------===// // CopyoutOp //===----------------------------------------------------------------------===// LogicalResult acc::CopyoutOp::verify() { … } bool acc::CopyoutOp::isCopyoutZero() { … } //===----------------------------------------------------------------------===// // DeleteOp //===----------------------------------------------------------------------===// LogicalResult acc::DeleteOp::verify() { … } //===----------------------------------------------------------------------===// // DetachOp //===----------------------------------------------------------------------===// LogicalResult acc::DetachOp::verify() { … } //===----------------------------------------------------------------------===// // HostOp //===----------------------------------------------------------------------===// LogicalResult acc::UpdateHostOp::verify() { … } //===----------------------------------------------------------------------===// // DeviceOp //===----------------------------------------------------------------------===// LogicalResult acc::UpdateDeviceOp::verify() { … } //===----------------------------------------------------------------------===// // UseDeviceOp //===----------------------------------------------------------------------===// LogicalResult acc::UseDeviceOp::verify() { … } //===----------------------------------------------------------------------===// // CacheOp //===----------------------------------------------------------------------===// LogicalResult acc::CacheOp::verify() { … } template <typename StructureOp> static ParseResult parseRegions(OpAsmParser &parser, OperationState &state, unsigned nRegions = 1) { … } static bool isComputeOperation(Operation *op) { … } namespace { /// Pattern to remove operation without region that have constant false `ifCond` /// and remove the condition from the operation if the `ifCond` is a true /// constant. template <typename OpTy> struct RemoveConstantIfCondition : public OpRewritePattern<OpTy> { … }; /// Replaces the given op with the contents of the given single-block region, /// using the operands of the block terminator to replace operation results. static void replaceOpWithRegion(PatternRewriter &rewriter, Operation *op, Region ®ion, ValueRange blockArgs = { … } /// Pattern to remove operation with region that have constant false `ifCond` /// and remove the condition from the operation if the `ifCond` is constant /// true. template <typename OpTy> struct RemoveConstantIfConditionWithRegion : public OpRewritePattern<OpTy> { … }; } // namespace //===----------------------------------------------------------------------===// // PrivateRecipeOp //===----------------------------------------------------------------------===// static LogicalResult verifyInitLikeSingleArgRegion( Operation *op, Region ®ion, StringRef regionType, StringRef regionName, Type type, bool verifyYield, bool optional = false) { … } LogicalResult acc::PrivateRecipeOp::verifyRegions() { … } //===----------------------------------------------------------------------===// // FirstprivateRecipeOp //===----------------------------------------------------------------------===// LogicalResult acc::FirstprivateRecipeOp::verifyRegions() { … } //===----------------------------------------------------------------------===// // ReductionRecipeOp //===----------------------------------------------------------------------===// LogicalResult acc::ReductionRecipeOp::verifyRegions() { … } //===----------------------------------------------------------------------===// // Custom parser and printer verifier for private clause //===----------------------------------------------------------------------===// static ParseResult parseSymOperandList( mlir::OpAsmParser &parser, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands, llvm::SmallVectorImpl<Type> &types, mlir::ArrayAttr &symbols) { … } static void printSymOperandList(mlir::OpAsmPrinter &p, mlir::Operation *op, mlir::OperandRange operands, mlir::TypeRange types, std::optional<mlir::ArrayAttr> attributes) { … } //===----------------------------------------------------------------------===// // ParallelOp //===----------------------------------------------------------------------===// /// Check dataOperands for acc.parallel, acc.serial and acc.kernels. template <typename Op> static LogicalResult checkDataOperands(Op op, const mlir::ValueRange &operands) { … } template <typename Op> static LogicalResult checkSymOperandList(Operation *op, std::optional<mlir::ArrayAttr> attributes, mlir::OperandRange operands, llvm::StringRef operandName, llvm::StringRef symbolName, bool checkOperandType = true) { … } unsigned ParallelOp::getNumDataOperands() { … } Value ParallelOp::getDataOperand(unsigned i) { … } template <typename Op> static LogicalResult verifyDeviceTypeCountMatch(Op op, OperandRange operands, ArrayAttr deviceTypes, llvm::StringRef keyword) { … } template <typename Op> static LogicalResult verifyDeviceTypeAndSegmentCountMatch( Op op, OperandRange operands, DenseI32ArrayAttr segments, ArrayAttr deviceTypes, llvm::StringRef keyword, int32_t maxInSegment = 0) { … } LogicalResult acc::ParallelOp::verify() { … } static mlir::Value getValueInDeviceTypeSegment(std::optional<mlir::ArrayAttr> arrayAttr, mlir::Operation::operand_range range, mlir::acc::DeviceType deviceType) { … } bool acc::ParallelOp::hasAsyncOnly() { … } bool acc::ParallelOp::hasAsyncOnly(mlir::acc::DeviceType deviceType) { … } mlir::Value acc::ParallelOp::getAsyncValue() { … } mlir::Value acc::ParallelOp::getAsyncValue(mlir::acc::DeviceType deviceType) { … } mlir::Value acc::ParallelOp::getNumWorkersValue() { … } mlir::Value acc::ParallelOp::getNumWorkersValue(mlir::acc::DeviceType deviceType) { … } mlir::Value acc::ParallelOp::getVectorLengthValue() { … } mlir::Value acc::ParallelOp::getVectorLengthValue(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range ParallelOp::getNumGangsValues() { … } mlir::Operation::operand_range ParallelOp::getNumGangsValues(mlir::acc::DeviceType deviceType) { … } bool acc::ParallelOp::hasWaitOnly() { … } bool acc::ParallelOp::hasWaitOnly(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range ParallelOp::getWaitValues() { … } mlir::Operation::operand_range ParallelOp::getWaitValues(mlir::acc::DeviceType deviceType) { … } mlir::Value ParallelOp::getWaitDevnum() { … } mlir::Value ParallelOp::getWaitDevnum(mlir::acc::DeviceType deviceType) { … } void ParallelOp::build(mlir::OpBuilder &odsBuilder, mlir::OperationState &odsState, mlir::ValueRange numGangs, mlir::ValueRange numWorkers, mlir::ValueRange vectorLength, mlir::ValueRange asyncOperands, mlir::ValueRange waitOperands, mlir::Value ifCond, mlir::Value selfCond, mlir::ValueRange reductionOperands, mlir::ValueRange gangPrivateOperands, mlir::ValueRange gangFirstPrivateOperands, mlir::ValueRange dataClauseOperands) { … } static ParseResult parseNumGangs( mlir::OpAsmParser &parser, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands, llvm::SmallVectorImpl<Type> &types, mlir::ArrayAttr &deviceTypes, mlir::DenseI32ArrayAttr &segments) { … } static void printSingleDeviceType(mlir::OpAsmPrinter &p, mlir::Attribute attr) { … } static void printNumGangs(mlir::OpAsmPrinter &p, mlir::Operation *op, mlir::OperandRange operands, mlir::TypeRange types, std::optional<mlir::ArrayAttr> deviceTypes, std::optional<mlir::DenseI32ArrayAttr> segments) { … } static ParseResult parseDeviceTypeOperandsWithSegment( mlir::OpAsmParser &parser, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands, llvm::SmallVectorImpl<Type> &types, mlir::ArrayAttr &deviceTypes, mlir::DenseI32ArrayAttr &segments) { … } static void printDeviceTypeOperandsWithSegment( mlir::OpAsmPrinter &p, mlir::Operation *op, mlir::OperandRange operands, mlir::TypeRange types, std::optional<mlir::ArrayAttr> deviceTypes, std::optional<mlir::DenseI32ArrayAttr> segments) { … } static ParseResult parseWaitClause( mlir::OpAsmParser &parser, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands, llvm::SmallVectorImpl<Type> &types, mlir::ArrayAttr &deviceTypes, mlir::DenseI32ArrayAttr &segments, mlir::ArrayAttr &hasDevNum, mlir::ArrayAttr &keywordOnly) { … } static bool hasOnlyDeviceTypeNone(std::optional<mlir::ArrayAttr> attrs) { … } static void printWaitClause(mlir::OpAsmPrinter &p, mlir::Operation *op, mlir::OperandRange operands, mlir::TypeRange types, std::optional<mlir::ArrayAttr> deviceTypes, std::optional<mlir::DenseI32ArrayAttr> segments, std::optional<mlir::ArrayAttr> hasDevNum, std::optional<mlir::ArrayAttr> keywordOnly) { … } static ParseResult parseDeviceTypeOperands( mlir::OpAsmParser &parser, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands, llvm::SmallVectorImpl<Type> &types, mlir::ArrayAttr &deviceTypes) { … } static void printDeviceTypeOperands(mlir::OpAsmPrinter &p, mlir::Operation *op, mlir::OperandRange operands, mlir::TypeRange types, std::optional<mlir::ArrayAttr> deviceTypes) { … } static ParseResult parseDeviceTypeOperandsWithKeywordOnly( mlir::OpAsmParser &parser, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands, llvm::SmallVectorImpl<Type> &types, mlir::ArrayAttr &deviceTypes, mlir::ArrayAttr &keywordOnlyDeviceType) { … } static void printDeviceTypeOperandsWithKeywordOnly( mlir::OpAsmPrinter &p, mlir::Operation *op, mlir::OperandRange operands, mlir::TypeRange types, std::optional<mlir::ArrayAttr> deviceTypes, std::optional<mlir::ArrayAttr> keywordOnlyDeviceTypes) { … } static ParseResult parseCombinedConstructsLoop(mlir::OpAsmParser &parser, mlir::acc::CombinedConstructsTypeAttr &attr) { … } static void printCombinedConstructsLoop(mlir::OpAsmPrinter &p, mlir::Operation *op, mlir::acc::CombinedConstructsTypeAttr attr) { … } //===----------------------------------------------------------------------===// // SerialOp //===----------------------------------------------------------------------===// unsigned SerialOp::getNumDataOperands() { … } Value SerialOp::getDataOperand(unsigned i) { … } bool acc::SerialOp::hasAsyncOnly() { … } bool acc::SerialOp::hasAsyncOnly(mlir::acc::DeviceType deviceType) { … } mlir::Value acc::SerialOp::getAsyncValue() { … } mlir::Value acc::SerialOp::getAsyncValue(mlir::acc::DeviceType deviceType) { … } bool acc::SerialOp::hasWaitOnly() { … } bool acc::SerialOp::hasWaitOnly(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range SerialOp::getWaitValues() { … } mlir::Operation::operand_range SerialOp::getWaitValues(mlir::acc::DeviceType deviceType) { … } mlir::Value SerialOp::getWaitDevnum() { … } mlir::Value SerialOp::getWaitDevnum(mlir::acc::DeviceType deviceType) { … } LogicalResult acc::SerialOp::verify() { … } //===----------------------------------------------------------------------===// // KernelsOp //===----------------------------------------------------------------------===// unsigned KernelsOp::getNumDataOperands() { … } Value KernelsOp::getDataOperand(unsigned i) { … } bool acc::KernelsOp::hasAsyncOnly() { … } bool acc::KernelsOp::hasAsyncOnly(mlir::acc::DeviceType deviceType) { … } mlir::Value acc::KernelsOp::getAsyncValue() { … } mlir::Value acc::KernelsOp::getAsyncValue(mlir::acc::DeviceType deviceType) { … } mlir::Value acc::KernelsOp::getNumWorkersValue() { … } mlir::Value acc::KernelsOp::getNumWorkersValue(mlir::acc::DeviceType deviceType) { … } mlir::Value acc::KernelsOp::getVectorLengthValue() { … } mlir::Value acc::KernelsOp::getVectorLengthValue(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range KernelsOp::getNumGangsValues() { … } mlir::Operation::operand_range KernelsOp::getNumGangsValues(mlir::acc::DeviceType deviceType) { … } bool acc::KernelsOp::hasWaitOnly() { … } bool acc::KernelsOp::hasWaitOnly(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range KernelsOp::getWaitValues() { … } mlir::Operation::operand_range KernelsOp::getWaitValues(mlir::acc::DeviceType deviceType) { … } mlir::Value KernelsOp::getWaitDevnum() { … } mlir::Value KernelsOp::getWaitDevnum(mlir::acc::DeviceType deviceType) { … } LogicalResult acc::KernelsOp::verify() { … } //===----------------------------------------------------------------------===// // HostDataOp //===----------------------------------------------------------------------===// LogicalResult acc::HostDataOp::verify() { … } void acc::HostDataOp::getCanonicalizationPatterns(RewritePatternSet &results, MLIRContext *context) { … } //===----------------------------------------------------------------------===// // LoopOp //===----------------------------------------------------------------------===// static ParseResult parseGangValue( OpAsmParser &parser, llvm::StringRef keyword, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &operands, llvm::SmallVectorImpl<Type> &types, llvm::SmallVector<GangArgTypeAttr> &attributes, GangArgTypeAttr gangArgType, bool &needCommaBetweenValues, bool &newValue) { … } static ParseResult parseGangClause( OpAsmParser &parser, llvm::SmallVectorImpl<mlir::OpAsmParser::UnresolvedOperand> &gangOperands, llvm::SmallVectorImpl<Type> &gangOperandsType, mlir::ArrayAttr &gangArgType, mlir::ArrayAttr &deviceType, mlir::DenseI32ArrayAttr &segments, mlir::ArrayAttr &gangOnlyDeviceType) { … } void printGangClause(OpAsmPrinter &p, Operation *op, mlir::OperandRange operands, mlir::TypeRange types, std::optional<mlir::ArrayAttr> gangArgTypes, std::optional<mlir::ArrayAttr> deviceTypes, std::optional<mlir::DenseI32ArrayAttr> segments, std::optional<mlir::ArrayAttr> gangOnlyDeviceTypes) { … } bool hasDuplicateDeviceTypes( std::optional<mlir::ArrayAttr> segments, llvm::SmallSet<mlir::acc::DeviceType, 3> &deviceTypes) { … } /// Check for duplicates in the DeviceType array attribute. LogicalResult checkDeviceTypes(mlir::ArrayAttr deviceTypes) { … } LogicalResult acc::LoopOp::verify() { … } unsigned LoopOp::getNumDataOperands() { … } Value LoopOp::getDataOperand(unsigned i) { … } bool LoopOp::hasAuto() { … } bool LoopOp::hasAuto(mlir::acc::DeviceType deviceType) { … } bool LoopOp::hasIndependent() { … } bool LoopOp::hasIndependent(mlir::acc::DeviceType deviceType) { … } bool LoopOp::hasSeq() { … } bool LoopOp::hasSeq(mlir::acc::DeviceType deviceType) { … } mlir::Value LoopOp::getVectorValue() { … } mlir::Value LoopOp::getVectorValue(mlir::acc::DeviceType deviceType) { … } bool LoopOp::hasVector() { … } bool LoopOp::hasVector(mlir::acc::DeviceType deviceType) { … } mlir::Value LoopOp::getWorkerValue() { … } mlir::Value LoopOp::getWorkerValue(mlir::acc::DeviceType deviceType) { … } bool LoopOp::hasWorker() { … } bool LoopOp::hasWorker(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range LoopOp::getTileValues() { … } mlir::Operation::operand_range LoopOp::getTileValues(mlir::acc::DeviceType deviceType) { … } std::optional<int64_t> LoopOp::getCollapseValue() { … } std::optional<int64_t> LoopOp::getCollapseValue(mlir::acc::DeviceType deviceType) { … } mlir::Value LoopOp::getGangValue(mlir::acc::GangArgType gangArgType) { … } mlir::Value LoopOp::getGangValue(mlir::acc::GangArgType gangArgType, mlir::acc::DeviceType deviceType) { … } bool LoopOp::hasGang() { … } bool LoopOp::hasGang(mlir::acc::DeviceType deviceType) { … } llvm::SmallVector<mlir::Region *> acc::LoopOp::getLoopRegions() { … } /// loop-control ::= `control` `(` ssa-id-and-type-list `)` `=` /// `(` ssa-id-and-type-list `)` `to` `(` ssa-id-and-type-list `)` `step` /// `(` ssa-id-and-type-list `)` /// region ParseResult parseLoopControl(OpAsmParser &parser, Region ®ion, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &lowerbound, SmallVectorImpl<Type> &lowerboundType, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &upperbound, SmallVectorImpl<Type> &upperboundType, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &step, SmallVectorImpl<Type> &stepType) { … } void printLoopControl(OpAsmPrinter &p, Operation *op, Region ®ion, ValueRange lowerbound, TypeRange lowerboundType, ValueRange upperbound, TypeRange upperboundType, ValueRange steps, TypeRange stepType) { … } //===----------------------------------------------------------------------===// // DataOp //===----------------------------------------------------------------------===// LogicalResult acc::DataOp::verify() { … } unsigned DataOp::getNumDataOperands() { … } Value DataOp::getDataOperand(unsigned i) { … } bool acc::DataOp::hasAsyncOnly() { … } bool acc::DataOp::hasAsyncOnly(mlir::acc::DeviceType deviceType) { … } mlir::Value DataOp::getAsyncValue() { … } mlir::Value DataOp::getAsyncValue(mlir::acc::DeviceType deviceType) { … } bool DataOp::hasWaitOnly() { … } bool DataOp::hasWaitOnly(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range DataOp::getWaitValues() { … } mlir::Operation::operand_range DataOp::getWaitValues(mlir::acc::DeviceType deviceType) { … } mlir::Value DataOp::getWaitDevnum() { … } mlir::Value DataOp::getWaitDevnum(mlir::acc::DeviceType deviceType) { … } //===----------------------------------------------------------------------===// // ExitDataOp //===----------------------------------------------------------------------===// LogicalResult acc::ExitDataOp::verify() { … } unsigned ExitDataOp::getNumDataOperands() { … } Value ExitDataOp::getDataOperand(unsigned i) { … } void ExitDataOp::getCanonicalizationPatterns(RewritePatternSet &results, MLIRContext *context) { … } //===----------------------------------------------------------------------===// // EnterDataOp //===----------------------------------------------------------------------===// LogicalResult acc::EnterDataOp::verify() { … } unsigned EnterDataOp::getNumDataOperands() { … } Value EnterDataOp::getDataOperand(unsigned i) { … } void EnterDataOp::getCanonicalizationPatterns(RewritePatternSet &results, MLIRContext *context) { … } //===----------------------------------------------------------------------===// // AtomicReadOp //===----------------------------------------------------------------------===// LogicalResult AtomicReadOp::verify() { … } //===----------------------------------------------------------------------===// // AtomicWriteOp //===----------------------------------------------------------------------===// LogicalResult AtomicWriteOp::verify() { … } //===----------------------------------------------------------------------===// // AtomicUpdateOp //===----------------------------------------------------------------------===// LogicalResult AtomicUpdateOp::canonicalize(AtomicUpdateOp op, PatternRewriter &rewriter) { … } LogicalResult AtomicUpdateOp::verify() { … } LogicalResult AtomicUpdateOp::verifyRegions() { … } //===----------------------------------------------------------------------===// // AtomicCaptureOp //===----------------------------------------------------------------------===// AtomicReadOp AtomicCaptureOp::getAtomicReadOp() { … } AtomicWriteOp AtomicCaptureOp::getAtomicWriteOp() { … } AtomicUpdateOp AtomicCaptureOp::getAtomicUpdateOp() { … } LogicalResult AtomicCaptureOp::verifyRegions() { … } //===----------------------------------------------------------------------===// // DeclareEnterOp //===----------------------------------------------------------------------===// template <typename Op> static LogicalResult checkDeclareOperands(Op &op, const mlir::ValueRange &operands, bool requireAtLeastOneOperand = true) { … } LogicalResult acc::DeclareEnterOp::verify() { … } //===----------------------------------------------------------------------===// // DeclareExitOp //===----------------------------------------------------------------------===// LogicalResult acc::DeclareExitOp::verify() { … } //===----------------------------------------------------------------------===// // DeclareOp //===----------------------------------------------------------------------===// LogicalResult acc::DeclareOp::verify() { … } //===----------------------------------------------------------------------===// // RoutineOp //===----------------------------------------------------------------------===// static unsigned getParallelismForDeviceType(acc::RoutineOp op, acc::DeviceType dtype) { … } LogicalResult acc::RoutineOp::verify() { … } static ParseResult parseBindName(OpAsmParser &parser, mlir::ArrayAttr &bindName, mlir::ArrayAttr &deviceTypes) { … } static void printBindName(mlir::OpAsmPrinter &p, mlir::Operation *op, std::optional<mlir::ArrayAttr> bindName, std::optional<mlir::ArrayAttr> deviceTypes) { … } static ParseResult parseRoutineGangClause(OpAsmParser &parser, mlir::ArrayAttr &gang, mlir::ArrayAttr &gangDim, mlir::ArrayAttr &gangDimDeviceTypes) { … } void printRoutineGangClause(OpAsmPrinter &p, Operation *op, std::optional<mlir::ArrayAttr> gang, std::optional<mlir::ArrayAttr> gangDim, std::optional<mlir::ArrayAttr> gangDimDeviceTypes) { … } static ParseResult parseDeviceTypeArrayAttr(OpAsmParser &parser, mlir::ArrayAttr &deviceTypes) { … } static void printDeviceTypeArrayAttr(mlir::OpAsmPrinter &p, mlir::Operation *op, std::optional<mlir::ArrayAttr> deviceTypes) { … } bool RoutineOp::hasWorker() { … } bool RoutineOp::hasWorker(mlir::acc::DeviceType deviceType) { … } bool RoutineOp::hasVector() { … } bool RoutineOp::hasVector(mlir::acc::DeviceType deviceType) { … } bool RoutineOp::hasSeq() { … } bool RoutineOp::hasSeq(mlir::acc::DeviceType deviceType) { … } std::optional<llvm::StringRef> RoutineOp::getBindNameValue() { … } std::optional<llvm::StringRef> RoutineOp::getBindNameValue(mlir::acc::DeviceType deviceType) { … } bool RoutineOp::hasGang() { … } bool RoutineOp::hasGang(mlir::acc::DeviceType deviceType) { … } std::optional<int64_t> RoutineOp::getGangDimValue() { … } std::optional<int64_t> RoutineOp::getGangDimValue(mlir::acc::DeviceType deviceType) { … } //===----------------------------------------------------------------------===// // InitOp //===----------------------------------------------------------------------===// LogicalResult acc::InitOp::verify() { … } //===----------------------------------------------------------------------===// // ShutdownOp //===----------------------------------------------------------------------===// LogicalResult acc::ShutdownOp::verify() { … } //===----------------------------------------------------------------------===// // SetOp //===----------------------------------------------------------------------===// LogicalResult acc::SetOp::verify() { … } //===----------------------------------------------------------------------===// // UpdateOp //===----------------------------------------------------------------------===// LogicalResult acc::UpdateOp::verify() { … } unsigned UpdateOp::getNumDataOperands() { … } Value UpdateOp::getDataOperand(unsigned i) { … } void UpdateOp::getCanonicalizationPatterns(RewritePatternSet &results, MLIRContext *context) { … } bool UpdateOp::hasAsyncOnly() { … } bool UpdateOp::hasAsyncOnly(mlir::acc::DeviceType deviceType) { … } mlir::Value UpdateOp::getAsyncValue() { … } mlir::Value UpdateOp::getAsyncValue(mlir::acc::DeviceType deviceType) { … } bool UpdateOp::hasWaitOnly() { … } bool UpdateOp::hasWaitOnly(mlir::acc::DeviceType deviceType) { … } mlir::Operation::operand_range UpdateOp::getWaitValues() { … } mlir::Operation::operand_range UpdateOp::getWaitValues(mlir::acc::DeviceType deviceType) { … } mlir::Value UpdateOp::getWaitDevnum() { … } mlir::Value UpdateOp::getWaitDevnum(mlir::acc::DeviceType deviceType) { … } //===----------------------------------------------------------------------===// // WaitOp //===----------------------------------------------------------------------===// LogicalResult acc::WaitOp::verify() { … } #define GET_OP_CLASSES #include "mlir/Dialect/OpenACC/OpenACCOps.cpp.inc" #define GET_ATTRDEF_CLASSES #include "mlir/Dialect/OpenACC/OpenACCOpsAttributes.cpp.inc" #define GET_TYPEDEF_CLASSES #include "mlir/Dialect/OpenACC/OpenACCOpsTypes.cpp.inc" //===----------------------------------------------------------------------===// // acc dialect utilities //===----------------------------------------------------------------------===// mlir::Value mlir::acc::getVarPtr(mlir::Operation *accDataClauseOp) { … } mlir::Value mlir::acc::getAccPtr(mlir::Operation *accDataClauseOp) { … } mlir::Value mlir::acc::getVarPtrPtr(mlir::Operation *accDataClauseOp) { … } mlir::SmallVector<mlir::Value> mlir::acc::getBounds(mlir::Operation *accDataClauseOp) { … } mlir::SmallVector<mlir::Value> mlir::acc::getAsyncOperands(mlir::Operation *accDataClauseOp) { … } mlir::ArrayAttr mlir::acc::getAsyncOperandsDeviceType(mlir::Operation *accDataClauseOp) { … } mlir::ArrayAttr mlir::acc::getAsyncOnly(mlir::Operation *accDataClauseOp) { … } std::optional<llvm::StringRef> mlir::acc::getVarName(mlir::Operation *accOp) { … } std::optional<mlir::acc::DataClause> mlir::acc::getDataClause(mlir::Operation *accDataEntryOp) { … } bool mlir::acc::getImplicitFlag(mlir::Operation *accDataEntryOp) { … } mlir::ValueRange mlir::acc::getDataOperands(mlir::Operation *accOp) { … } mlir::MutableOperandRange mlir::acc::getMutableDataOperands(mlir::Operation *accOp) { … }
Codebase Browser
llvm