//===- LLVMDialect.cpp - LLVM IR Ops and Dialect registration -------------===// // // Part of the LLVM 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 // //===----------------------------------------------------------------------===// // // This file defines the types and operation details for the LLVM IR dialect in // MLIR, and the LLVM IR dialect. It also registers the dialect. // //===----------------------------------------------------------------------===// #include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "TypeDetail.h" #include "mlir/Dialect/LLVMIR/LLVMAttrs.h" #include "mlir/Dialect/LLVMIR/LLVMInterfaces.h" #include "mlir/Dialect/LLVMIR/LLVMTypes.h" #include "mlir/IR/Attributes.h" #include "mlir/IR/Builders.h" #include "mlir/IR/BuiltinOps.h" #include "mlir/IR/BuiltinTypes.h" #include "mlir/IR/DialectImplementation.h" #include "mlir/IR/MLIRContext.h" #include "mlir/IR/Matchers.h" #include "mlir/Interfaces/FunctionImplementation.h" #include "mlir/Transforms/InliningUtils.h" #include "llvm/ADT/SCCIterator.h" #include "llvm/ADT/TypeSwitch.h" #include "llvm/AsmParser/Parser.h" #include "llvm/Bitcode/BitcodeReader.h" #include "llvm/Bitcode/BitcodeWriter.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/Function.h" #include "llvm/IR/Type.h" #include "llvm/Support/Error.h" #include "llvm/Support/Mutex.h" #include "llvm/Support/SourceMgr.h" #include <numeric> #include <optional> usingnamespacemlir; usingnamespacemlir::LLVM; getMaxEnumValForCConv; getMaxEnumValForLinkage; getMaxEnumValForTailCallKind; #include "mlir/Dialect/LLVMIR/LLVMOpsDialect.cpp.inc" //===----------------------------------------------------------------------===// // Property Helpers //===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===// // IntegerOverflowFlags namespace mlir { static Attribute convertToAttribute(MLIRContext *ctx, IntegerOverflowFlags flags) { … } static LogicalResult convertFromAttribute(IntegerOverflowFlags &flags, Attribute attr, function_ref<InFlightDiagnostic()> emitError) { … } } // namespace mlir static ParseResult parseOverflowFlags(AsmParser &p, IntegerOverflowFlags &flags) { … } static void printOverflowFlags(AsmPrinter &p, Operation *op, IntegerOverflowFlags flags) { … } //===----------------------------------------------------------------------===// // Attribute Helpers //===----------------------------------------------------------------------===// static constexpr const char kElemTypeAttrName[] = …; static auto processFMFAttr(ArrayRef<NamedAttribute> attrs) { … } static ParseResult parseLLVMOpAttrs(OpAsmParser &parser, NamedAttrList &result) { … } static void printLLVMOpAttrs(OpAsmPrinter &printer, Operation *op, DictionaryAttr attrs) { … } /// Verifies `symbol`'s use in `op` to ensure the symbol is a valid and /// fully defined llvm.func. static LogicalResult verifySymbolAttrUse(FlatSymbolRefAttr symbol, Operation *op, SymbolTableCollection &symbolTable) { … } /// Returns a boolean type that has the same shape as `type`. It supports both /// fixed size vectors as well as scalable vectors. static Type getI1SameShape(Type type) { … } // Parses one of the keywords provided in the list `keywords` and returns the // position of the parsed keyword in the list. If none of the keywords from the // list is parsed, returns -1. static int parseOptionalKeywordAlternative(OpAsmParser &parser, ArrayRef<StringRef> keywords) { … } namespace … // namespace /// Parse an enum from the keyword, or default to the provided default value. /// The return type is the enum type by default, unless overridden with the /// second template argument. template <typename EnumTy, typename RetTy = EnumTy> static RetTy parseOptionalLLVMKeyword(OpAsmParser &parser, OperationState &result, EnumTy defaultValue) { … } //===----------------------------------------------------------------------===// // Operand bundle helpers. //===----------------------------------------------------------------------===// static void printOneOpBundle(OpAsmPrinter &p, OperandRange operands, TypeRange operandTypes, StringRef tag) { … } static void printOpBundles(OpAsmPrinter &p, Operation *op, OperandRangeRange opBundleOperands, TypeRangeRange opBundleOperandTypes, ArrayRef<std::string> opBundleTags) { … } static ParseResult parseOneOpBundle( OpAsmParser &p, SmallVector<SmallVector<OpAsmParser::UnresolvedOperand>> &opBundleOperands, SmallVector<SmallVector<Type>> &opBundleOperandTypes, SmallVector<std::string> &opBundleTags) { … } static std::optional<ParseResult> parseOpBundles( OpAsmParser &p, SmallVector<SmallVector<OpAsmParser::UnresolvedOperand>> &opBundleOperands, SmallVector<SmallVector<Type>> &opBundleOperandTypes, SmallVector<std::string> &opBundleTags) { … } //===----------------------------------------------------------------------===// // Printing, parsing, folding and builder for LLVM::CmpOp. //===----------------------------------------------------------------------===// void ICmpOp::print(OpAsmPrinter &p) { … } void FCmpOp::print(OpAsmPrinter &p) { … } // <operation> ::= `llvm.icmp` string-literal ssa-use `,` ssa-use // attribute-dict? `:` type // <operation> ::= `llvm.fcmp` string-literal ssa-use `,` ssa-use // attribute-dict? `:` type template <typename CmpPredicateType> static ParseResult parseCmpOp(OpAsmParser &parser, OperationState &result) { … } ParseResult ICmpOp::parse(OpAsmParser &parser, OperationState &result) { … } ParseResult FCmpOp::parse(OpAsmParser &parser, OperationState &result) { … } /// Returns a scalar or vector boolean attribute of the given type. static Attribute getBoolAttribute(Type type, MLIRContext *ctx, bool value) { … } OpFoldResult ICmpOp::fold(FoldAdaptor adaptor) { … } //===----------------------------------------------------------------------===// // Printing, parsing and verification for LLVM::AllocaOp. //===----------------------------------------------------------------------===// void AllocaOp::print(OpAsmPrinter &p) { … } // <operation> ::= `llvm.alloca` `inalloca`? ssa-use `x` type // attribute-dict? `:` type `,` type ParseResult AllocaOp::parse(OpAsmParser &parser, OperationState &result) { … } LogicalResult AllocaOp::verify() { … } //===----------------------------------------------------------------------===// // LLVM::BrOp //===----------------------------------------------------------------------===// SuccessorOperands BrOp::getSuccessorOperands(unsigned index) { … } //===----------------------------------------------------------------------===// // LLVM::CondBrOp //===----------------------------------------------------------------------===// SuccessorOperands CondBrOp::getSuccessorOperands(unsigned index) { … } void CondBrOp::build(OpBuilder &builder, OperationState &result, Value condition, Block *trueDest, ValueRange trueOperands, Block *falseDest, ValueRange falseOperands, std::optional<std::pair<uint32_t, uint32_t>> weights) { … } //===----------------------------------------------------------------------===// // LLVM::SwitchOp //===----------------------------------------------------------------------===// void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value, Block *defaultDestination, ValueRange defaultOperands, DenseIntElementsAttr caseValues, BlockRange caseDestinations, ArrayRef<ValueRange> caseOperands, ArrayRef<int32_t> branchWeights) { … } void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef<APInt> caseValues, BlockRange caseDestinations, ArrayRef<ValueRange> caseOperands, ArrayRef<int32_t> branchWeights) { … } void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value, Block *defaultDestination, ValueRange defaultOperands, ArrayRef<int32_t> caseValues, BlockRange caseDestinations, ArrayRef<ValueRange> caseOperands, ArrayRef<int32_t> branchWeights) { … } /// <cases> ::= `[` (case (`,` case )* )? `]` /// <case> ::= integer `:` bb-id (`(` ssa-use-and-type-list `)`)? static ParseResult parseSwitchOpCases( OpAsmParser &parser, Type flagType, DenseIntElementsAttr &caseValues, SmallVectorImpl<Block *> &caseDestinations, SmallVectorImpl<SmallVector<OpAsmParser::UnresolvedOperand>> &caseOperands, SmallVectorImpl<SmallVector<Type>> &caseOperandTypes) { … } static void printSwitchOpCases(OpAsmPrinter &p, SwitchOp op, Type flagType, DenseIntElementsAttr caseValues, SuccessorRange caseDestinations, OperandRangeRange caseOperands, const TypeRangeRange &caseOperandTypes) { … } LogicalResult SwitchOp::verify() { … } SuccessorOperands SwitchOp::getSuccessorOperands(unsigned index) { … } //===----------------------------------------------------------------------===// // Code for LLVM::GEPOp. //===----------------------------------------------------------------------===// constexpr int32_t GEPOp::kDynamicIndex; GEPIndicesAdaptor<ValueRange> GEPOp::getIndices() { … } /// Returns the elemental type of any LLVM-compatible vector type or self. static Type extractVectorElementType(Type type) { … } /// Destructures the 'indices' parameter into 'rawConstantIndices' and /// 'dynamicIndices', encoding the former in the process. In the process, /// dynamic indices which are used to index into a structure type are converted /// to constant indices when possible. To do this, the GEPs element type should /// be passed as first parameter. static void destructureIndices(Type currType, ArrayRef<GEPArg> indices, SmallVectorImpl<int32_t> &rawConstantIndices, SmallVectorImpl<Value> &dynamicIndices) { … } void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType, Type elementType, Value basePtr, ArrayRef<GEPArg> indices, bool inbounds, ArrayRef<NamedAttribute> attributes) { … } void GEPOp::build(OpBuilder &builder, OperationState &result, Type resultType, Type elementType, Value basePtr, ValueRange indices, bool inbounds, ArrayRef<NamedAttribute> attributes) { … } static ParseResult parseGEPIndices(OpAsmParser &parser, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &indices, DenseI32ArrayAttr &rawConstantIndices) { … } static void printGEPIndices(OpAsmPrinter &printer, LLVM::GEPOp gepOp, OperandRange indices, DenseI32ArrayAttr rawConstantIndices) { … } /// For the given `indices`, check if they comply with `baseGEPType`, /// especially check against LLVMStructTypes nested within. static LogicalResult verifyStructIndices(Type baseGEPType, unsigned indexPos, GEPIndicesAdaptor<ValueRange> indices, function_ref<InFlightDiagnostic()> emitOpError) { … } /// Driver function around `verifyStructIndices`. static LogicalResult verifyStructIndices(Type baseGEPType, GEPIndicesAdaptor<ValueRange> indices, function_ref<InFlightDiagnostic()> emitOpError) { … } LogicalResult LLVM::GEPOp::verify() { … } //===----------------------------------------------------------------------===// // LoadOp //===----------------------------------------------------------------------===// void LoadOp::getEffects( SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) { … } /// Returns true if the given type is supported by atomic operations. All /// integer, float, and pointer types with a power-of-two bitsize and a minimal /// size of 8 bits are supported. static bool isTypeCompatibleWithAtomicOp(Type type, const DataLayout &dataLayout) { … } /// Verifies the attributes and the type of atomic memory access operations. template <typename OpTy> LogicalResult verifyAtomicMemOp(OpTy memOp, Type valueType, ArrayRef<AtomicOrdering> unsupportedOrderings) { … } LogicalResult LoadOp::verify() { … } void LoadOp::build(OpBuilder &builder, OperationState &state, Type type, Value addr, unsigned alignment, bool isVolatile, bool isNonTemporal, bool isInvariant, AtomicOrdering ordering, StringRef syncscope) { … } //===----------------------------------------------------------------------===// // StoreOp //===----------------------------------------------------------------------===// void StoreOp::getEffects( SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) { … } LogicalResult StoreOp::verify() { … } void StoreOp::build(OpBuilder &builder, OperationState &state, Value value, Value addr, unsigned alignment, bool isVolatile, bool isNonTemporal, AtomicOrdering ordering, StringRef syncscope) { … } //===----------------------------------------------------------------------===// // CallOp //===----------------------------------------------------------------------===// /// Gets the MLIR Op-like result types of a LLVMFunctionType. static SmallVector<Type, 1> getCallOpResultTypes(LLVMFunctionType calleeType) { … } /// Gets the variadic callee type for a LLVMFunctionType. static TypeAttr getCallOpVarCalleeType(LLVMFunctionType calleeType) { … } /// Constructs a LLVMFunctionType from MLIR `results` and `args`. static LLVMFunctionType getLLVMFuncType(MLIRContext *context, TypeRange results, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, TypeRange results, StringRef callee, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, TypeRange results, StringAttr callee, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, TypeRange results, FlatSymbolRefAttr callee, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, LLVMFunctionType calleeType, StringRef callee, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, LLVMFunctionType calleeType, StringAttr callee, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, LLVMFunctionType calleeType, ValueRange args) { … } void CallOp::build(OpBuilder &builder, OperationState &state, LLVMFuncOp func, ValueRange args) { … } CallInterfaceCallable CallOp::getCallableForCallee() { … } void CallOp::setCalleeFromCallable(CallInterfaceCallable callee) { … } Operation::operand_range CallOp::getArgOperands() { … } MutableOperandRange CallOp::getArgOperandsMutable() { … } /// Verify that an inlinable callsite of a debug-info-bearing function in a /// debug-info-bearing function has a debug location attached to it. This /// mirrors an LLVM IR verifier. static LogicalResult verifyCallOpDebugInfo(CallOp callOp, LLVMFuncOp callee) { … } /// Verify that the parameter and return types of the variadic callee type match /// the `callOp` argument and result types. template <typename OpTy> LogicalResult verifyCallOpVarCalleeType(OpTy callOp) { … } template <typename OpType> static LogicalResult verifyOperandBundles(OpType &op) { … } LogicalResult CallOp::verify() { … } LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) { … } void CallOp::print(OpAsmPrinter &p) { … } /// Parses the type of a call operation and resolves the operands if the parsing /// succeeds. Returns failure otherwise. static ParseResult parseCallTypeAndResolveOperands( OpAsmParser &parser, OperationState &result, bool isDirect, ArrayRef<OpAsmParser::UnresolvedOperand> operands) { … } /// Parses an optional function pointer operand before the call argument list /// for indirect calls, or stops parsing at the function identifier otherwise. static ParseResult parseOptionalCallFuncPtr( OpAsmParser &parser, SmallVectorImpl<OpAsmParser::UnresolvedOperand> &operands) { … } static ParseResult resolveOpBundleOperands( OpAsmParser &parser, SMLoc loc, OperationState &state, ArrayRef<SmallVector<OpAsmParser::UnresolvedOperand>> opBundleOperands, ArrayRef<SmallVector<Type>> opBundleOperandTypes, StringAttr opBundleSizesAttrName) { … } // <operation> ::= `llvm.call` (cconv)? (tailcallkind)? (function-id | ssa-use) // `(` ssa-use-list `)` // ( `vararg(` var-callee-type `)` )? // ( `[` op-bundles-list `]` )? // attribute-dict? `:` (type `,`)? function-type ParseResult CallOp::parse(OpAsmParser &parser, OperationState &result) { … } LLVMFunctionType CallOp::getCalleeFunctionType() { … } ///===---------------------------------------------------------------------===// /// LLVM::InvokeOp ///===---------------------------------------------------------------------===// void InvokeOp::build(OpBuilder &builder, OperationState &state, LLVMFuncOp func, ValueRange ops, Block *normal, ValueRange normalOps, Block *unwind, ValueRange unwindOps) { … } void InvokeOp::build(OpBuilder &builder, OperationState &state, TypeRange tys, FlatSymbolRefAttr callee, ValueRange ops, Block *normal, ValueRange normalOps, Block *unwind, ValueRange unwindOps) { … } void InvokeOp::build(OpBuilder &builder, OperationState &state, LLVMFunctionType calleeType, FlatSymbolRefAttr callee, ValueRange ops, Block *normal, ValueRange normalOps, Block *unwind, ValueRange unwindOps) { … } SuccessorOperands InvokeOp::getSuccessorOperands(unsigned index) { … } CallInterfaceCallable InvokeOp::getCallableForCallee() { … } void InvokeOp::setCalleeFromCallable(CallInterfaceCallable callee) { … } Operation::operand_range InvokeOp::getArgOperands() { … } MutableOperandRange InvokeOp::getArgOperandsMutable() { … } LogicalResult InvokeOp::verify() { … } void InvokeOp::print(OpAsmPrinter &p) { … } // <operation> ::= `llvm.invoke` (cconv)? (function-id | ssa-use) // `(` ssa-use-list `)` // `to` bb-id (`[` ssa-use-and-type-list `]`)? // `unwind` bb-id (`[` ssa-use-and-type-list `]`)? // ( `vararg(` var-callee-type `)` )? // ( `[` op-bundles-list `]` )? // attribute-dict? `:` (type `,`)? function-type ParseResult InvokeOp::parse(OpAsmParser &parser, OperationState &result) { … } LLVMFunctionType InvokeOp::getCalleeFunctionType() { … } ///===----------------------------------------------------------------------===// /// Verifying/Printing/Parsing for LLVM::LandingpadOp. ///===----------------------------------------------------------------------===// LogicalResult LandingpadOp::verify() { … } void LandingpadOp::print(OpAsmPrinter &p) { … } // <operation> ::= `llvm.landingpad` `cleanup`? // ((`catch` | `filter`) operand-type ssa-use)* attribute-dict? ParseResult LandingpadOp::parse(OpAsmParser &parser, OperationState &result) { … } //===----------------------------------------------------------------------===// // ExtractValueOp //===----------------------------------------------------------------------===// /// Extract the type at `position` in the LLVM IR aggregate type /// `containerType`. Each element of `position` is an index into a nested /// aggregate type. Return the resulting type or emit an error. static Type getInsertExtractValueElementType( function_ref<InFlightDiagnostic(StringRef)> emitError, Type containerType, ArrayRef<int64_t> position) { … } /// Extract the type at `position` in the wrapped LLVM IR aggregate type /// `containerType`. static Type getInsertExtractValueElementType(Type llvmType, ArrayRef<int64_t> position) { … } OpFoldResult LLVM::ExtractValueOp::fold(FoldAdaptor adaptor) { … } LogicalResult ExtractValueOp::verify() { … } void ExtractValueOp::build(OpBuilder &builder, OperationState &state, Value container, ArrayRef<int64_t> position) { … } //===----------------------------------------------------------------------===// // InsertValueOp //===----------------------------------------------------------------------===// /// Infer the value type from the container type and position. static ParseResult parseInsertExtractValueElementType(AsmParser &parser, Type &valueType, Type containerType, DenseI64ArrayAttr position) { … } /// Nothing to print for an inferred type. static void printInsertExtractValueElementType(AsmPrinter &printer, Operation *op, Type valueType, Type containerType, DenseI64ArrayAttr position) { … } LogicalResult InsertValueOp::verify() { … } //===----------------------------------------------------------------------===// // ReturnOp //===----------------------------------------------------------------------===// LogicalResult ReturnOp::verify() { … } //===----------------------------------------------------------------------===// // LLVM::AddressOfOp. //===----------------------------------------------------------------------===// static Operation *parentLLVMModule(Operation *op) { … } GlobalOp AddressOfOp::getGlobal(SymbolTableCollection &symbolTable) { … } LLVMFuncOp AddressOfOp::getFunction(SymbolTableCollection &symbolTable) { … } LogicalResult AddressOfOp::verifySymbolUses(SymbolTableCollection &symbolTable) { … } // AddressOfOp constant-folds to the global symbol name. OpFoldResult LLVM::AddressOfOp::fold(FoldAdaptor) { … } //===----------------------------------------------------------------------===// // Verifier for LLVM::ComdatOp. //===----------------------------------------------------------------------===// void ComdatOp::build(OpBuilder &builder, OperationState &result, StringRef symName) { … } LogicalResult ComdatOp::verifyRegions() { … } //===----------------------------------------------------------------------===// // Builder, printer and verifier for LLVM::GlobalOp. //===----------------------------------------------------------------------===// void GlobalOp::build(OpBuilder &builder, OperationState &result, Type type, bool isConstant, Linkage linkage, StringRef name, Attribute value, uint64_t alignment, unsigned addrSpace, bool dsoLocal, bool threadLocal, SymbolRefAttr comdat, ArrayRef<NamedAttribute> attrs, DIGlobalVariableExpressionAttr dbgExpr) { … } void GlobalOp::print(OpAsmPrinter &p) { … } static LogicalResult verifyComdat(Operation *op, std::optional<SymbolRefAttr> attr) { … } // operation ::= `llvm.mlir.global` linkage? visibility? // (`unnamed_addr` | `local_unnamed_addr`)? // `thread_local`? `constant`? `@` identifier // `(` attribute? `)` (`comdat(` symbol-ref-id `)`)? // attribute-list? (`:` type)? region? // // The type can be omitted for string attributes, in which case it will be // inferred from the value of the string as [strlen(value) x i8]. ParseResult GlobalOp::parse(OpAsmParser &parser, OperationState &result) { … } static bool isZeroAttribute(Attribute value) { … } LogicalResult GlobalOp::verify() { … } LogicalResult GlobalOp::verifyRegions() { … } //===----------------------------------------------------------------------===// // LLVM::GlobalCtorsOp //===----------------------------------------------------------------------===// LogicalResult GlobalCtorsOp::verifySymbolUses(SymbolTableCollection &symbolTable) { … } LogicalResult GlobalCtorsOp::verify() { … } //===----------------------------------------------------------------------===// // LLVM::GlobalDtorsOp //===----------------------------------------------------------------------===// LogicalResult GlobalDtorsOp::verifySymbolUses(SymbolTableCollection &symbolTable) { … } LogicalResult GlobalDtorsOp::verify() { … } //===----------------------------------------------------------------------===// // ShuffleVectorOp //===----------------------------------------------------------------------===// void ShuffleVectorOp::build(OpBuilder &builder, OperationState &state, Value v1, Value v2, DenseI32ArrayAttr mask, ArrayRef<NamedAttribute> attrs) { … } void ShuffleVectorOp::build(OpBuilder &builder, OperationState &state, Value v1, Value v2, ArrayRef<int32_t> mask) { … } /// Build the result type of a shuffle vector operation. static ParseResult parseShuffleType(AsmParser &parser, Type v1Type, Type &resType, DenseI32ArrayAttr mask) { … } /// Nothing to do when the result type is inferred. static void printShuffleType(AsmPrinter &printer, Operation *op, Type v1Type, Type resType, DenseI32ArrayAttr mask) { … } LogicalResult ShuffleVectorOp::verify() { … } //===----------------------------------------------------------------------===// // Implementations for LLVM::LLVMFuncOp. //===----------------------------------------------------------------------===// // Add the entry block to the function. Block *LLVMFuncOp::addEntryBlock(OpBuilder &builder) { … } void LLVMFuncOp::build(OpBuilder &builder, OperationState &result, StringRef name, Type type, LLVM::Linkage linkage, bool dsoLocal, CConv cconv, SymbolRefAttr comdat, ArrayRef<NamedAttribute> attrs, ArrayRef<DictionaryAttr> argAttrs, std::optional<uint64_t> functionEntryCount) { … } // Builds an LLVM function type from the given lists of input and output types. // Returns a null type if any of the types provided are non-LLVM types, or if // there is more than one output type. static Type buildLLVMFunctionType(OpAsmParser &parser, SMLoc loc, ArrayRef<Type> inputs, ArrayRef<Type> outputs, function_interface_impl::VariadicFlag variadicFlag) { … } // Parses an LLVM function. // // operation ::= `llvm.func` linkage? cconv? function-signature // (`comdat(` symbol-ref-id `)`)? // function-attributes? // function-body // ParseResult LLVMFuncOp::parse(OpAsmParser &parser, OperationState &result) { … } // Print the LLVMFuncOp. Collects argument and result types and passes them to // helper functions. Drops "void" result since it cannot be parsed back. Skips // the external linkage since it is the default value. void LLVMFuncOp::print(OpAsmPrinter &p) { … } // Verifies LLVM- and implementation-specific properties of the LLVM func Op: // - functions don't have 'common' linkage // - external functions have 'external' or 'extern_weak' linkage; // - vararg is (currently) only supported for external functions; LogicalResult LLVMFuncOp::verify() { … } /// Verifies LLVM- and implementation-specific properties of the LLVM func Op: /// - entry block arguments are of LLVM types. LogicalResult LLVMFuncOp::verifyRegions() { … } Region *LLVMFuncOp::getCallableRegion() { … } //===----------------------------------------------------------------------===// // UndefOp. //===----------------------------------------------------------------------===// /// Fold an undef operation to a dedicated undef attribute. OpFoldResult LLVM::UndefOp::fold(FoldAdaptor) { … } //===----------------------------------------------------------------------===// // PoisonOp. //===----------------------------------------------------------------------===// /// Fold a poison operation to a dedicated poison attribute. OpFoldResult LLVM::PoisonOp::fold(FoldAdaptor) { … } //===----------------------------------------------------------------------===// // ZeroOp. //===----------------------------------------------------------------------===// LogicalResult LLVM::ZeroOp::verify() { … } /// Fold a zero operation to a builtin zero attribute when possible and fall /// back to a dedicated zero attribute. OpFoldResult LLVM::ZeroOp::fold(FoldAdaptor) { … } //===----------------------------------------------------------------------===// // ConstantOp. //===----------------------------------------------------------------------===// /// Compute the total number of elements in the given type, also taking into /// account nested types. Supported types are `VectorType`, `LLVMArrayType` and /// `LLVMFixedVectorType`. Everything else is treated as a scalar. static int64_t getNumElements(Type t) { … } /// Check if the given type is a scalable vector type or a vector/array type /// that contains a nested scalable vector type. static bool hasScalableVectorType(Type t) { … } LogicalResult LLVM::ConstantOp::verify() { … } bool LLVM::ConstantOp::isBuildableWith(Attribute value, Type type) { … } ConstantOp LLVM::ConstantOp::materialize(OpBuilder &builder, Attribute value, Type type, Location loc) { … } // Constant op constant-folds to its value. OpFoldResult LLVM::ConstantOp::fold(FoldAdaptor) { … } //===----------------------------------------------------------------------===// // AtomicRMWOp //===----------------------------------------------------------------------===// void AtomicRMWOp::build(OpBuilder &builder, OperationState &state, AtomicBinOp binOp, Value ptr, Value val, AtomicOrdering ordering, StringRef syncscope, unsigned alignment, bool isVolatile) { … } LogicalResult AtomicRMWOp::verify() { … } //===----------------------------------------------------------------------===// // AtomicCmpXchgOp //===----------------------------------------------------------------------===// /// Returns an LLVM struct type that contains a value type and a boolean type. static LLVMStructType getValAndBoolStructType(Type valType) { … } void AtomicCmpXchgOp::build(OpBuilder &builder, OperationState &state, Value ptr, Value cmp, Value val, AtomicOrdering successOrdering, AtomicOrdering failureOrdering, StringRef syncscope, unsigned alignment, bool isWeak, bool isVolatile) { … } LogicalResult AtomicCmpXchgOp::verify() { … } //===----------------------------------------------------------------------===// // FenceOp //===----------------------------------------------------------------------===// void FenceOp::build(OpBuilder &builder, OperationState &state, AtomicOrdering ordering, StringRef syncscope) { … } LogicalResult FenceOp::verify() { … } //===----------------------------------------------------------------------===// // Verifier for extension ops //===----------------------------------------------------------------------===// /// Verifies that the given extension operation operates on consistent scalars /// or vectors, and that the target width is larger than the input width. template <class ExtOp> static LogicalResult verifyExtOp(ExtOp op) { … } //===----------------------------------------------------------------------===// // ZExtOp //===----------------------------------------------------------------------===// LogicalResult ZExtOp::verify() { … } OpFoldResult LLVM::ZExtOp::fold(FoldAdaptor adaptor) { … } //===----------------------------------------------------------------------===// // SExtOp //===----------------------------------------------------------------------===// LogicalResult SExtOp::verify() { … } //===----------------------------------------------------------------------===// // Folder and verifier for LLVM::BitcastOp //===----------------------------------------------------------------------===// /// Folds a cast op that can be chained. template <typename T> static OpFoldResult foldChainableCast(T castOp, typename T::FoldAdaptor adaptor) { … } OpFoldResult LLVM::BitcastOp::fold(FoldAdaptor adaptor) { … } LogicalResult LLVM::BitcastOp::verify() { … } //===----------------------------------------------------------------------===// // Folder for LLVM::AddrSpaceCastOp //===----------------------------------------------------------------------===// OpFoldResult LLVM::AddrSpaceCastOp::fold(FoldAdaptor adaptor) { … } Value LLVM::AddrSpaceCastOp::getViewSource() { … } //===----------------------------------------------------------------------===// // Folder for LLVM::GEPOp //===----------------------------------------------------------------------===// OpFoldResult LLVM::GEPOp::fold(FoldAdaptor adaptor) { … } Value LLVM::GEPOp::getViewSource() { … } //===----------------------------------------------------------------------===// // ShlOp //===----------------------------------------------------------------------===// OpFoldResult LLVM::ShlOp::fold(FoldAdaptor adaptor) { … } //===----------------------------------------------------------------------===// // OrOp //===----------------------------------------------------------------------===// OpFoldResult LLVM::OrOp::fold(FoldAdaptor adaptor) { … } //===----------------------------------------------------------------------===// // CallIntrinsicOp //===----------------------------------------------------------------------===// LogicalResult CallIntrinsicOp::verify() { … } void CallIntrinsicOp::build(OpBuilder &builder, OperationState &state, mlir::StringAttr intrin, mlir::ValueRange args) { … } void CallIntrinsicOp::build(OpBuilder &builder, OperationState &state, mlir::StringAttr intrin, mlir::ValueRange args, mlir::LLVM::FastmathFlagsAttr fastMathFlags) { … } void CallIntrinsicOp::build(OpBuilder &builder, OperationState &state, mlir::Type resultType, mlir::StringAttr intrin, mlir::ValueRange args) { … } void CallIntrinsicOp::build(OpBuilder &builder, OperationState &state, mlir::TypeRange resultTypes, mlir::StringAttr intrin, mlir::ValueRange args, mlir::LLVM::FastmathFlagsAttr fastMathFlags) { … } //===----------------------------------------------------------------------===// // OpAsmDialectInterface //===----------------------------------------------------------------------===// namespace { struct LLVMOpAsmDialectInterface : public OpAsmDialectInterface { … }; } // namespace //===----------------------------------------------------------------------===// // LinkerOptionsOp //===----------------------------------------------------------------------===// LogicalResult LinkerOptionsOp::verify() { … } //===----------------------------------------------------------------------===// // InlineAsmOp //===----------------------------------------------------------------------===// void InlineAsmOp::getEffects( SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>> &effects) { … } //===----------------------------------------------------------------------===// // masked_gather (intrinsic) //===----------------------------------------------------------------------===// LogicalResult LLVM::masked_gather::verify() { … } //===----------------------------------------------------------------------===// // masked_scatter (intrinsic) //===----------------------------------------------------------------------===// LogicalResult LLVM::masked_scatter::verify() { … } //===----------------------------------------------------------------------===// // LLVMDialect initialization, type parsing, and registration. //===----------------------------------------------------------------------===// void LLVMDialect::initialize() { … } #define GET_OP_CLASSES #include "mlir/Dialect/LLVMIR/LLVMOps.cpp.inc" #define GET_OP_CLASSES #include "mlir/Dialect/LLVMIR/LLVMIntrinsicOps.cpp.inc" LogicalResult LLVMDialect::verifyDataLayoutString( StringRef descr, llvm::function_ref<void(const Twine &)> reportError) { … } /// Verify LLVM dialect attributes. LogicalResult LLVMDialect::verifyOperationAttribute(Operation *op, NamedAttribute attr) { … } LogicalResult LLVMDialect::verifyParameterAttribute(Operation *op, Type paramType, NamedAttribute paramAttr) { … } /// Verify LLVMIR function argument attributes. LogicalResult LLVMDialect::verifyRegionArgAttribute(Operation *op, unsigned regionIdx, unsigned argIdx, NamedAttribute argAttr) { … } LogicalResult LLVMDialect::verifyRegionResultAttribute(Operation *op, unsigned regionIdx, unsigned resIdx, NamedAttribute resAttr) { … } Operation *LLVMDialect::materializeConstant(OpBuilder &builder, Attribute value, Type type, Location loc) { … } //===----------------------------------------------------------------------===// // Utility functions. //===----------------------------------------------------------------------===// Value mlir::LLVM::createGlobalString(Location loc, OpBuilder &builder, StringRef name, StringRef value, LLVM::Linkage linkage) { … } bool mlir::LLVM::satisfiesLLVMModule(Operation *op) { … }
Codebase Browser
llvm