maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/mlir/test/Dialect/LLVMIR/roundtrip.mlir

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

336 lines
16 KiB
MLIR
Raw Normal View History

Add support for vector ops in the LLVM dialect This CL is step 1/n towards building a simple, programmable and portable vector abstraction in MLIR that can go all the way down to generating assembly vector code via LLVM's opt and llc tools. This CL adds the 3 instructions `llvm.extractelement`, `llvm.insertelement` and `llvm.shufflevector` as documented in the LLVM LangRef "Vector Instructions" section. The "Experimental Vector Reduction Intrinsics" are left out for now and can be added in the future on a per-need basis. Appropriate roundtrip and LLVM Target tests are added. PiperOrigin-RevId: 262542095
2019-08-09 20:24:47 +08:00
// RUN: mlir-opt %s | mlir-opt | FileCheck %s
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
[mlir] support returning unranked memrefs Initially, unranked memref descriptors in the LLVM dialect were designed only to be passed into functions. An assertion was guarding against returning unranked memrefs from functions in the standard-to-LLVM conversion. This is insufficient for functions that wish to return an unranked memref such that the caller does not know the rank in advance, and hence cannot allocate the descriptor and pass it in as an argument. Introduce a calling convention for returning unranked memref descriptors as follows. An unranked memref descriptor always points to a ranked memref descriptor stored on stack of the current function. When an unranked memref descriptor is returned from a function, the ranked memref descriptor it points to is copied to dynamically allocated memory, the ownership of which is transferred to the caller. The caller is responsible for deallocating the dynamically allocated memory and for copying the pointed-to ranked memref descriptor onto its stack. Provide default lowerings for std.return, std.call and std.indirect_call that maintain the conversion defined above. This convention is additionally exercised by a runtime test to guard against memory errors. Differential Revision: https://reviews.llvm.org/D82647
2020-06-26 20:34:00 +08:00
// CHECK-LABEL: func @ops
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK-SAME: (%[[I32:.*]]: !llvm.i32, %[[FLOAT:.*]]: !llvm.float, %[[I8PTR1:.*]]: !llvm.ptr<i8>, %[[I8PTR2:.*]]: !llvm.ptr<i8>, %[[BOOL:.*]]: !llvm.i1)
[mlir] support returning unranked memrefs Initially, unranked memref descriptors in the LLVM dialect were designed only to be passed into functions. An assertion was guarding against returning unranked memrefs from functions in the standard-to-LLVM conversion. This is insufficient for functions that wish to return an unranked memref such that the caller does not know the rank in advance, and hence cannot allocate the descriptor and pass it in as an argument. Introduce a calling convention for returning unranked memref descriptors as follows. An unranked memref descriptor always points to a ranked memref descriptor stored on stack of the current function. When an unranked memref descriptor is returned from a function, the ranked memref descriptor it points to is copied to dynamically allocated memory, the ownership of which is transferred to the caller. The caller is responsible for deallocating the dynamically allocated memory and for copying the pointed-to ranked memref descriptor onto its stack. Provide default lowerings for std.return, std.call and std.indirect_call that maintain the conversion defined above. This convention is additionally exercised by a runtime test to guard against memory errors. Differential Revision: https://reviews.llvm.org/D82647
2020-06-26 20:34:00 +08:00
func @ops(%arg0: !llvm.i32, %arg1: !llvm.float,
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
%arg2: !llvm.ptr<i8>, %arg3: !llvm.ptr<i8>,
[mlir] support returning unranked memrefs Initially, unranked memref descriptors in the LLVM dialect were designed only to be passed into functions. An assertion was guarding against returning unranked memrefs from functions in the standard-to-LLVM conversion. This is insufficient for functions that wish to return an unranked memref such that the caller does not know the rank in advance, and hence cannot allocate the descriptor and pass it in as an argument. Introduce a calling convention for returning unranked memref descriptors as follows. An unranked memref descriptor always points to a ranked memref descriptor stored on stack of the current function. When an unranked memref descriptor is returned from a function, the ranked memref descriptor it points to is copied to dynamically allocated memory, the ownership of which is transferred to the caller. The caller is responsible for deallocating the dynamically allocated memory and for copying the pointed-to ranked memref descriptor onto its stack. Provide default lowerings for std.return, std.call and std.indirect_call that maintain the conversion defined above. This convention is additionally exercised by a runtime test to guard against memory errors. Differential Revision: https://reviews.llvm.org/D82647
2020-06-26 20:34:00 +08:00
%arg4: !llvm.i1) {
Fix minor spelling tweaks (NFC) Closes tensorflow/mlir#175 PiperOrigin-RevId: 275726876
2019-10-21 00:44:06 +08:00
// Integer arithmetic binary operations.
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
//
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: {{.*}} = llvm.add %[[I32]], %[[I32]] : !llvm.i32
// CHECK: {{.*}} = llvm.sub %[[I32]], %[[I32]] : !llvm.i32
// CHECK: {{.*}} = llvm.mul %[[I32]], %[[I32]] : !llvm.i32
// CHECK: {{.*}} = llvm.udiv %[[I32]], %[[I32]] : !llvm.i32
// CHECK: {{.*}} = llvm.sdiv %[[I32]], %[[I32]] : !llvm.i32
// CHECK: {{.*}} = llvm.urem %[[I32]], %[[I32]] : !llvm.i32
// CHECK: {{.*}} = llvm.srem %[[I32]], %[[I32]] : !llvm.i32
// CHECK: {{.*}} = llvm.icmp "ne" %[[I32]], %[[I32]] : !llvm.i32
Change the asmprinter to use pretty syntax for dialect types when it can, making the IR dumps much nicer. This is part 2/3 of the path to making dialect types more nice. Part 3/3 will slightly generalize the set of characters allowed in pretty types and make it more principled. -- PiperOrigin-RevId: 242249955
2019-04-06 14:56:49 +08:00
%0 = llvm.add %arg0, %arg0 : !llvm.i32
%1 = llvm.sub %arg0, %arg0 : !llvm.i32
%2 = llvm.mul %arg0, %arg0 : !llvm.i32
%3 = llvm.udiv %arg0, %arg0 : !llvm.i32
%4 = llvm.sdiv %arg0, %arg0 : !llvm.i32
%5 = llvm.urem %arg0, %arg0 : !llvm.i32
%6 = llvm.srem %arg0, %arg0 : !llvm.i32
%7 = llvm.icmp "ne" %arg0, %arg0 : !llvm.i32
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
Replace remaining usages of the Instruction class with Operation. PiperOrigin-RevId: 240777521
2019-03-28 23:24:38 +08:00
// Floating point binary operations.
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
//
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: {{.*}} = llvm.fadd %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.fsub %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.fmul %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.fdiv %[[FLOAT]], %[[FLOAT]] : !llvm.float
// CHECK: {{.*}} = llvm.frem %[[FLOAT]], %[[FLOAT]] : !llvm.float
Change the asmprinter to use pretty syntax for dialect types when it can, making the IR dumps much nicer. This is part 2/3 of the path to making dialect types more nice. Part 3/3 will slightly generalize the set of characters allowed in pretty types and make it more principled. -- PiperOrigin-RevId: 242249955
2019-04-06 14:56:49 +08:00
%8 = llvm.fadd %arg1, %arg1 : !llvm.float
%9 = llvm.fsub %arg1, %arg1 : !llvm.float
%10 = llvm.fmul %arg1, %arg1 : !llvm.float
%11 = llvm.fdiv %arg1, %arg1 : !llvm.float
%12 = llvm.frem %arg1, %arg1 : !llvm.float
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
Replace remaining usages of the Instruction class with Operation. PiperOrigin-RevId: 240777521
2019-03-28 23:24:38 +08:00
// Memory-related operations.
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
//
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK-NEXT: %[[ALLOCA:.*]] = llvm.alloca %[[I32]] x !llvm.double : (!llvm.i32) -> !llvm.ptr<double>
// CHECK-NEXT: %[[GEP:.*]] = llvm.getelementptr %[[ALLOCA]][%[[I32]], %[[I32]]] : (!llvm.ptr<double>, !llvm.i32, !llvm.i32) -> !llvm.ptr<double>
// CHECK-NEXT: %[[VALUE:.*]] = llvm.load %[[GEP]] : !llvm.ptr<double>
// CHECK-NEXT: llvm.store %[[VALUE]], %[[ALLOCA]] : !llvm.ptr<double>
// CHECK-NEXT: %{{.*}} = llvm.bitcast %[[ALLOCA]] : !llvm.ptr<double> to !llvm.ptr<i64>
%13 = llvm.alloca %arg0 x !llvm.double : (!llvm.i32) -> !llvm.ptr<double>
%14 = llvm.getelementptr %13[%arg0, %arg0] : (!llvm.ptr<double>, !llvm.i32, !llvm.i32) -> !llvm.ptr<double>
%15 = llvm.load %14 : !llvm.ptr<double>
llvm.store %15, %13 : !llvm.ptr<double>
%16 = llvm.bitcast %13 : !llvm.ptr<double> to !llvm.ptr<i64>
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
Replace remaining usages of the Instruction class with Operation. PiperOrigin-RevId: 240777521
2019-03-28 23:24:38 +08:00
// Function call-related operations.
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
//
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %[[STRUCT:.*]] = llvm.call @foo(%[[I32]]) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
// CHECK: %[[VALUE:.*]] = llvm.extractvalue %[[STRUCT]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[NEW_STRUCT:.*]] = llvm.insertvalue %[[VALUE]], %[[STRUCT]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[FUNC:.*]] = llvm.mlir.addressof @foo : !llvm.ptr<func<struct<(i32, double, i32)> (i32)>>
// CHECK: %{{.*}} = llvm.call %[[FUNC]](%[[I32]]) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
%17 = llvm.call @foo(%arg0) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
%18 = llvm.extractvalue %17[0] : !llvm.struct<(i32, double, i32)>
%19 = llvm.insertvalue %18, %17[2] : !llvm.struct<(i32, double, i32)>
%20 = llvm.mlir.addressof @foo : !llvm.ptr<func<struct<(i32, double, i32)> (i32)>>
%21 = llvm.call %20(%arg0) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
Introduce custom format for the LLVM IR Dialect Historically, the LLVM IR dialect has been using the generic form of MLIR operation syntax. It is verbose and often redundant. Introduce the custom printing and parsing for all existing operations in the LLVM IR dialect. Update the relevant documentation and tests. -- PiperOrigin-RevId: 241617393
2019-04-03 06:33:54 +08:00
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
Replace remaining usages of the Instruction class with Operation. PiperOrigin-RevId: 240777521
2019-03-28 23:24:38 +08:00
// Terminator operations and their successors.
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
//
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: llvm.br ^[[BB1:.*]]
Introduce custom format for the LLVM IR Dialect Historically, the LLVM IR dialect has been using the generic form of MLIR operation syntax. It is verbose and often redundant. Introduce the custom printing and parsing for all existing operations in the LLVM IR dialect. Update the relevant documentation and tests. -- PiperOrigin-RevId: 241617393
2019-04-03 06:33:54 +08:00
llvm.br ^bb1
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: ^[[BB1]]
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
^bb1:
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: llvm.cond_br %7, ^[[BB2:.*]], ^[[BB1]]
Introduce custom format for the LLVM IR Dialect Historically, the LLVM IR dialect has been using the generic form of MLIR operation syntax. It is verbose and often redundant. Introduce the custom printing and parsing for all existing operations in the LLVM IR dialect. Update the relevant documentation and tests. -- PiperOrigin-RevId: 241617393
2019-04-03 06:33:54 +08:00
llvm.cond_br %7, ^bb2, ^bb1
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: ^[[BB2]]
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
^bb2:
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %{{.*}} = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %{{.*}} = llvm.mlir.constant(42 : i64) : !llvm.i47
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
%22 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
LLVM dialect: prefix auxiliary operations with "mlir." Some of the operations in the LLVM dialect are required to model the LLVM IR in MLIR, for example "constant" operations are needed to declare a constant value since MLIR, unlike LLVM, does not support immediate values as operands. To avoid confusion with actual LLVM operations, we prefix such axuiliary operations with "mlir.". PiperOrigin-RevId: 266942838
2019-09-04 00:10:24 +08:00
%23 = llvm.mlir.constant(42) : !llvm.i47
LLVM IR Dialect: add select op and lower standard select to it This is a similar one-to-one mapping. PiperOrigin-RevId: 233621006
2019-02-13 01:31:20 +08:00
Replace remaining usages of the Instruction class with Operation. PiperOrigin-RevId: 240777521
2019-03-28 23:24:38 +08:00
// Misc operations.
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i32
Change the asmprinter to use pretty syntax for dialect types when it can, making the IR dumps much nicer. This is part 2/3 of the path to making dialect types more nice. Part 3/3 will slightly generalize the set of characters allowed in pretty types and make it more principled. -- PiperOrigin-RevId: 242249955
2019-04-06 14:56:49 +08:00
%24 = llvm.select %7, %0, %1 : !llvm.i1, !llvm.i32
Add LLVM::IntToPtrOp and LLVM::PtrToIntOp to LLVM dialect. -- PiperOrigin-RevId: 249604199
2019-05-23 17:03:14 +08:00
// Integer to pointer and pointer to integer conversions.
//
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %[[PTR:.*]] = llvm.inttoptr %[[I32]] : !llvm.i32 to !llvm.ptr<i32>
// CHECK: %{{.*}} = llvm.ptrtoint %[[PTR]] : !llvm.ptr<i32> to !llvm.i32
%25 = llvm.inttoptr %arg0 : !llvm.i32 to !llvm.ptr<i32>
%26 = llvm.ptrtoint %25 : !llvm.ptr<i32> to !llvm.i32
Add LLVM::IntToPtrOp and LLVM::PtrToIntOp to LLVM dialect. -- PiperOrigin-RevId: 249604199
2019-05-23 17:03:14 +08:00
Add LLVM IR dialect hooks for FP128 and X86_FP80 types Closes tensorflow/mlir#184 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/184 from schweitzpgi:more-float-types ca27d00510a86ffc9c79c65fb3a0193b5ea097a0 PiperOrigin-RevId: 274288813
2019-10-12 09:35:02 +08:00
// Extended and Quad floating point
//
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : !llvm.float to !llvm.x86_fp80
// CHECK: %{{.*}} = llvm.fpext %[[FLOAT]] : !llvm.float to !llvm.fp128
Allow '_' when pretty printing dialect symbols '_' is used frequently enough as the separator of words in symbols. We should allow it in dialect symbols when considering pretty printing. Also updated LangRef.md regarding pretty form. PiperOrigin-RevId: 275312494
2019-10-18 03:23:47 +08:00
%27 = llvm.fpext %arg1 : !llvm.float to !llvm.x86_fp80
Add LLVM IR dialect hooks for FP128 and X86_FP80 types Closes tensorflow/mlir#184 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/184 from schweitzpgi:more-float-types ca27d00510a86ffc9c79c65fb3a0193b5ea097a0 PiperOrigin-RevId: 274288813
2019-10-12 09:35:02 +08:00
%28 = llvm.fpext %arg1 : !llvm.float to !llvm.fp128
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %{{.*}} = llvm.fneg %[[FLOAT]] : !llvm.float
Add support for the LLVM FNeg instruction Closes tensorflow/mlir#216 COPYBARA_INTEGRATE_REVIEW=https://github.com/tensorflow/mlir/pull/216 from schweitzpgi:llvmir-fneg-op f9b5f185845d671b745ab6fc213d5d9aff044b34 PiperOrigin-RevId: 278795325
2019-11-06 15:39:25 +08:00
%29 = llvm.fneg %arg1 : !llvm.float
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: "llvm.intr.sin"(%[[FLOAT]]) : (!llvm.float) -> !llvm.float
[mlir][StandardToLLVM] Add SinOp to LLVM dialect and lowering of std.sin to this op. Differential Revision: https://reviews.llvm.org/D79505
2020-05-13 14:04:33 +08:00
%30 = "llvm.intr.sin"(%arg1) : (!llvm.float) -> !llvm.float
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: "llvm.intr.pow"(%[[FLOAT]], %[[FLOAT]]) : (!llvm.float, !llvm.float) -> !llvm.float
Added pow intrinsic to LLVMIR dialect Added pow intrinsic to LLVMIR dialect. Added a roundrip test for it. Differential Revision: https://reviews.llvm.org/D80248
2020-05-25 19:42:17 +08:00
%31 = "llvm.intr.pow"(%arg1, %arg1) : (!llvm.float, !llvm.float) -> !llvm.float
[MLIR][LLVMDialect] Added bitreverse and ctpop intrinsics Introduced `llvm.intr.bitreverse` and `llvm.intr.ctpop` LLVM bit intrinsics to LLVM dialect. These intrinsics help with SPIR-V to LLVM conversion, allowing a direct mapping from `spv.BitReverse` and `spv.BitCount` respectively. Tests are added to `roundtrip.mlir` and `llvm-intrinsics.mlir`. Differential Revision: https://reviews.llvm.org/D82285
2020-06-24 02:20:42 +08:00
// CHECK: "llvm.intr.bitreverse"(%{{.*}}) : (!llvm.i32) -> !llvm.i32
%32 = "llvm.intr.bitreverse"(%arg0) : (!llvm.i32) -> !llvm.i32
// CHECK: "llvm.intr.ctpop"(%{{.*}}) : (!llvm.i32) -> !llvm.i32
%33 = "llvm.intr.ctpop"(%arg0) : (!llvm.i32) -> !llvm.i32
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> ()
"llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> ()
[mlir] support returning unranked memrefs Initially, unranked memref descriptors in the LLVM dialect were designed only to be passed into functions. An assertion was guarding against returning unranked memrefs from functions in the standard-to-LLVM conversion. This is insufficient for functions that wish to return an unranked memref such that the caller does not know the rank in advance, and hence cannot allocate the descriptor and pass it in as an argument. Introduce a calling convention for returning unranked memref descriptors as follows. An unranked memref descriptor always points to a ranked memref descriptor stored on stack of the current function. When an unranked memref descriptor is returned from a function, the ranked memref descriptor it points to is copied to dynamically allocated memory, the ownership of which is transferred to the caller. The caller is responsible for deallocating the dynamically allocated memory and for copying the pointed-to ranked memref descriptor onto its stack. Provide default lowerings for std.return, std.call and std.indirect_call that maintain the conversion defined above. This convention is additionally exercised by a runtime test to guard against memory errors. Differential Revision: https://reviews.llvm.org/D82647
2020-06-26 20:34:00 +08:00
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> ()
"llvm.intr.memcpy"(%arg2, %arg3, %arg0, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i32, !llvm.i1) -> ()
[mlir] support returning unranked memrefs Initially, unranked memref descriptors in the LLVM dialect were designed only to be passed into functions. An assertion was guarding against returning unranked memrefs from functions in the standard-to-LLVM conversion. This is insufficient for functions that wish to return an unranked memref such that the caller does not know the rank in advance, and hence cannot allocate the descriptor and pass it in as an argument. Introduce a calling convention for returning unranked memref descriptors as follows. An unranked memref descriptor always points to a ranked memref descriptor stored on stack of the current function. When an unranked memref descriptor is returned from a function, the ranked memref descriptor it points to is copied to dynamically allocated memory, the ownership of which is transferred to the caller. The caller is responsible for deallocating the dynamically allocated memory and for copying the pointed-to ranked memref descriptor onto its stack. Provide default lowerings for std.return, std.call and std.indirect_call that maintain the conversion defined above. This convention is additionally exercised by a runtime test to guard against memory errors. Differential Revision: https://reviews.llvm.org/D82647
2020-06-26 20:34:00 +08:00
// CHECK: %[[SZ:.*]] = llvm.mlir.constant
%sz = llvm.mlir.constant(10: i64) : !llvm.i64
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i64, !llvm.i1) -> ()
"llvm.intr.memcpy.inline"(%arg2, %arg3, %sz, %arg4) : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.i64, !llvm.i1) -> ()
[mlir] support returning unranked memrefs Initially, unranked memref descriptors in the LLVM dialect were designed only to be passed into functions. An assertion was guarding against returning unranked memrefs from functions in the standard-to-LLVM conversion. This is insufficient for functions that wish to return an unranked memref such that the caller does not know the rank in advance, and hence cannot allocate the descriptor and pass it in as an argument. Introduce a calling convention for returning unranked memref descriptors as follows. An unranked memref descriptor always points to a ranked memref descriptor stored on stack of the current function. When an unranked memref descriptor is returned from a function, the ranked memref descriptor it points to is copied to dynamically allocated memory, the ownership of which is transferred to the caller. The caller is responsible for deallocating the dynamically allocated memory and for copying the pointed-to ranked memref descriptor onto its stack. Provide default lowerings for std.return, std.call and std.indirect_call that maintain the conversion defined above. This convention is additionally exercised by a runtime test to guard against memory errors. Differential Revision: https://reviews.llvm.org/D82647
2020-06-26 20:34:00 +08:00
Add LLVM::IntToPtrOp and LLVM::PtrToIntOp to LLVM dialect. -- PiperOrigin-RevId: 249604199
2019-05-23 17:03:14 +08:00
// CHECK: llvm.return
Introduce custom format for the LLVM IR Dialect Historically, the LLVM IR dialect has been using the generic form of MLIR operation syntax. It is verbose and often redundant. Introduce the custom printing and parsing for all existing operations in the LLVM IR dialect. Update the relevant documentation and tests. -- PiperOrigin-RevId: 241617393
2019-04-03 06:33:54 +08:00
llvm.return
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
}
// An larger self-contained function.
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK-LABEL: llvm.func @foo(%{{.*}}: !llvm.i32) -> !llvm.struct<(i32, double, i32)> {
llvm.func @foo(%arg0: !llvm.i32) -> !llvm.struct<(i32, double, i32)> {
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %[[V0:.*]] = llvm.mlir.constant(3 : i64) : !llvm.i32
// CHECK: %[[V1:.*]] = llvm.mlir.constant(3 : i64) : !llvm.i32
// CHECK: %[[V2:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double
// CHECK: %[[V3:.*]] = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double
// CHECK: %[[V4:.*]] = llvm.add %[[V0]], %[[V1]] : !llvm.i32
// CHECK: %[[V5:.*]] = llvm.mul %[[V4]], %[[V1]] : !llvm.i32
// CHECK: %[[V6:.*]] = llvm.fadd %[[V2]], %[[V3]] : !llvm.double
// CHECK: %[[V7:.*]] = llvm.fsub %[[V3]], %[[V6]] : !llvm.double
// CHECK: %[[V8:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i1
// CHECK: llvm.cond_br %[[V8]], ^[[BB1:.*]](%[[V4]] : !llvm.i32), ^[[BB2:.*]](%[[V4]] : !llvm.i32)
LLVM dialect: prefix auxiliary operations with "mlir." Some of the operations in the LLVM dialect are required to model the LLVM IR in MLIR, for example "constant" operations are needed to declare a constant value since MLIR, unlike LLVM, does not support immediate values as operands. To avoid confusion with actual LLVM operations, we prefix such axuiliary operations with "mlir.". PiperOrigin-RevId: 266942838
2019-09-04 00:10:24 +08:00
%0 = llvm.mlir.constant(3) : !llvm.i32
%1 = llvm.mlir.constant(3) : !llvm.i32
%2 = llvm.mlir.constant(4.200000e+01) : !llvm.double
%3 = llvm.mlir.constant(4.200000e+01) : !llvm.double
Change the asmprinter to use pretty syntax for dialect types when it can, making the IR dumps much nicer. This is part 2/3 of the path to making dialect types more nice. Part 3/3 will slightly generalize the set of characters allowed in pretty types and make it more principled. -- PiperOrigin-RevId: 242249955
2019-04-06 14:56:49 +08:00
%4 = llvm.add %0, %1 : !llvm.i32
%5 = llvm.mul %4, %1 : !llvm.i32
%6 = llvm.fadd %2, %3 : !llvm.double
%7 = llvm.fsub %3, %6 : !llvm.double
LLVM dialect: prefix auxiliary operations with "mlir." Some of the operations in the LLVM dialect are required to model the LLVM IR in MLIR, for example "constant" operations are needed to declare a constant value since MLIR, unlike LLVM, does not support immediate values as operands. To avoid confusion with actual LLVM operations, we prefix such axuiliary operations with "mlir.". PiperOrigin-RevId: 266942838
2019-09-04 00:10:24 +08:00
%8 = llvm.mlir.constant(1) : !llvm.i1
Change the asmprinter to use pretty syntax for dialect types when it can, making the IR dumps much nicer. This is part 2/3 of the path to making dialect types more nice. Part 3/3 will slightly generalize the set of characters allowed in pretty types and make it more principled. -- PiperOrigin-RevId: 242249955
2019-04-06 14:56:49 +08:00
llvm.cond_br %8, ^bb1(%4 : !llvm.i32), ^bb2(%4 : !llvm.i32)
Introduce custom format for the LLVM IR Dialect Historically, the LLVM IR dialect has been using the generic form of MLIR operation syntax. It is verbose and often redundant. Introduce the custom printing and parsing for all existing operations in the LLVM IR dialect. Update the relevant documentation and tests. -- PiperOrigin-RevId: 241617393
2019-04-03 06:33:54 +08:00
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK:^[[BB1]](%[[V9:.*]]: !llvm.i32):
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %[[V10:.*]] = llvm.call @foo(%[[V9]]) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
// CHECK: %[[V11:.*]] = llvm.extractvalue %[[V10]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V12:.*]] = llvm.extractvalue %[[V10]][1] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V13:.*]] = llvm.extractvalue %[[V10]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V14:.*]] = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V15:.*]] = llvm.insertvalue %[[V5]], %[[V14]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V16:.*]] = llvm.insertvalue %[[V7]], %[[V15]][1] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V17:.*]] = llvm.insertvalue %[[V11]], %[[V16]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: llvm.return %[[V17]] : !llvm.struct<(i32, double, i32)>
Change the asmprinter to use pretty syntax for dialect types when it can, making the IR dumps much nicer. This is part 2/3 of the path to making dialect types more nice. Part 3/3 will slightly generalize the set of characters allowed in pretty types and make it more principled. -- PiperOrigin-RevId: 242249955
2019-04-06 14:56:49 +08:00
^bb1(%9: !llvm.i32):
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
%10 = llvm.call @foo(%9) : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
%11 = llvm.extractvalue %10[0] : !llvm.struct<(i32, double, i32)>
%12 = llvm.extractvalue %10[1] : !llvm.struct<(i32, double, i32)>
%13 = llvm.extractvalue %10[2] : !llvm.struct<(i32, double, i32)>
%14 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
%15 = llvm.insertvalue %5, %14[0] : !llvm.struct<(i32, double, i32)>
%16 = llvm.insertvalue %7, %15[1] : !llvm.struct<(i32, double, i32)>
%17 = llvm.insertvalue %11, %16[2] : !llvm.struct<(i32, double, i32)>
llvm.return %17 : !llvm.struct<(i32, double, i32)>
Introduce custom format for the LLVM IR Dialect Historically, the LLVM IR dialect has been using the generic form of MLIR operation syntax. It is verbose and often redundant. Introduce the custom printing and parsing for all existing operations in the LLVM IR dialect. Update the relevant documentation and tests. -- PiperOrigin-RevId: 241617393
2019-04-03 06:33:54 +08:00
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK:^[[BB2]](%[[V18:.*]]: !llvm.i32):
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %[[V19:.*]] = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V20:.*]] = llvm.insertvalue %[[V18]], %[[V19]][0] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V21:.*]] = llvm.insertvalue %[[V7]], %[[V20]][1] : !llvm.struct<(i32, double, i32)>
// CHECK: %[[V22:.*]] = llvm.insertvalue %[[V5]], %[[V21]][2] : !llvm.struct<(i32, double, i32)>
// CHECK: llvm.return %[[V22]] : !llvm.struct<(i32, double, i32)>
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
^bb2(%18: !llvm.i32):
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
%19 = llvm.mlir.undef : !llvm.struct<(i32, double, i32)>
%20 = llvm.insertvalue %18, %19[0] : !llvm.struct<(i32, double, i32)>
%21 = llvm.insertvalue %7, %20[1] : !llvm.struct<(i32, double, i32)>
%22 = llvm.insertvalue %5, %21[2] : !llvm.struct<(i32, double, i32)>
llvm.return %22 : !llvm.struct<(i32, double, i32)>
Initial version of the LLVM IR dialect LLVM IR types are defined using MLIR's extendable type system. The dialect provides the only type kind, LLVMType, that wraps an llvm::Type*. Since LLVM IR types are pointer-unique, MLIR type systems relies on those pointers to perform its own type unique'ing. Type parsing and printing is delegated to LLVM libraries. Define MLIR operations for the LLVM IR instructions currently used by the translation to the LLVM IR Target to simplify eventual transition. Operations classes are defined using TableGen. LLVM IR instruction operands that are only allowed to take constant values are accepted as attributes instead. All operations are using verbose form for printing and parsing. PiperOrigin-RevId: 229400375
2019-01-16 02:53:22 +08:00
}
Introduce std.index_cast and its lowering+translation to LLVM Index types integers of platform-specific bit width. They are used to index memrefs and as loop induction variables, however they could not be obtained from an integer until now, making it virtually impossible to express indirect accesses (given that memrefs of indices are not allowed) or data-dependent loops. Introduce `std.index_cast` to transform indices into integers and vice versa. The semantics of this cast is to sign-extend when casting to a wider integer, and to truncate when casting to a narrower integer. It belongs to StandardOps because both types it operates on are standard types, and because its results are likely to be used in std.load and std.store. Introduce llvm.sext, llvm.zext and llvm.trunc operations to the LLVM dialect. Provide the conversion of `std.index_cast` to llvm.sext or llvm.trunc, depending on the actual bitwidth of `index` known during the conversion. PiperOrigin-RevId: 253624100
2019-06-18 02:35:05 +08:00
// CHECK-LABEL: @casts
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK-SAME: (%[[I32:.*]]: !llvm.i32, %[[I64:.*]]: !llvm.i64, %[[V4I32:.*]]: !llvm.vec<4 x i32>, %[[V4I64:.*]]: !llvm.vec<4 x i64>, %[[I32PTR:.*]]: !llvm.ptr<i32>)
func @casts(%arg0: !llvm.i32, %arg1: !llvm.i64, %arg2: !llvm.vec<4 x i32>,
%arg3: !llvm.vec<4 x i64>, %arg4: !llvm.ptr<i32>) {
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: = llvm.sext %[[I32]] : !llvm.i32 to !llvm.i56
Introduce std.index_cast and its lowering+translation to LLVM Index types integers of platform-specific bit width. They are used to index memrefs and as loop induction variables, however they could not be obtained from an integer until now, making it virtually impossible to express indirect accesses (given that memrefs of indices are not allowed) or data-dependent loops. Introduce `std.index_cast` to transform indices into integers and vice versa. The semantics of this cast is to sign-extend when casting to a wider integer, and to truncate when casting to a narrower integer. It belongs to StandardOps because both types it operates on are standard types, and because its results are likely to be used in std.load and std.store. Introduce llvm.sext, llvm.zext and llvm.trunc operations to the LLVM dialect. Provide the conversion of `std.index_cast` to llvm.sext or llvm.trunc, depending on the actual bitwidth of `index` known during the conversion. PiperOrigin-RevId: 253624100
2019-06-18 02:35:05 +08:00
%0 = llvm.sext %arg0 : !llvm.i32 to !llvm.i56
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: = llvm.zext %[[I32]] : !llvm.i32 to !llvm.i64
Introduce std.index_cast and its lowering+translation to LLVM Index types integers of platform-specific bit width. They are used to index memrefs and as loop induction variables, however they could not be obtained from an integer until now, making it virtually impossible to express indirect accesses (given that memrefs of indices are not allowed) or data-dependent loops. Introduce `std.index_cast` to transform indices into integers and vice versa. The semantics of this cast is to sign-extend when casting to a wider integer, and to truncate when casting to a narrower integer. It belongs to StandardOps because both types it operates on are standard types, and because its results are likely to be used in std.load and std.store. Introduce llvm.sext, llvm.zext and llvm.trunc operations to the LLVM dialect. Provide the conversion of `std.index_cast` to llvm.sext or llvm.trunc, depending on the actual bitwidth of `index` known during the conversion. PiperOrigin-RevId: 253624100
2019-06-18 02:35:05 +08:00
%1 = llvm.zext %arg0 : !llvm.i32 to !llvm.i64
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: = llvm.trunc %[[I64]] : !llvm.i64 to !llvm.i56
Introduce std.index_cast and its lowering+translation to LLVM Index types integers of platform-specific bit width. They are used to index memrefs and as loop induction variables, however they could not be obtained from an integer until now, making it virtually impossible to express indirect accesses (given that memrefs of indices are not allowed) or data-dependent loops. Introduce `std.index_cast` to transform indices into integers and vice versa. The semantics of this cast is to sign-extend when casting to a wider integer, and to truncate when casting to a narrower integer. It belongs to StandardOps because both types it operates on are standard types, and because its results are likely to be used in std.load and std.store. Introduce llvm.sext, llvm.zext and llvm.trunc operations to the LLVM dialect. Provide the conversion of `std.index_cast` to llvm.sext or llvm.trunc, depending on the actual bitwidth of `index` known during the conversion. PiperOrigin-RevId: 253624100
2019-06-18 02:35:05 +08:00
%2 = llvm.trunc %arg1 : !llvm.i64 to !llvm.i56
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: = llvm.sext %[[V4I32]] : !llvm.vec<4 x i32> to !llvm.vec<4 x i56>
%3 = llvm.sext %arg2 : !llvm.vec<4 x i32> to !llvm.vec<4 x i56>
// CHECK: = llvm.zext %[[V4I32]] : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
%4 = llvm.zext %arg2 : !llvm.vec<4 x i32> to !llvm.vec<4 x i64>
// CHECK: = llvm.trunc %[[V4I64]] : !llvm.vec<4 x i64> to !llvm.vec<4 x i56>
%5 = llvm.trunc %arg3 : !llvm.vec<4 x i64> to !llvm.vec<4 x i56>
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: = llvm.sitofp %[[I32]] : !llvm.i32 to !llvm.float
[mlir][llvm] Add missing cast ops Also adds a builder method for fcmp, identical to that for icmp. PiperOrigin-RevId: 277923158
2019-11-01 22:31:33 +08:00
%6 = llvm.sitofp %arg0 : !llvm.i32 to !llvm.float
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %[[FLOAT:.*]] = llvm.uitofp %[[I32]] : !llvm.i32 to !llvm.float
[mlir][llvm] Add missing cast ops Also adds a builder method for fcmp, identical to that for icmp. PiperOrigin-RevId: 277923158
2019-11-01 22:31:33 +08:00
%7 = llvm.uitofp %arg0 : !llvm.i32 to !llvm.float
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: = llvm.fptosi %[[FLOAT]] : !llvm.float to !llvm.i32
[mlir][llvm] Add missing cast ops Also adds a builder method for fcmp, identical to that for icmp. PiperOrigin-RevId: 277923158
2019-11-01 22:31:33 +08:00
%8 = llvm.fptosi %7 : !llvm.float to !llvm.i32
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: = llvm.fptoui %[[FLOAT]] : !llvm.float to !llvm.i32
[mlir][llvm] Add missing cast ops Also adds a builder method for fcmp, identical to that for icmp. PiperOrigin-RevId: 277923158
2019-11-01 22:31:33 +08:00
%9 = llvm.fptoui %7 : !llvm.float to !llvm.i32
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: = llvm.addrspacecast %[[I32PTR]] : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
%10 = llvm.addrspacecast %arg4 : !llvm.ptr<i32> to !llvm.ptr<i32, 2>
Introduce std.index_cast and its lowering+translation to LLVM Index types integers of platform-specific bit width. They are used to index memrefs and as loop induction variables, however they could not be obtained from an integer until now, making it virtually impossible to express indirect accesses (given that memrefs of indices are not allowed) or data-dependent loops. Introduce `std.index_cast` to transform indices into integers and vice versa. The semantics of this cast is to sign-extend when casting to a wider integer, and to truncate when casting to a narrower integer. It belongs to StandardOps because both types it operates on are standard types, and because its results are likely to be used in std.load and std.store. Introduce llvm.sext, llvm.zext and llvm.trunc operations to the LLVM dialect. Provide the conversion of `std.index_cast` to llvm.sext or llvm.trunc, depending on the actual bitwidth of `index` known during the conversion. PiperOrigin-RevId: 253624100
2019-06-18 02:35:05 +08:00
llvm.return
}
Add support for vector ops in the LLVM dialect This CL is step 1/n towards building a simple, programmable and portable vector abstraction in MLIR that can go all the way down to generating assembly vector code via LLVM's opt and llc tools. This CL adds the 3 instructions `llvm.extractelement`, `llvm.insertelement` and `llvm.shufflevector` as documented in the LLVM LangRef "Vector Instructions" section. The "Experimental Vector Reduction Intrinsics" are left out for now and can be added in the future on a per-need basis. Appropriate roundtrip and LLVM Target tests are added. PiperOrigin-RevId: 262542095
2019-08-09 20:24:47 +08:00
// CHECK-LABEL: @vect
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
func @vect(%arg0: !llvm.vec<4 x float>, %arg1: !llvm.i32, %arg2: !llvm.float) {
// CHECK: = llvm.extractelement {{.*}} : !llvm.vec<4 x float>
%0 = llvm.extractelement %arg0[%arg1 : !llvm.i32] : !llvm.vec<4 x float>
// CHECK: = llvm.insertelement {{.*}} : !llvm.vec<4 x float>
%1 = llvm.insertelement %arg2, %arg0[%arg1 : !llvm.i32] : !llvm.vec<4 x float>
// CHECK: = llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float>
%2 = llvm.shufflevector %arg0, %arg0 [0 : i32, 0 : i32, 0 : i32, 0 : i32, 7 : i32] : !llvm.vec<4 x float>, !llvm.vec<4 x float>
// CHECK: = llvm.mlir.constant(dense<1.000000e+00> : vector<4xf32>) : !llvm.vec<4 x float>
%3 = llvm.mlir.constant(dense<1.0> : vector<4xf32>) : !llvm.vec<4 x float>
Add support for vector ops in the LLVM dialect This CL is step 1/n towards building a simple, programmable and portable vector abstraction in MLIR that can go all the way down to generating assembly vector code via LLVM's opt and llc tools. This CL adds the 3 instructions `llvm.extractelement`, `llvm.insertelement` and `llvm.shufflevector` as documented in the LLVM LangRef "Vector Instructions" section. The "Experimental Vector Reduction Intrinsics" are left out for now and can be added in the future on a per-need basis. Appropriate roundtrip and LLVM Target tests are added. PiperOrigin-RevId: 262542095
2019-08-09 20:24:47 +08:00
return
}
Add alignment support for llvm.alloca Extend the LLVM dialect AllocaOp with an alignment attribute. PiperOrigin-RevId: 264068306
2019-08-19 09:54:50 +08:00
// CHECK-LABEL: @alloca
func @alloca(%size : !llvm.i64) {
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: llvm.alloca %{{.*}} x !llvm.i32 : (!llvm.i64) -> !llvm.ptr<i32>
llvm.alloca %size x !llvm.i32 {alignment = 0} : (!llvm.i64) -> (!llvm.ptr<i32>)
// CHECK: llvm.alloca %{{.*}} x !llvm.i32 {alignment = 8 : i64} : (!llvm.i64) -> !llvm.ptr<i32>
llvm.alloca %size x !llvm.i32 {alignment = 8} : (!llvm.i64) -> (!llvm.ptr<i32>)
Add alignment support for llvm.alloca Extend the LLVM dialect AllocaOp with an alignment attribute. PiperOrigin-RevId: 264068306
2019-08-19 09:54:50 +08:00
llvm.return
}
LLVM Dialect: introduce llvm.mlir.null operation Similarly to `llvm.mlir.undef`, this auxiliary operation creates an SSA value that corresponds to `null` in LLVM IR. This operation is necessary to model sizeof(<...>) behavior when allocating memory. PiperOrigin-RevId: 274158760
2019-10-11 21:13:25 +08:00
// CHECK-LABEL: @null
func @null() {
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: llvm.mlir.null : !llvm.ptr<i8>
%0 = llvm.mlir.null : !llvm.ptr<i8>
// CHECK: llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
%1 = llvm.mlir.null : !llvm.ptr<struct<(ptr<func<void (i32, ptr<func<void ()>>)>>, i64)>>
LLVM Dialect: introduce llvm.mlir.null operation Similarly to `llvm.mlir.undef`, this auxiliary operation creates an SSA value that corresponds to `null` in LLVM IR. This operation is necessary to model sizeof(<...>) behavior when allocating memory. PiperOrigin-RevId: 274158760
2019-10-11 21:13:25 +08:00
llvm.return
}
[MLIR] LLVM dialect: Add llvm.atomicrmw Summary: This op is the counterpart to LLVM's atomicrmw instruction. Note that volatile and syncscope attributes are not yet supported. This will be useful for upcoming parallel versions of `affine.for` and generally for reduction-like semantics. Differential Revision: https://reviews.llvm.org/D72741
2020-01-18 04:09:53 +08:00
[MLIR] LLVM Dialect: add llvm.cmpxchg and improve llvm.atomicrmw custom parser Summary: Add a `llvm.cmpxchg` op as a counterpart to LLVM IR's `cmpxchg` instruction. Note that the `weak`, `volatile`, and `syncscope` attributes are not yet supported. This will be useful for upcoming parallel versions of affine.for and generally for reduction-like semantics (especially for reductions that can't make use of `atomicrmw`, e.g. `fmax`). Reviewers: ftynse, nicolasvasilache Reviewed By: ftynse Subscribers: merge_guards_bot, jfb, mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D72995
2020-01-21 16:22:01 +08:00
// CHECK-LABEL: @atomicrmw
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
func @atomicrmw(%ptr : !llvm.ptr<float>, %val : !llvm.float) {
[MLIR] LLVM Dialect: add llvm.cmpxchg and improve llvm.atomicrmw custom parser Summary: Add a `llvm.cmpxchg` op as a counterpart to LLVM IR's `cmpxchg` instruction. Note that the `weak`, `volatile`, and `syncscope` attributes are not yet supported. This will be useful for upcoming parallel versions of affine.for and generally for reduction-like semantics (especially for reductions that can't make use of `atomicrmw`, e.g. `fmax`). Reviewers: ftynse, nicolasvasilache Reviewed By: ftynse Subscribers: merge_guards_bot, jfb, mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, arpith-jacob, mgester, lucyrfox, liufengdb, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D72995
2020-01-21 16:22:01 +08:00
// CHECK: llvm.atomicrmw fadd %{{.*}}, %{{.*}} unordered : !llvm.float
%0 = llvm.atomicrmw fadd %ptr, %val unordered : !llvm.float
llvm.return
}
// CHECK-LABEL: @cmpxchg
[mlir] do not use llvm.cmpxchg with floats According to the LLVM Language Reference, 'cmpxchg' accepts integer or pointer types. Several MLIR tests were using it with floats as it appears possible to programmatically construct and print such an instruction, but it cannot be parsed back. Use integers instead. Depends On D85899 Reviewed By: flaub, rriddle Differential Revision: https://reviews.llvm.org/D85900
2020-08-13 20:46:31 +08:00
func @cmpxchg(%ptr : !llvm.ptr<i32>, %cmp : !llvm.i32, %new : !llvm.i32) {
// CHECK: llvm.cmpxchg %{{.*}}, %{{.*}}, %{{.*}} acq_rel monotonic : !llvm.i32
%0 = llvm.cmpxchg %ptr, %cmp, %new acq_rel monotonic : !llvm.i32
[MLIR] LLVM dialect: Add llvm.atomicrmw Summary: This op is the counterpart to LLVM's atomicrmw instruction. Note that volatile and syncscope attributes are not yet supported. This will be useful for upcoming parallel versions of `affine.for` and generally for reduction-like semantics. Differential Revision: https://reviews.llvm.org/D72741
2020-01-18 04:09:53 +08:00
llvm.return
}
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
llvm.mlir.global external constant @_ZTIi() : !llvm.ptr<i8>
llvm.func @bar(!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>)
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
llvm.func @__gxx_personality_v0(...) -> !llvm.i32
// CHECK-LABEL: @invokeLandingpad
[mlir] Added llvm.resume and personality functions in LLVM IR Dialect `llvm.resume` is similar to `llvm.return` except that has to be exactly one operand and that should be derived from a `llvm.landingpad` instruction. Any function having `llvm.landingpad` instruction must have a personality attribute. Example: LLVM IR ``` define dso_local i32 @main() personality i32 (...)* @__gxx_personality_v0 { invoke void @foo(i32 42) to label %3 unwind label %1 1: ; preds = %0 %2 = landingpad i8* catch i8** @_ZTIi catch i8* bitcast (i8** @_ZTIi to i8*) resume i8* %2 3: ; preds = %0 ret i32 1 } ``` MLIR - LLVM IR Dialect ``` llvm.func @main() -> !llvm.i32 attributes {personality = @__gxx_personality_v0} { %0 = llvm.mlir.constant(1 : i32) : !llvm.i32 %1 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %2 = llvm.bitcast %1 : !llvm<"i8**"> to !llvm<"i8*"> %3 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %4 = llvm.mlir.constant(42 : i32) : !llvm.i32 llvm.invoke @foo(%4) to ^bb2 unwind ^bb1 : (!llvm.i32) -> () ^bb1: // pred: ^bb0 %5 = llvm.landingpad (catch %3 : !llvm<"i8**">) (catch %2 : !llvm<"i8*">) : !llvm<"i8*"> llvm.resume %5 : !llvm<"i8*"> ^bb2: // pred: ^bb0 llvm.return %0 : !llvm.i32 } ``` Differential Revision: https://reviews.llvm.org/D71888
2020-03-19 20:09:31 +08:00
llvm.func @invokeLandingpad() -> !llvm.i32 attributes { personality = @__gxx_personality_v0 } {
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %[[a0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
// CHECK: %{{.*}} = llvm.mlir.constant(3 : i32) : !llvm.i32
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %[[a2:.*]] = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
// CHECK: %[[a3:.*]] = llvm.mlir.null : !llvm.ptr<ptr<i8>>
// CHECK: %[[a4:.*]] = llvm.mlir.null : !llvm.ptr<i8>
// CHECK: %[[a5:.*]] = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
// CHECK: %[[a6:.*]] = llvm.bitcast %[[a5]] : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: %[[a7:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %[[a8:.*]] = llvm.alloca %[[a7]] x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8>
// CHECK: %{{.*}} = llvm.invoke @foo(%[[a7]]) to ^[[BB2:.*]] unwind ^[[BB1:.*]] : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
%0 = llvm.mlir.constant(0 : i32) : !llvm.i32
%1 = llvm.mlir.constant(3 : i32) : !llvm.i32
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
%2 = llvm.mlir.constant("\01") : !llvm.array<1 x i8>
%3 = llvm.mlir.null : !llvm.ptr<ptr<i8>>
%4 = llvm.mlir.null : !llvm.ptr<i8>
%5 = llvm.mlir.addressof @_ZTIi : !llvm.ptr<ptr<i8>>
%6 = llvm.bitcast %5 : !llvm.ptr<ptr<i8>> to !llvm.ptr<i8>
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
%7 = llvm.mlir.constant(1 : i32) : !llvm.i32
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
%8 = llvm.alloca %7 x !llvm.i8 : (!llvm.i32) -> !llvm.ptr<i8>
%9 = llvm.invoke @foo(%7) to ^bb2 unwind ^bb1 : (!llvm.i32) -> !llvm.struct<(i32, double, i32)>
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: ^[[BB1]]:
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: %[[lp:.*]] = llvm.landingpad cleanup (catch %[[a3]] : !llvm.ptr<ptr<i8>>) (catch %[[a6]] : !llvm.ptr<i8>) (filter %[[a2]] : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
// CHECK: llvm.resume %[[lp]] : !llvm.struct<(ptr<i8>, i32)>
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
^bb1:
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
%10 = llvm.landingpad cleanup (catch %3 : !llvm.ptr<ptr<i8>>) (catch %6 : !llvm.ptr<i8>) (filter %2 : !llvm.array<1 x i8>) : !llvm.struct<(ptr<i8>, i32)>
llvm.resume %10 : !llvm.struct<(ptr<i8>, i32)>
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: ^[[BB2]]:
// CHECK: llvm.return %[[a7]] : !llvm.i32
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
^bb2:
llvm.return %7 : !llvm.i32
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: ^[[BB3:.*]]:
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
// CHECK: llvm.invoke @bar(%[[a8]], %[[a6]], %[[a4]]) to ^[[BB2]] unwind ^[[BB1]] : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
^bb3:
[mlir] switch the modeling of LLVM types to use the new mechanism A new first-party modeling for LLVM IR types in the LLVM dialect has been developed in parallel to the existing modeling based on wrapping LLVM `Type *` instances. It resolves the long-standing problem of modeling identified structure types, including recursive structures, and enables future removal of LLVMContext and related locking mechanisms from LLVMDialect. This commit only switches the modeling by (a) renaming LLVMTypeNew to LLVMType, (b) removing the old implementaiton of LLVMType, and (c) updating the tests. It is intentionally minimal. Separate commits will remove the infrastructure built for the transition and update API uses where appropriate. Depends On D85020 Reviewed By: rriddle Differential Revision: https://reviews.llvm.org/D85021
2020-08-04 17:37:50 +08:00
llvm.invoke @bar(%8, %6, %4) to ^bb2 unwind ^bb1 : (!llvm.ptr<i8>, !llvm.ptr<i8>, !llvm.ptr<i8>) -> ()
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: ^[[BB4:.*]]:
// CHECK: llvm.return %[[a0]] : !llvm.i32
[MLIR] Added llvm.invoke and llvm.landingpad Summary: I have tried to implement `llvm.invoke` and `llvm.landingpad`. # `llvm.invoke` is similar to `llvm.call` with two successors added, the first one is the normal label and the second one is unwind label. # `llvm.launchpad` takes a variable number of args with either `catch` or `filter` associated with them. Catch clauses are not array types and filter clauses are array types. This is same as the criteria used by LLVM (https://github.com/llvm/llvm-project/blob/4f82af81a04d711721300f6ca32f402f2ea6faf4/llvm/include/llvm/IR/Instructions.h#L2866) Examples: LLVM IR ``` define i32 @caller(i32 %a) personality i8* bitcast (i32 (...)* @__gxx_personality_v0 to i8*) { invoke i32 @foo(i32 2) to label %success unwind label %fail success: ret i32 2 fail: landingpad {i8*, i32} catch i8** @_ZTIi catch i8** null catch i8* bitcast (i8** @_ZTIi to i8*) filter [1 x i8] [ i8 1 ] ret i32 3 } ``` MLIR LLVM Dialect ``` llvm.func @caller(%arg0: !llvm.i32) -> !llvm.i32 { %0 = llvm.mlir.constant(3 : i32) : !llvm.i32 %1 = llvm.mlir.constant("\01") : !llvm<"[1 x i8]"> %2 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %3 = llvm.bitcast %2 : !llvm<"i8**"> to !llvm<"i8*"> %4 = llvm.mlir.null : !llvm<"i8**"> %5 = llvm.mlir.addressof @_ZTIi : !llvm<"i8**"> %6 = llvm.mlir.constant(2 : i32) : !llvm.i32 %7 = llvm.invoke @foo(%6) to ^bb1 unwind ^bb2 : (!llvm.i32) -> !llvm.i32 ^bb1: // pred: ^bb0 llvm.return %6 : !llvm.i32 ^bb2: // pred: ^bb0 %8 = llvm.landingpad (catch %5 : !llvm<"i8**">) (catch %4 : !llvm<"i8**">) (catch %3 : !llvm<"i8*">) (filter %1 : !llvm<"[1 x i8]">) : !llvm<"{ i8*, i32 }"> llvm.return %0 : !llvm.i32 } ``` Signed-off-by: Shraiysh Vaishay <cs17btech11050@iith.ac.in> Differential Revision: https://reviews.llvm.org/D72006
2020-01-30 19:50:12 +08:00
^bb4:
llvm.return %0 : !llvm.i32
}
[MLIR] Added llvm.freeze This patch adds llvm.freeze & processes undef constants from LLVM IR. Syntax: LLVM IR `<result> = freeze ty <val>` MLIR LLVM Dialect: `llvm.freeze val attr-dict : type` Example: LLVM IR: `%3 = freeze i32 5` MLIR: `%6 = llvm.freeze %5 : !llvm.i32` Differential Revision: https://reviews.llvm.org/D75329
2020-03-02 17:19:57 +08:00
// CHECK-LABEL: @useFreezeOp
func @useFreezeOp(%arg0: !llvm.i32) {
// CHECK: = llvm.freeze %[[ARG0:.*]] : !llvm.i32
%0 = llvm.freeze %arg0 : !llvm.i32
// CHECK: %[[x:.*]] = llvm.mlir.undef : !llvm.i8
%1 = llvm.mlir.undef : !llvm.i8
// CHECK: = llvm.freeze %[[x]] : !llvm.i8
%2 = llvm.freeze %1 : !llvm.i8
return
[MLIR] Added llvm.fence This patch adds llvm.fence. I tried not to change the syntax much. syntax: LLVM IR `fence [syncscope("<target-scope>")] <ordering>` MLIR LLVM Dialect `llvm.fence [syncscope("<target-scope>")] <ordering>` example: LLVM IR: `fence syncscope("agent") seq_cst` MLIR: `llvm.fence syncscope("agent") seq_cst` Differential Revision: https://reviews.llvm.org/D75645
2020-03-18 00:43:21 +08:00
}
// CHECK-LABEL: @useFenceInst
func @useFenceInst() {
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: syncscope("agent") seq_cst
[MLIR] Added llvm.fence This patch adds llvm.fence. I tried not to change the syntax much. syntax: LLVM IR `fence [syncscope("<target-scope>")] <ordering>` MLIR LLVM Dialect `llvm.fence [syncscope("<target-scope>")] <ordering>` example: LLVM IR: `fence syncscope("agent") seq_cst` MLIR: `llvm.fence syncscope("agent") seq_cst` Differential Revision: https://reviews.llvm.org/D75645
2020-03-18 00:43:21 +08:00
llvm.fence syncscope("agent") seq_cst
[mlir] Modernize LLVM dialect rountrip test This test largely predates MLIR testing guidelines. Update it to match the guidelines. In particular, avoid pattern-matching SSA value names, avoid unnecessary CHECK-NEXT, relax assumptions about the form of SSA names. Value-returning operations are still matched agaist _any_ name in order to check that the operation indeed produces values. Differential Revision: https://reviews.llvm.org/D82656
2020-06-26 21:27:46 +08:00
// CHECK: seq_cst
[MLIR] Added llvm.fence This patch adds llvm.fence. I tried not to change the syntax much. syntax: LLVM IR `fence [syncscope("<target-scope>")] <ordering>` MLIR LLVM Dialect `llvm.fence [syncscope("<target-scope>")] <ordering>` example: LLVM IR: `fence syncscope("agent") seq_cst` MLIR: `llvm.fence syncscope("agent") seq_cst` Differential Revision: https://reviews.llvm.org/D75645
2020-03-18 00:43:21 +08:00
llvm.fence syncscope("") seq_cst
// CHECK: release
llvm.fence release
return
[mlir] support returning unranked memrefs Initially, unranked memref descriptors in the LLVM dialect were designed only to be passed into functions. An assertion was guarding against returning unranked memrefs from functions in the standard-to-LLVM conversion. This is insufficient for functions that wish to return an unranked memref such that the caller does not know the rank in advance, and hence cannot allocate the descriptor and pass it in as an argument. Introduce a calling convention for returning unranked memref descriptors as follows. An unranked memref descriptor always points to a ranked memref descriptor stored on stack of the current function. When an unranked memref descriptor is returned from a function, the ranked memref descriptor it points to is copied to dynamically allocated memory, the ownership of which is transferred to the caller. The caller is responsible for deallocating the dynamically allocated memory and for copying the pointed-to ranked memref descriptor onto its stack. Provide default lowerings for std.return, std.call and std.indirect_call that maintain the conversion defined above. This convention is additionally exercised by a runtime test to guard against memory errors. Differential Revision: https://reviews.llvm.org/D82647
2020-06-26 20:34:00 +08:00
}