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
This commit is contained in:
Alex Zinenko 2019-09-03 09:10:24 -07:00 committed by A. Unique TensorFlower
parent da646505c5
commit c335d9d313
18 changed files with 288 additions and 284 deletions

View File

@ -210,7 +210,7 @@ func @bar() {
func @foo(%arg0: !llvm.type<"i32">, %arg1: !llvm.type<"i64">) -> !llvm.type<"{i32, i64}"> {
// insert the vales into a structure
%0 = llvm.undef : !llvm.type<"{i32, i64}">
%0 = llvm.mlir.undef : !llvm.type<"{i32, i64}">
%1 = llvm.insertvalue %arg0, %0[0] : !llvm.type<"{i32, i64}">
%2 = llvm.insertvalue %arg1, %1[1] : !llvm.type<"{i32, i64}">
@ -218,8 +218,8 @@ func @foo(%arg0: !llvm.type<"i32">, %arg1: !llvm.type<"i64">) -> !llvm.type<"{i3
llvm.return %2 : !llvm.type<"{i32, i64}">
}
func @bar() {
%0 = llvm.constant(42 : i32) : !llvm.type<"i32">
%1 = llvm.constant(17) : !llvm.type<"i64">
%0 = llvm.mlir.constant(42 : i32) : !llvm.type<"i32">
%1 = llvm.mlir.constant(17) : !llvm.type<"i64">
// call and extract the values from the structure
%2 = llvm.call @bar(%0, %1) : (%arg0: !llvm.type<"i32">, %arg1: !llvm.type<"i64">) -> !llvm.type<"{i32, i64}">
@ -327,15 +327,15 @@ is transformed into the equivalent of the following code:
%b = llvm.extractvalue %m[0] : !llvm.type<"{float*, i64, i64}">
// obtain the components for the index
%sub1 = llvm.constant(1) : !llvm.type<"i64"> // first subscript
%sub1 = llvm.mlir.constant(1) : !llvm.type<"i64"> // first subscript
%sz2 = llvm.extractvalue %m[1]
: !llvm.type<"{float*, i64, i64}"> // second size (dynamic, second descriptor element)
%sub2 = llvm.constant(2) : !llvm.type<"i64"> // second subscript
%sz3 = llvm.constant(13) : !llvm.type<"i64"> // third size (static)
%sub3 = llvm.constant(3) : !llvm.type<"i64"> // third subscript
%sub2 = llvm.mlir.constant(2) : !llvm.type<"i64"> // second subscript
%sz3 = llvm.mlir.constant(13) : !llvm.type<"i64"> // third size (static)
%sub3 = llvm.mlir.constant(3) : !llvm.type<"i64"> // third subscript
%sz4 = llvm.extractvalue %m[1]
: !llvm.type<"{float*, i64, i64}"> // fourth size (dynamic, third descriptor element)
%sub4 = llvm.constant(4) : !llvm.type<"i64"> // fourth subscript
%sub4 = llvm.mlir.constant(4) : !llvm.type<"i64"> // fourth subscript
// compute the linearized index
// %sub4 + %sub3 * %sz4 + %sub2 * (%sz3 * %sz4) + %sub1 * (%sz2 * %sz3 * %sz4) =

View File

@ -119,16 +119,16 @@ Examples:
```mlir {.mlir}
// Allocate an array of 4 floats on stack
%c4 = llvm.constant(4) : !llvm.i64
%c4 = llvm.mlir.constant(4) : !llvm.i64
%0 = llvm.alloca %c4 x !llvm.float : (!llvm.i64) -> !llvm<"float*">
// Get the second element of the array (note 0-based indexing).
%c1 = llvm.constant(1) : !llvm.i64
%c1 = llvm.mlir.constant(1) : !llvm.i64
%1 = llvm.getelementptr %0[%c1] : (!llvm<"float*">, !llvm.i64)
-> !llvm<"float*">
// Store a constant into this element.
%cf = llvm.constant(42.0 : f32) : !llvm.float
%cf = llvm.mlir.constant(42.0 : f32) : !llvm.float
llvm.store %cf, %1 : !llvm<"float*">
// Load the value from this element.
@ -250,39 +250,39 @@ Bitwise reinterpretation: `bitcast <value>`.
Selection: `select <condition>, <lhs>, <rhs>`.
### Pseudo-operations
### Auxiliary MLIR operations
These operations do not have LLVM IR counterparts but are necessary to map LLVM
IR into MLIR.
IR into MLIR. They should be prefixed with `llvm.mlir`.
#### `llvm.addressof`
#### `llvm.mlir.addressof`
Creates an SSA value containing a pointer to a global variable or constant
defined by `llvm.global`. The global value can be defined after its first
referenced. If the global value is a constant, storing into it is not allowed.
defined by `llvm.mlir.global`. The global value can be defined after its first
referenced. If the global value is a constant, storing into it is not allowed.
Examples:
```mlir {.mlir}
func @foo() {
// Get the address of a global.
%0 = llvm.addressof @const : !llvm<"i32*">
%0 = llvm.mlir.addressof @const : !llvm<"i32*">
// Use it as a regular pointer.
%1 = llvm.load %0 : !llvm<"i32*">
}
// Define the global.
llvm.global @const(42 : i32) : !llvm.i32
llvm.mlir.global @const(42 : i32) : !llvm.i32
```
#### `llvm.constant`
#### `llvm.mlir.constant`
Unlike LLVM IR, MLIR does not have first-class constant values. Therefore, all
constants must be created as SSA values before being used in other operations.
`llvm.constant` creates such values for scalars and vectors. It has a mandatory
`value` attribute, which may be an integer, floating point attribute; splat,
dense or sparse attribute containing integers or floats. The type of the
`llvm.mlir.constant` creates such values for scalars and vectors. It has a
mandatory `value` attribute, which may be an integer, floating point attribute;
splat, dense or sparse attribute containing integers or floats. The type of the
attribute is one the corresponding MLIR standard types. It may be omitted for
`i64` and `f64` types that are implied. The operation produces a new SSA value
of the specified LLVM IR dialect type. The type of that value _must_ correspond
@ -292,56 +292,57 @@ Examples:
```mlir {.mlir}
// Integer constant, internal i32 is mandatory
%0 = llvm.constant(42 : i32) : !llvm.i32
%0 = llvm.mlir.constant(42 : i32) : !llvm.i32
// It's okay to omit i64.
%1 = llvm.constant(42) : !llvm.i64
%1 = llvm.mlir.constant(42) : !llvm.i64
// Floating point constant.
%2 = llvm.constant(42.0 : f32) : !llvm.float
%2 = llvm.mlir.constant(42.0 : f32) : !llvm.float
// Splat vector constant,.
%3 = llvm.constant(splat<vector<4xf32>, 1.0>) : !llvm<"<4 x float>">
%3 = llvm.mlir.constant(splat<vector<4xf32>, 1.0>) : !llvm<"<4 x float>">
```
#### `llvm.global`
#### `llvm.mlir.global`
Since MLIR allows for arbitrary operations to be present at the top level,
global variables are defined using the `llvm.global` operation. Both global
global variables are defined using the `llvm.mlir.global` operation. Both global
constants and variables can be defined, and the value must be initialized in
both cases. The initialization and type syntax is similar to `llvm.constant` and
may use two types: one for MLIR attribute and another for the LLVM value. These
types must be compatible. `llvm.global` must appear at top-level of the
enclosing module. It uses an @-identifier for its value, which will be uniqued
by the module with respect to other @-identifiers in it.
both cases. The initialization and type syntax is similar to
`llvm.mlir.constant` and may use two types: one for MLIR attribute and another
for the LLVM value. These types must be compatible. `llvm.mlir.global` must
appear at top-level of the enclosing module. It uses an @-identifier for its
value, which will be uniqued by the module with respect to other @-identifiers
in it.
Examples:
```mlir {.mlir}
// Global values use @-identifiers.
llvm.global constant @cst(42 : i32) : !llvm.i32
llvm.mlir.global constant @cst(42 : i32) : !llvm.i32
// Non-constant values must also be initialized.
llvm.global @variable(32.0 : f32) : !llvm.float
llvm.mlir.global @variable(32.0 : f32) : !llvm.float
// Strings are expected to be of wrapped LLVM i8 array type and do not
// automatically include the trailing zero.
llvm.global @string("abc") : !llvm<"[3 x i8]">
llvm.mlir.global @string("abc") : !llvm<"[3 x i8]">
// For strings globals, the trailing type may be omitted.
llvm.global constant @no_trailing_type("foo bar")
llvm.mlir.global constant @no_trailing_type("foo bar")
```
#### `llvm.undef`
#### `llvm.mlir.undef`
Unlike LLVM IR, MLIR does not have first-class undefined values. Such values
must be created as SSA values using `llvm.undef`. This operation has no operands
or attributes. It creates an undefined value of the specified LLVM IR dialect
type wrapping an LLVM IR structure type.
must be created as SSA values using `llvm.mlir.undef`. This operation has no
operands or attributes. It creates an undefined value of the specified LLVM IR
dialect type wrapping an LLVM IR structure type.
Example:
```mlir {.mlir}
// Create a structure with a 32-bit integer followed by a float.
%0 = llvm.undef : !llvm<"{i32, float}">
%0 = llvm.mlir.undef : !llvm<"{i32, float}">
```

View File

@ -201,26 +201,26 @@ Note the mix of a loop nest in the `Affine` dialect, with an operation
%90 = llvm.icmp "slt" %89, %88 : !llvm.i64
llvm.cond_br %90, ^bb2, ^bb6
^bb2: // pred: ^bb1
%91 = llvm.constant(0 : index) : !llvm.i64
%92 = llvm.constant(2 : index) : !llvm.i64
%91 = llvm.mlir.constant(0 : index) : !llvm.i64
%92 = llvm.mlir.constant(2 : index) : !llvm.i64
llvm.br ^bb3(%91 : !llvm.i64)
^bb3(%93: !llvm.i64): // 2 preds: ^bb2, ^bb4
%94 = llvm.icmp "slt" %93, %92 : !llvm.i64
llvm.cond_br %94, ^bb4, ^bb5
^bb4: // pred: ^bb3
%95 = llvm.constant(2 : index) : !llvm.i64
%96 = llvm.constant(2 : index) : !llvm.i64
%95 = llvm.mlir.constant(2 : index) : !llvm.i64
%96 = llvm.mlir.constant(2 : index) : !llvm.i64
%97 = llvm.mul %89, %96 : !llvm.i64
%98 = llvm.add %97, %93 : !llvm.i64
%99 = llvm.getelementptr %6[%98] : (!llvm<"double*">, !llvm.i64) -> !llvm<"double*">
%100 = llvm.load %99 : !llvm<"double*">
%101 = llvm.call @printf(%48, %100) : (!llvm<"i8*">, !llvm.double) -> !llvm.i32
%102 = llvm.constant(1 : index) : !llvm.i64
%102 = llvm.mlir.constant(1 : index) : !llvm.i64
%103 = llvm.add %93, %102 : !llvm.i64
llvm.br ^bb3(%103 : !llvm.i64)
^bb5: // pred: ^bb3
%104 = llvm.call @printf(%76, %71) : (!llvm<"i8*">, !llvm.double) -> !llvm.i32
%105 = llvm.constant(1 : index) : !llvm.i64
%105 = llvm.mlir.constant(1 : index) : !llvm.i64
%106 = llvm.add %89, %105 : !llvm.i64
llvm.br ^bb1(%106 : !llvm.i64)
```

View File

@ -442,10 +442,10 @@ def LLVM_UnreachableOp : LLVM_TerminatorOp<"unreachable", []> {
let printer = [{ *p << getOperationName(); }];
}
// Pseudo-operations (do not appear in LLVM IR but necessary for the dialect to
// work correctly).
// Auxiliary operations (do not appear in LLVM IR but necessary for the dialect
// to work correctly).
def LLVM_AddressOfOp
: LLVM_OneResultOp<"addressof">,
: LLVM_OneResultOp<"mlir.addressof">,
Arguments<(ins SymbolRefAttr:$global_name)> {
let builders = [
OpBuilder<"Builder *builder, OperationState *result, LLVMType resType, "
@ -461,7 +461,8 @@ def LLVM_AddressOfOp
];
let extraClassDeclaration = [{
/// Return the llvm.global operation that defined the value referenced here.
/// Return the llvm.mlir.global operation that defined the value referenced
/// here.
GlobalOp getGlobal();
}];
@ -471,7 +472,7 @@ def LLVM_AddressOfOp
}
def LLVM_GlobalOp
: LLVM_ZeroResultOp<"global">,
: LLVM_ZeroResultOp<"mlir.global">,
Arguments<(ins TypeAttr:$type, UnitAttr:$constant, StrAttr:$sym_name,
AnyAttr:$value)> {
@ -534,13 +535,13 @@ def LLVM_LLVMFuncOp : LLVM_ZeroResultOp<"func",
}];
}
def LLVM_UndefOp : LLVM_OneResultOp<"undef", [NoSideEffect]>,
def LLVM_UndefOp : LLVM_OneResultOp<"mlir.undef", [NoSideEffect]>,
LLVM_Builder<"$res = llvm::UndefValue::get($_resultType);"> {
let parser = [{ return parseUndefOp(parser, result); }];
let printer = [{ printUndefOp(p, *this); }];
}
def LLVM_ConstantOp
: LLVM_OneResultOp<"constant", [NoSideEffect]>,
: LLVM_OneResultOp<"mlir.constant", [NoSideEffect]>,
Arguments<(ins AnyAttr:$value)>,
LLVM_Builder<"$res = getLLVMConstant($_resultType, $value, $_location);">
{

View File

@ -89,7 +89,7 @@ private:
ModuleOp mlirModule;
std::unique_ptr<llvm::Module> llvmModule;
// Mappings between llvm.global definitions and corresponding globals.
// Mappings between llvm.mlir.global definitions and corresponding globals.
llvm::DenseMap<Operation *, llvm::GlobalValue *> globalsMapping;
protected:

View File

@ -779,7 +779,7 @@ static void printUndefOp(OpAsmPrinter *p, UndefOp &op) {
*p << " : " << op.res()->getType();
}
// <operation> ::= `llvm.undef` attribute-dict? : type
// <operation> ::= `llvm.mlir.undef` attribute-dict? : type
static ParseResult parseUndefOp(OpAsmParser *parser, OperationState *result) {
Type type;
@ -825,7 +825,8 @@ static ParseResult parseAddressOfOp(OpAsmParser *parser,
static LogicalResult verify(AddressOfOp op) {
auto global = op.getGlobal();
if (!global)
return op.emitOpError("must reference a global defined by 'llvm.global'");
return op.emitOpError(
"must reference a global defined by 'llvm.mlir.global'");
if (global.getType().getPointerTo() != op.getResult()->getType())
return op.emitOpError(
@ -844,7 +845,7 @@ static void printConstantOp(OpAsmPrinter *p, ConstantOp &op) {
*p << " : " << op.res()->getType();
}
// <operation> ::= `llvm.constant` `(` attribute `)` attribute-list? : type
// <operation> ::= `llvm.mlir.constant` `(` attribute `)` attribute-list? : type
static ParseResult parseConstantOp(OpAsmParser *parser,
OperationState *result) {
Attribute valueAttr;
@ -894,8 +895,8 @@ static void printGlobalOp(OpAsmPrinter *p, GlobalOp op) {
p->printType(op.type());
}
// <operation> ::= `llvm.global` `constant`? `@` identifier `(` attribute `)`
// attribute-list? (`:` type)?
// <operation> ::= `llvm.mlir.global` `constant`? `@` identifier
// `(` attribute `)` attribute-list? (`:` type)?
//
// The type can be omitted for string attributes, in which case it will be
// inferred from the value of the string as [strlen(value) x i8].

View File

@ -297,7 +297,8 @@ LogicalResult ModuleTranslation::convertBlock(Block &bb, bool ignoreArguments) {
return success();
}
// Create named global variables that correspond to llvm.global definitions.
// Create named global variables that correspond to llvm.mlir.global
// definitions.
void ModuleTranslation::convertGlobals() {
for (auto op : mlirModule.getOps<LLVM::GlobalOp>()) {
llvm::Constant *cst;

View File

@ -1,14 +1,14 @@
// RUN: mlir-opt %s --generate-cubin-accessors | FileCheck %s
// CHECK: llvm.global constant @[[global:.*]]("CUBIN")
// CHECK: llvm.mlir.global constant @[[global:.*]]("CUBIN")
func @kernel(!llvm.float, !llvm<"float*">)
// CHECK: attributes {gpu.kernel, nvvm.cubin = "CUBIN", nvvm.cubingetter = @[[getter:.*]]}
attributes {gpu.kernel, nvvm.cubin = "CUBIN"}
// CHECK: func @[[getter]]() -> !llvm<"i8*">
// CHECK: %[[addressof:.*]] = llvm.addressof @[[global]]
// CHECK: %[[c0:.*]] = llvm.constant(0 : index)
// CHECK: %[[addressof:.*]] = llvm.mlir.addressof @[[global]]
// CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index)
// CHECK: %[[gep:.*]] = llvm.getelementptr %[[addressof]][%[[c0]], %[[c0]]]
// CHECK-SAME: -> !llvm<"i8*">
// CHECK: llvm.return %[[gep]] : !llvm<"i8*">

View File

@ -1,6 +1,6 @@
// RUN: mlir-opt %s --launch-func-to-cuda | FileCheck %s
// CHECK: llvm.global constant @[[kernel_name:.*]]("kernel\00")
// CHECK: llvm.mlir.global constant @[[kernel_name:.*]]("kernel\00")
func @cubin_getter() -> !llvm<"i8*">

View File

@ -5,7 +5,7 @@ func @outerproduct(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<2x3xf32
return %2 : vector<2x3xf32>
}
// CHECK-LABEL: outerproduct
// CHECK: llvm.undef : !llvm<"[2 x <3 x float>]">
// CHECK: llvm.mlir.undef : !llvm<"[2 x <3 x float>]">
// CHECK: llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32] : !llvm<"<2 x float>">, !llvm<"<2 x float>">
// CHECK: llvm.fmul {{.*}}, {{.*}} : !llvm<"<3 x float>">
// CHECK: llvm.insertvalue {{.*}}[0] : !llvm<"[2 x <3 x float>]">
@ -19,7 +19,7 @@ func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector
return %2 : vector<2x3xf32>
}
// CHECK-LABEL: outerproduct_add
// CHECK: llvm.undef : !llvm<"[2 x <3 x float>]">
// CHECK: llvm.mlir.undef : !llvm<"[2 x <3 x float>]">
// CHECK: llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32] : !llvm<"<2 x float>">, !llvm<"<2 x float>">
// CHECK: llvm.extractvalue {{.*}}[0] : !llvm<"[2 x <3 x float>]">
// CHECK: "llvm.intr.fmuladd"({{.*}}) : (!llvm<"<3 x float>">, !llvm<"<3 x float>">, !llvm<"<3 x float>">) -> !llvm<"<3 x float>">
@ -44,6 +44,6 @@ func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 {
}
// CHECK-LABEL: extract_element_from_vec_3d
// CHECK: llvm.extractvalue %{{.*}}[0 : i32, 0 : i32] : !llvm<"[4 x [3 x <16 x float>]]">
// CHECK: llvm.constant(0 : i32) : !llvm.i32
// CHECK: llvm.mlir.constant(0 : i32) : !llvm.i32
// CHECK: llvm.extractelement %{{.*}}, %{{.*}} : !llvm<"<16 x float>">
// CHECK: llvm.return %{{.*}} : !llvm.float

View File

@ -53,7 +53,7 @@ func @rangeConversion(%arg0: index, %arg1: index, %arg2: index) {
return
}
// LLVM-LABEL: @rangeConversion
// LLVM-NEXT: %0 = llvm.undef : !llvm<"{ i64, i64, i64 }">
// LLVM-NEXT: %0 = llvm.mlir.undef : !llvm<"{ i64, i64, i64 }">
// LLVM-NEXT: %1 = llvm.insertvalue %arg0, %0[0] : !llvm<"{ i64, i64, i64 }">
// LLVM-NEXT: %2 = llvm.insertvalue %arg1, %1[1] : !llvm<"{ i64, i64, i64 }">
// LLVM-NEXT: %3 = llvm.insertvalue %arg2, %2[2] : !llvm<"{ i64, i64, i64 }">
@ -63,13 +63,13 @@ func @viewRangeConversion(%arg0: memref<?x?xf32>, %arg1: !linalg.range, %arg2: !
return
}
// LLVM-LABEL: @viewRangeConversion
// LLVM-NEXT: %0 = llvm.undef : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM-NEXT: %0 = llvm.mlir.undef : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM-NEXT: %1 = llvm.extractvalue %arg0[0] : !llvm<"{ float*, i64, i64 }">
// LLVM-NEXT: %2 = llvm.insertvalue %1, %0[0] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM-NEXT: %3 = llvm.extractvalue %arg0[2] : !llvm<"{ float*, i64, i64 }">
// LLVM-NEXT: %4 = llvm.constant(1 : index) : !llvm.i64
// LLVM-NEXT: %4 = llvm.mlir.constant(1 : index) : !llvm.i64
// LLVM-NEXT: %5 = llvm.mul %4, %3 : !llvm.i64
// LLVM-NEXT: %6 = llvm.constant(0 : index) : !llvm.i64
// LLVM-NEXT: %6 = llvm.mlir.constant(0 : index) : !llvm.i64
// LLVM-NEXT: %7 = llvm.extractvalue %arg1[0] : !llvm<"{ i64, i64, i64 }">
// LLVM-NEXT: %8 = llvm.mul %7, %5 : !llvm.i64
// LLVM-NEXT: %9 = llvm.add %6, %8 : !llvm.i64
@ -97,13 +97,13 @@ func @viewNonRangeConversion(%arg0: memref<?x?xf32>, %arg1: !linalg.range, %arg2
return
}
// LLVM-LABEL: @viewNonRangeConversion
// LLVM-NEXT: %0 = llvm.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// LLVM-NEXT: %0 = llvm.mlir.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// LLVM-NEXT: %1 = llvm.extractvalue %arg0[0] : !llvm<"{ float*, i64, i64 }">
// LLVM-NEXT: %2 = llvm.insertvalue %1, %0[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// LLVM-NEXT: %3 = llvm.extractvalue %arg0[2] : !llvm<"{ float*, i64, i64 }">
// LLVM-NEXT: %4 = llvm.constant(1 : index) : !llvm.i64
// LLVM-NEXT: %4 = llvm.mlir.constant(1 : index) : !llvm.i64
// LLVM-NEXT: %5 = llvm.mul %4, %3 : !llvm.i64
// LLVM-NEXT: %6 = llvm.constant(0 : index) : !llvm.i64
// LLVM-NEXT: %6 = llvm.mlir.constant(0 : index) : !llvm.i64
// LLVM-NEXT: %7 = llvm.extractvalue %arg1[0] : !llvm<"{ i64, i64, i64 }">
// LLVM-NEXT: %8 = llvm.mul %7, %5 : !llvm.i64
// LLVM-NEXT: %9 = llvm.add %6, %8 : !llvm.i64
@ -124,7 +124,7 @@ func @sliceRangeConversion(%arg0: memref<?x?xf32>, %arg1: !linalg.range, %arg2:
return
}
// LLVM-LABEL: @sliceRangeConversion
// LLVM: %28 = llvm.undef : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM: %28 = llvm.mlir.undef : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM-NEXT: %29 = llvm.extractvalue %27[0] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM-NEXT: %30 = llvm.insertvalue %29, %28[0] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM-NEXT: %31 = llvm.extractvalue %27[1] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
@ -152,7 +152,7 @@ func @sliceNonRangeConversion2(%arg0: memref<?x?xf32>, %arg1: !linalg.range, %ar
return
}
// LLVM-LABEL: @sliceNonRangeConversion2
// LLVM: %28 = llvm.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// LLVM: %28 = llvm.mlir.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// LLVM-NEXT: %29 = llvm.extractvalue %27[0] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// LLVM-NEXT: %30 = llvm.insertvalue %29, %28[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// LLVM-NEXT: %31 = llvm.extractvalue %27[1] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">

View File

@ -34,7 +34,7 @@ func @body(i32)
// CHECK-LABEL: func @indirect_const_call(%arg0: !llvm.i32) {
func @indirect_const_call(%arg0: i32) {
// CHECK-NEXT: %0 = llvm.constant(@body) : !llvm<"void (i32)*">
// CHECK-NEXT: %0 = llvm.mlir.constant(@body) : !llvm<"void (i32)*">
%0 = constant @body : (i32) -> ()
// CHECK-NEXT: llvm.call %0(%arg0) : (!llvm.i32) -> ()
call_indirect %0(%arg0) : (i32) -> ()

View File

@ -14,8 +14,8 @@ func @check_static_return(%static : memref<32x18xf32>) -> memref<32x18xf32> {
// CHECK-LABEL: func @zero_d_alloc() -> !llvm<"float*"> {
func @zero_d_alloc() -> memref<f32> {
// CHECK-NEXT: %0 = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.mlir.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mul %0, %1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.call @malloc(%2) : (!llvm.i64) -> !llvm<"i8*">
// CHECK-NEXT: %4 = llvm.bitcast %3 : !llvm<"i8*"> to !llvm<"float*">
@ -33,14 +33,14 @@ func @zero_d_dealloc(%arg0: memref<f32>) {
// CHECK-LABEL: func @mixed_alloc(%arg0: !llvm.i64, %arg1: !llvm.i64) -> !llvm<"{ float*, i64, i64 }"> {
func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> {
// CHECK-NEXT: %0 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.mul %arg0, %0 : !llvm.i64
// CHECK-NEXT: %2 = llvm.mul %1, %arg1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.mlir.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %4 = llvm.mul %2, %3 : !llvm.i64
// CHECK-NEXT: %5 = llvm.call @malloc(%4) : (!llvm.i64) -> !llvm<"i8*">
// CHECK-NEXT: %6 = llvm.bitcast %5 : !llvm<"i8*"> to !llvm<"float*">
// CHECK-NEXT: %7 = llvm.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %7 = llvm.mlir.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %8 = llvm.insertvalue %6, %7[0 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %9 = llvm.insertvalue %arg0, %8[1 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %10 = llvm.insertvalue %arg1, %9[2 : index] : !llvm<"{ float*, i64, i64 }">
@ -61,11 +61,11 @@ func @mixed_dealloc(%arg0: memref<?x42x?xf32>) {
// CHECK-LABEL: func @dynamic_alloc(%arg0: !llvm.i64, %arg1: !llvm.i64) -> !llvm<"{ float*, i64, i64 }"> {
func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> {
// CHECK-NEXT: %0 = llvm.mul %arg0, %arg1 : !llvm.i64
// CHECK-NEXT: %1 = llvm.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.mlir.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mul %0, %1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.call @malloc(%2) : (!llvm.i64) -> !llvm<"i8*">
// CHECK-NEXT: %4 = llvm.bitcast %3 : !llvm<"i8*"> to !llvm<"float*">
// CHECK-NEXT: %5 = llvm.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %5 = llvm.mlir.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %6 = llvm.insertvalue %4, %5[0 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %7 = llvm.insertvalue %arg0, %6[1 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %8 = llvm.insertvalue %arg1, %7[2 : index] : !llvm<"{ float*, i64, i64 }">
@ -84,10 +84,10 @@ func @dynamic_dealloc(%arg0: memref<?x?xf32>) {
// CHECK-LABEL: func @static_alloc() -> !llvm<"float*"> {
func @static_alloc() -> memref<32x18xf32> {
// CHECK-NEXT: %0 = llvm.constant(32 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.constant(18 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(32 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.mlir.constant(18 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mul %0, %1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.mlir.constant(4 : index) : !llvm.i64
// CHECK-NEXT: %4 = llvm.mul %2, %3 : !llvm.i64
// CHECK-NEXT: %5 = llvm.call @malloc(%4) : (!llvm.i64) -> !llvm<"i8*">
// CHECK-NEXT: %6 = llvm.bitcast %5 : !llvm<"i8*"> to !llvm<"float*">
@ -112,8 +112,8 @@ func @zero_d_load(%arg0: memref<f32>) -> f32 {
// CHECK-LABEL: func @static_load
func @static_load(%static : memref<10x42xf32>, %i : index, %j : index) {
// CHECK-NEXT: %0 = llvm.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mul %arg1, %1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.add %2, %arg2 : !llvm.i64
// CHECK-NEXT: %4 = llvm.getelementptr %arg0[%3] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
@ -124,7 +124,7 @@ func @static_load(%static : memref<10x42xf32>, %i : index, %j : index) {
// CHECK-LABEL: func @mixed_load
func @mixed_load(%mixed : memref<42x?xf32>, %i : index, %j : index) {
// CHECK-NEXT: %0 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.extractvalue %arg0[1 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %2 = llvm.mul %arg1, %1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.add %2, %arg2 : !llvm.i64
@ -157,8 +157,8 @@ func @zero_d_store(%arg0: memref<f32>, %arg1: f32) {
// CHECK-LABEL: func @static_store
func @static_store(%static : memref<10x42xf32>, %i : index, %j : index, %val : f32) {
// CHECK-NEXT: %0 = llvm.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mul %arg1, %1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.add %2, %arg2 : !llvm.i64
// CHECK-NEXT: %4 = llvm.getelementptr %arg0[%3] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
@ -182,7 +182,7 @@ func @dynamic_store(%dynamic : memref<?x?xf32>, %i : index, %j : index, %val : f
// CHECK-LABEL: func @mixed_store
func @mixed_store(%mixed : memref<42x?xf32>, %i : index, %j : index, %val : f32) {
// CHECK-NEXT: %0 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.extractvalue %arg0[1 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %2 = llvm.mul %arg1, %1 : !llvm.i64
// CHECK-NEXT: %3 = llvm.add %2, %arg2 : !llvm.i64
@ -195,11 +195,11 @@ func @mixed_store(%mixed : memref<42x?xf32>, %i : index, %j : index, %val : f32)
// CHECK-LABEL: func @memref_cast_static_to_dynamic
func @memref_cast_static_to_dynamic(%static : memref<10x42xf32>) {
// CHECK-NEXT: %0 = llvm.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %0 = llvm.mlir.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %1 = llvm.insertvalue %arg0, %0[0 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %2 = llvm.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mlir.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.insertvalue %2, %1[1 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %4 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %4 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %5 = llvm.insertvalue %4, %3[2 : index] : !llvm<"{ float*, i64, i64 }">
%0 = memref_cast %static : memref<10x42xf32> to memref<?x?xf32>
return
@ -207,9 +207,9 @@ func @memref_cast_static_to_dynamic(%static : memref<10x42xf32>) {
// CHECK-LABEL: func @memref_cast_static_to_mixed
func @memref_cast_static_to_mixed(%static : memref<10x42xf32>) {
// CHECK-NEXT: %0 = llvm.undef : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %0 = llvm.mlir.undef : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %1 = llvm.insertvalue %arg0, %0[0 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %2 = llvm.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mlir.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.insertvalue %2, %1[1 : index] : !llvm<"{ float*, i64 }">
%0 = memref_cast %static : memref<10x42xf32> to memref<?x42xf32>
return
@ -225,7 +225,7 @@ func @memref_cast_dynamic_to_static(%dynamic : memref<?x?xf32>) {
// CHECK-LABEL: func @memref_cast_dynamic_to_mixed
func @memref_cast_dynamic_to_mixed(%dynamic : memref<?x?xf32>) {
// CHECK-NEXT: %0 = llvm.extractvalue %arg0[0 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %1 = llvm.undef : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %1 = llvm.mlir.undef : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %2 = llvm.insertvalue %0, %1[0 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %3 = llvm.extractvalue %arg0[1 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %4 = llvm.insertvalue %3, %2[1 : index] : !llvm<"{ float*, i64 }">
@ -236,9 +236,9 @@ func @memref_cast_dynamic_to_mixed(%dynamic : memref<?x?xf32>) {
// CHECK-LABEL: func @memref_cast_mixed_to_dynamic
func @memref_cast_mixed_to_dynamic(%mixed : memref<42x?xf32>) {
// CHECK-NEXT: %0 = llvm.extractvalue %arg0[0 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %1 = llvm.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %1 = llvm.mlir.undef : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %2 = llvm.insertvalue %0, %1[0 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %3 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %4 = llvm.insertvalue %3, %2[1 : index] : !llvm<"{ float*, i64, i64 }">
// CHECK-NEXT: %5 = llvm.extractvalue %arg0[1 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %6 = llvm.insertvalue %5, %4[2 : index] : !llvm<"{ float*, i64, i64 }">
@ -256,9 +256,9 @@ func @memref_cast_mixed_to_static(%mixed : memref<42x?xf32>) {
// CHECK-LABEL: func @memref_cast_mixed_to_mixed
func @memref_cast_mixed_to_mixed(%mixed : memref<42x?xf32>) {
// CHECK-NEXT: %0 = llvm.extractvalue %arg0[0 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %1 = llvm.undef : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %1 = llvm.mlir.undef : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %2 = llvm.insertvalue %0, %1[0 : index] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %3 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %4 = llvm.insertvalue %3, %2[1 : index] : !llvm<"{ float*, i64 }">
%0 = memref_cast %mixed : memref<42x?xf32> to memref<?x1xf32>
return
@ -266,13 +266,13 @@ func @memref_cast_mixed_to_mixed(%mixed : memref<42x?xf32>) {
// CHECK-LABEL: func @mixed_memref_dim(%arg0: !llvm<"{ float*, i64, i64, i64 }">)
func @mixed_memref_dim(%mixed : memref<42x?x?x13x?xf32>) {
// CHECK-NEXT: %0 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(42 : index) : !llvm.i64
%0 = dim %mixed, 0 : memref<42x?x?x13x?xf32>
// CHECK-NEXT: %1 = llvm.extractvalue %arg0[1 : index] : !llvm<"{ float*, i64, i64, i64 }">
%1 = dim %mixed, 1 : memref<42x?x?x13x?xf32>
// CHECK-NEXT: %2 = llvm.extractvalue %arg0[2 : index] : !llvm<"{ float*, i64, i64, i64 }">
%2 = dim %mixed, 2 : memref<42x?x?x13x?xf32>
// CHECK-NEXT: %3 = llvm.constant(13 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.mlir.constant(13 : index) : !llvm.i64
%3 = dim %mixed, 3 : memref<42x?x?x13x?xf32>
// CHECK-NEXT: %4 = llvm.extractvalue %arg0[3 : index] : !llvm<"{ float*, i64, i64, i64 }">
%4 = dim %mixed, 4 : memref<42x?x?x13x?xf32>
@ -281,15 +281,15 @@ func @mixed_memref_dim(%mixed : memref<42x?x?x13x?xf32>) {
// CHECK-LABEL: func @static_memref_dim(%arg0: !llvm<"float*">)
func @static_memref_dim(%static : memref<42x32x15x13x27xf32>) {
// CHECK-NEXT: %0 = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %0 = llvm.mlir.constant(42 : index) : !llvm.i64
%0 = dim %static, 0 : memref<42x32x15x13x27xf32>
// CHECK-NEXT: %1 = llvm.constant(32 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.mlir.constant(32 : index) : !llvm.i64
%1 = dim %static, 1 : memref<42x32x15x13x27xf32>
// CHECK-NEXT: %2 = llvm.constant(15 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.mlir.constant(15 : index) : !llvm.i64
%2 = dim %static, 2 : memref<42x32x15x13x27xf32>
// CHECK-NEXT: %3 = llvm.constant(13 : index) : !llvm.i64
// CHECK-NEXT: %3 = llvm.mlir.constant(13 : index) : !llvm.i64
%3 = dim %static, 3 : memref<42x32x15x13x27xf32>
// CHECK-NEXT: %4 = llvm.constant(27 : index) : !llvm.i64
// CHECK-NEXT: %4 = llvm.mlir.constant(27 : index) : !llvm.i64
%4 = dim %static, 4 : memref<42x32x15x13x27xf32>
return
}

View File

@ -18,8 +18,8 @@ func @simple_loop() {
br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
^bb1: // pred: ^bb0
%c1 = constant 1 : index
@ -35,7 +35,7 @@ func @simple_loop() {
// CHECK: ^bb3: // pred: ^bb2
// CHECK-NEXT: llvm.call @body({{.*}}) : (!llvm.i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
^bb3: // pred: ^bb2
@ -78,7 +78,7 @@ func @body_args(index) -> index
func @other(index, i32) -> i32
// CHECK-LABEL: func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 {
// CHECK-NEXT: {{.*}} = llvm.constant(0 : i32) : !llvm.i32
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : i32) : !llvm.i32
// CHECK-NEXT: llvm.br ^bb1
func @func_args(i32, i32) -> i32 {
^bb0(%arg0: i32, %arg1: i32):
@ -86,8 +86,8 @@ func @func_args(i32, i32) -> i32 {
br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
^bb1: // pred: ^bb0
%c0 = constant 0 : index
@ -106,7 +106,7 @@ func @func_args(i32, i32) -> i32 {
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg0) : (!llvm.i64, !llvm.i32) -> !llvm.i32
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i32) -> !llvm.i32
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, %arg1) : (!llvm.i64, !llvm.i32) -> !llvm.i32
// CHECK-NEXT: {{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
^bb3: // pred: ^bb2
@ -119,7 +119,7 @@ func @func_args(i32, i32) -> i32 {
br ^bb2(%6 : index)
// CHECK-NEXT: ^bb4: // pred: ^bb2
// CHECK-NEXT: {{.*}} = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.call @other({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i32) -> !llvm.i32
// CHECK-NEXT: llvm.return {{.*}} : !llvm.i32
^bb4: // pred: ^bb2
@ -144,8 +144,8 @@ func @imperfectly_nested_loops() {
br ^bb1
// CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
^bb1: // pred: ^bb0
%c0 = constant 0 : index
@ -167,8 +167,8 @@ func @imperfectly_nested_loops() {
br ^bb4
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: {{.*}} = llvm.constant(7 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.constant(56 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : !llvm.i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64)
^bb4: // pred: ^bb3
%c7 = constant 7 : index
@ -184,7 +184,7 @@ func @imperfectly_nested_loops() {
// CHECK-NEXT: ^bb6: // pred: ^bb5
// CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.constant(2 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64)
^bb6: // pred: ^bb5
@ -195,7 +195,7 @@ func @imperfectly_nested_loops() {
// CHECK-NEXT: ^bb7: // pred: ^bb5
// CHECK-NEXT: llvm.call @post({{.*}}) : (!llvm.i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
^bb7: // pred: ^bb5
@ -220,8 +220,8 @@ func @body3(index, index)
// CHECK-LABEL: func @more_imperfectly_nested_loops() {
// CHECK-NEXT: llvm.br ^bb1
// CHECK-NEXT:^bb1: // pred: ^bb0
// CHECK-NEXT: {{.*}} = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.constant(42 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(0 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
// CHECK-NEXT:^bb2({{.*}}: !llvm.i64): // 2 preds: ^bb1, ^bb11
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64
@ -230,35 +230,35 @@ func @body3(index, index)
// CHECK-NEXT: llvm.call @pre({{.*}}) : (!llvm.i64) -> ()
// CHECK-NEXT: llvm.br ^bb4
// CHECK-NEXT:^bb4: // pred: ^bb3
// CHECK-NEXT: {{.*}} = llvm.constant(7 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.constant(56 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(7 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(56 : index) : !llvm.i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64)
// CHECK-NEXT:^bb5({{.*}}: !llvm.i64): // 2 preds: ^bb4, ^bb6
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb6, ^bb7
// CHECK-NEXT:^bb6: // pred: ^bb5
// CHECK-NEXT: llvm.call @body2({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.constant(2 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(2 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.br ^bb5({{.*}} : !llvm.i64)
// CHECK-NEXT:^bb7: // pred: ^bb5
// CHECK-NEXT: llvm.call @mid({{.*}}) : (!llvm.i64) -> ()
// CHECK-NEXT: llvm.br ^bb8
// CHECK-NEXT:^bb8: // pred: ^bb7
// CHECK-NEXT: {{.*}} = llvm.constant(18 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.constant(37 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(18 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(37 : index) : !llvm.i64
// CHECK-NEXT: llvm.br ^bb9({{.*}} : !llvm.i64)
// CHECK-NEXT:^bb9({{.*}}: !llvm.i64): // 2 preds: ^bb8, ^bb10
// CHECK-NEXT: {{.*}} = llvm.icmp "slt" {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.cond_br {{.*}}, ^bb10, ^bb11
// CHECK-NEXT:^bb10: // pred: ^bb9
// CHECK-NEXT: llvm.call @body3({{.*}}, {{.*}}) : (!llvm.i64, !llvm.i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.constant(3 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(3 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.br ^bb9({{.*}} : !llvm.i64)
// CHECK-NEXT:^bb11: // pred: ^bb9
// CHECK-NEXT: llvm.call @post({{.*}}) : (!llvm.i64) -> ()
// CHECK-NEXT: {{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: {{.*}} = llvm.add {{.*}}, {{.*}} : !llvm.i64
// CHECK-NEXT: llvm.br ^bb2({{.*}} : !llvm.i64)
// CHECK-NEXT:^bb12: // pred: ^bb2
@ -329,7 +329,7 @@ func @multireturn() -> (i64, f32, memref<42x?x10x?xf32>) {
%0 = call @get_i64() : () -> (i64)
%1 = call @get_f32() : () -> (f32)
%2 = call @get_memref() : () -> (memref<42x?x10x?xf32>)
// CHECK-NEXT: {{.*}} = llvm.undef : !llvm<"{ i64, float, { float*, i64, i64 } }">
// CHECK-NEXT: {{.*}} = llvm.mlir.undef : !llvm<"{ i64, float, { float*, i64, i64 } }">
// CHECK-NEXT: {{.*}} = llvm.insertvalue {{.*}}, {{.*}}[0 : index] : !llvm<"{ i64, float, { float*, i64, i64 } }">
// CHECK-NEXT: {{.*}} = llvm.insertvalue {{.*}}, {{.*}}[1 : index] : !llvm<"{ i64, float, { float*, i64, i64 } }">
// CHECK-NEXT: {{.*}} = llvm.insertvalue {{.*}}, {{.*}}[2 : index] : !llvm<"{ i64, float, { float*, i64, i64 } }">
@ -359,7 +359,7 @@ func @multireturn_caller() {
// CHECK-LABEL: func @vector_ops(%arg0: !llvm<"<4 x float>">, %arg1: !llvm<"<4 x i1>">, %arg2: !llvm<"<4 x i64>">) -> !llvm<"<4 x float>"> {
func @vector_ops(vector<4xf32>, vector<4xi1>, vector<4xi64>) -> vector<4xf32> {
^bb0(%arg0: vector<4xf32>, %arg1: vector<4xi1>, %arg2: vector<4xi64>):
// CHECK-NEXT: %0 = llvm.constant(dense<4.200000e+01> : vector<4xf32>) : !llvm<"<4 x float>">
// CHECK-NEXT: %0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : !llvm<"<4 x float>">
%0 = constant dense<42.> : vector<4xf32>
// CHECK-NEXT: %1 = llvm.fadd %arg0, %0 : !llvm<"<4 x float>">
%1 = addf %arg0, %0 : vector<4xf32>
@ -445,7 +445,7 @@ func @sitofp(%arg0 : i32, %arg1 : i64) {
// CHECK-LABEL: @dfs_block_order
func @dfs_block_order() -> (i32) {
// CHECK-NEXT: %0 = llvm.constant(42 : i32) : !llvm.i32
// CHECK-NEXT: %0 = llvm.mlir.constant(42 : i32) : !llvm.i32
%0 = constant 42 : i32
// CHECK-NEXT: llvm.br ^bb2
br ^bb2
@ -459,7 +459,7 @@ func @dfs_block_order() -> (i32) {
// CHECK-NEXT: ^bb2:
^bb2:
// CHECK-NEXT: %2 = llvm.constant(55 : i32) : !llvm.i32
// CHECK-NEXT: %2 = llvm.mlir.constant(55 : i32) : !llvm.i32
%1 = constant 55 : i32
// CHECK-NEXT: llvm.br ^bb1
br ^bb1
@ -519,7 +519,7 @@ func @vec_bin(%arg0: vector<2x2x2xf32>) -> vector<2x2x2xf32> {
%0 = addf %arg0, %arg0 : vector<2x2x2xf32>
return %0 : vector<2x2x2xf32>
// CHECK-NEXT: llvm.undef : !llvm<"[2 x [2 x <2 x float>]]">
// CHECK-NEXT: llvm.mlir.undef : !llvm<"[2 x [2 x <2 x float>]]">
// This block appears 2x2 times
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0 : index, 0 : index] : !llvm<"[2 x [2 x <2 x float>]]">

View File

@ -1,24 +1,24 @@
// RUN: mlir-opt -split-input-file -verify-diagnostics %s | FileCheck %s
// CHECK: llvm.global @global(42 : i64) : !llvm.i64
llvm.global @global(42 : i64) : !llvm.i64
// CHECK: llvm.mlir.global @global(42 : i64) : !llvm.i64
llvm.mlir.global @global(42 : i64) : !llvm.i64
// CHECK: llvm.global constant @constant(3.700000e+01 : f64) : !llvm.float
llvm.global constant @constant(37.0) : !llvm.float
// CHECK: llvm.mlir.global constant @constant(3.700000e+01 : f64) : !llvm.float
llvm.mlir.global constant @constant(37.0) : !llvm.float
// CHECK: llvm.global constant @string("foobar")
llvm.global constant @string("foobar") : !llvm<"[6 x i8]">
// CHECK: llvm.mlir.global constant @string("foobar")
llvm.mlir.global constant @string("foobar") : !llvm<"[6 x i8]">
// CHECK: llvm.global @string_notype("1234567")
llvm.global @string_notype("1234567")
// CHECK: llvm.mlir.global @string_notype("1234567")
llvm.mlir.global @string_notype("1234567")
// CHECK-LABEL: references
func @references() {
// CHECK: llvm.addressof @global : !llvm<"i64*">
%0 = llvm.addressof @global : !llvm<"i64*">
// CHECK: llvm.mlir.addressof @global : !llvm<"i64*">
%0 = llvm.mlir.addressof @global : !llvm<"i64*">
// CHECK: llvm.addressof @string : !llvm<"[6 x i8]*">
%1 = llvm.addressof @string : !llvm<"[6 x i8]*">
// CHECK: llvm.mlir.addressof @string : !llvm<"[6 x i8]*">
%1 = llvm.mlir.addressof @string : !llvm<"[6 x i8]*">
llvm.return
}
@ -26,52 +26,52 @@ func @references() {
// -----
// expected-error @+1 {{op requires attribute 'sym_name'}}
"llvm.global"() {type = !llvm.i64, constant, value = 42 : i64} : () -> ()
"llvm.mlir.global"() {type = !llvm.i64, constant, value = 42 : i64} : () -> ()
// -----
// expected-error @+1 {{op requires attribute 'type'}}
"llvm.global"() {sym_name = "foo", constant, value = 42 : i64} : () -> ()
"llvm.mlir.global"() {sym_name = "foo", constant, value = 42 : i64} : () -> ()
// -----
// expected-error @+1 {{op requires attribute 'value'}}
"llvm.global"() {sym_name = "foo", type = !llvm.i64, constant} : () -> ()
"llvm.mlir.global"() {sym_name = "foo", type = !llvm.i64, constant} : () -> ()
// -----
// expected-error @+1 {{expects type to be a valid element type for an LLVM pointer}}
llvm.global constant @constant(37.0) : !llvm<"label">
llvm.mlir.global constant @constant(37.0) : !llvm<"label">
// -----
func @foo() {
// expected-error @+1 {{must appear at the module level}}
llvm.global @bar(42) : !llvm.i32
llvm.mlir.global @bar(42) : !llvm.i32
}
// -----
// expected-error @+1 {{requires an i8 array type of the length equal to that of the string}}
llvm.global constant @string("foobar") : !llvm<"[42 x i8]">
llvm.mlir.global constant @string("foobar") : !llvm<"[42 x i8]">
// -----
// expected-error @+1 {{type can only be omitted for string globals}}
llvm.global @i64_needs_type(0: i64)
llvm.mlir.global @i64_needs_type(0: i64)
// -----
// expected-error @+1 {{expected zero or one type}}
llvm.global @more_than_one_type(0) : !llvm.i64, !llvm.i32
llvm.mlir.global @more_than_one_type(0) : !llvm.i64, !llvm.i32
// -----
llvm.global @foo(0: i32) : !llvm.i32
llvm.mlir.global @foo(0: i32) : !llvm.i32
func @bar() {
// expected-error @+2{{expected ':'}}
llvm.addressof @foo
llvm.mlir.addressof @foo
}
// -----
@ -80,21 +80,21 @@ func @foo() {
// The attribute parser will consume the first colon-type, so we put two of
// them to trigger the attribute type mismatch error.
// expected-error @+1 {{expected symbol reference}}
llvm.addressof "foo" : i64 : !llvm<"void ()*">
llvm.mlir.addressof "foo" : i64 : !llvm<"void ()*">
}
// -----
func @foo() {
// expected-error @+1 {{must reference a global defined by 'llvm.global'}}
llvm.addressof @foo : !llvm<"void ()*">
// expected-error @+1 {{must reference a global defined by 'llvm.mlir.global'}}
llvm.mlir.addressof @foo : !llvm<"void ()*">
}
// -----
llvm.global @foo(0: i32) : !llvm.i32
llvm.mlir.global @foo(0: i32) : !llvm.i32
func @bar() {
// expected-error @+1 {{the type must be a pointer to the type of the referred global}}
llvm.addressof @foo : !llvm<"i64*">
llvm.mlir.addressof @foo : !llvm<"i64*">
}

View File

@ -52,12 +52,12 @@ func @ops(%arg0 : !llvm.i32, %arg1 : !llvm.float) {
// CHECK-NEXT: %17 = llvm.call @foo(%arg0) : (!llvm.i32) -> !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %18 = llvm.extractvalue %17[0] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %19 = llvm.insertvalue %18, %17[2] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %20 = llvm.constant(@foo) : !llvm<"{ i32, double, i32 } (i32)*">
// CHECK-NEXT: %20 = llvm.mlir.constant(@foo) : !llvm<"{ i32, double, i32 } (i32)*">
// CHECK-NEXT: %21 = llvm.call %20(%arg0) : (!llvm.i32) -> !llvm<"{ i32, double, i32 }">
%17 = llvm.call @foo(%arg0) : (!llvm.i32) -> !llvm<"{ i32, double, i32 }">
%18 = llvm.extractvalue %17[0] : !llvm<"{ i32, double, i32 }">
%19 = llvm.insertvalue %18, %17[2] : !llvm<"{ i32, double, i32 }">
%20 = llvm.constant(@foo) : !llvm<"{ i32, double, i32 } (i32)*">
%20 = llvm.mlir.constant(@foo) : !llvm<"{ i32, double, i32 } (i32)*">
%21 = llvm.call %20(%arg0) : (!llvm.i32) -> !llvm<"{ i32, double, i32 }">
@ -71,10 +71,10 @@ func @ops(%arg0 : !llvm.i32, %arg1 : !llvm.float) {
llvm.cond_br %7, ^bb2, ^bb1
^bb2:
// CHECK: %22 = llvm.undef : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %23 = llvm.constant(42 : i64) : !llvm.i47
%22 = llvm.undef : !llvm<"{ i32, double, i32 }">
%23 = llvm.constant(42) : !llvm.i47
// CHECK: %22 = llvm.mlir.undef : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %23 = llvm.mlir.constant(42 : i64) : !llvm.i47
%22 = llvm.mlir.undef : !llvm<"{ i32, double, i32 }">
%23 = llvm.mlir.constant(42) : !llvm.i47
// Misc operations.
// CHECK: %24 = llvm.select %7, %0, %1 : !llvm.i1, !llvm.i32
@ -94,25 +94,25 @@ func @ops(%arg0 : !llvm.i32, %arg1 : !llvm.float) {
// An larger self-contained function.
// CHECK-LABEL:func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
// CHECK-NEXT: %0 = llvm.constant(3 : i64) : !llvm.i32
// CHECK-NEXT: %1 = llvm.constant(3 : i64) : !llvm.i32
// CHECK-NEXT: %2 = llvm.constant(4.200000e+01 : f64) : !llvm.double
// CHECK-NEXT: %3 = llvm.constant(4.200000e+01 : f64) : !llvm.double
// CHECK-NEXT: %0 = llvm.mlir.constant(3 : i64) : !llvm.i32
// CHECK-NEXT: %1 = llvm.mlir.constant(3 : i64) : !llvm.i32
// CHECK-NEXT: %2 = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double
// CHECK-NEXT: %3 = llvm.mlir.constant(4.200000e+01 : f64) : !llvm.double
// CHECK-NEXT: %4 = llvm.add %0, %1 : !llvm.i32
// CHECK-NEXT: %5 = llvm.mul %4, %1 : !llvm.i32
// CHECK-NEXT: %6 = llvm.fadd %2, %3 : !llvm.double
// CHECK-NEXT: %7 = llvm.fsub %3, %6 : !llvm.double
// CHECK-NEXT: %8 = llvm.constant(1 : i64) : !llvm.i1
// CHECK-NEXT: %8 = llvm.mlir.constant(1 : i64) : !llvm.i1
// CHECK-NEXT: llvm.cond_br %8, ^bb1(%4 : !llvm.i32), ^bb2(%4 : !llvm.i32)
%0 = llvm.constant(3) : !llvm.i32
%1 = llvm.constant(3) : !llvm.i32
%2 = llvm.constant(4.200000e+01) : !llvm.double
%3 = llvm.constant(4.200000e+01) : !llvm.double
%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
%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
%8 = llvm.constant(1) : !llvm.i1
%8 = llvm.mlir.constant(1) : !llvm.i1
llvm.cond_br %8, ^bb1(%4 : !llvm.i32), ^bb2(%4 : !llvm.i32)
// CHECK-NEXT:^bb1(%9: !llvm.i32):
@ -120,7 +120,7 @@ func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
// CHECK-NEXT: %11 = llvm.extractvalue %10[0] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %12 = llvm.extractvalue %10[1] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %13 = llvm.extractvalue %10[2] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %14 = llvm.undef : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %14 = llvm.mlir.undef : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %15 = llvm.insertvalue %5, %14[0] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %16 = llvm.insertvalue %7, %15[1] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %17 = llvm.insertvalue %11, %16[2] : !llvm<"{ i32, double, i32 }">
@ -130,20 +130,20 @@ func @foo(%arg0: !llvm.i32) -> !llvm<"{ i32, double, i32 }"> {
%11 = llvm.extractvalue %10[0] : !llvm<"{ i32, double, i32 }">
%12 = llvm.extractvalue %10[1] : !llvm<"{ i32, double, i32 }">
%13 = llvm.extractvalue %10[2] : !llvm<"{ i32, double, i32 }">
%14 = llvm.undef : !llvm<"{ i32, double, i32 }">
%14 = llvm.mlir.undef : !llvm<"{ i32, double, i32 }">
%15 = llvm.insertvalue %5, %14[0] : !llvm<"{ i32, double, i32 }">
%16 = llvm.insertvalue %7, %15[1] : !llvm<"{ i32, double, i32 }">
%17 = llvm.insertvalue %11, %16[2] : !llvm<"{ i32, double, i32 }">
llvm.return %17 : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT:^bb2(%18: !llvm.i32): // pred: ^bb0
// CHECK-NEXT: %19 = llvm.undef : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %19 = llvm.mlir.undef : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %20 = llvm.insertvalue %18, %19[0] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %21 = llvm.insertvalue %7, %20[1] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: %22 = llvm.insertvalue %5, %21[2] : !llvm<"{ i32, double, i32 }">
// CHECK-NEXT: llvm.return %22 : !llvm<"{ i32, double, i32 }">
^bb2(%18: !llvm.i32): // pred: ^bb0
%19 = llvm.undef : !llvm<"{ i32, double, i32 }">
%19 = llvm.mlir.undef : !llvm<"{ i32, double, i32 }">
%20 = llvm.insertvalue %18, %19[0] : !llvm<"{ i32, double, i32 }">
%21 = llvm.insertvalue %7, %20[1] : !llvm<"{ i32, double, i32 }">
%22 = llvm.insertvalue %5, %21[2] : !llvm<"{ i32, double, i32 }">

View File

@ -15,10 +15,10 @@ func @buffer_alloc_aligned(%arg0: index) {
return
}
// CHECK-LABEL: func @buffer_alloc_aligned
// CHECK: %[[c4:.*]] = llvm.constant(4 : index) : !llvm.i64
// CHECK: %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64
// CHECK: %[[m:.*]] = llvm.mul %arg0, %[[c4]] : !llvm.i64
// CHECK: %[[c1:.*]] = llvm.constant(1 : index) : !llvm.i64
// CHECK: %[[c16:.*]] = llvm.constant(16 : index) : !llvm.i64
// CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK: %[[c16:.*]] = llvm.mlir.constant(16 : index) : !llvm.i64
// CHECK: %[[a:.*]] = llvm.add %[[m]], %[[c16]] : !llvm.i64
// CHECK: %[[s:.*]] = llvm.sub %[[a]], %[[c1]] : !llvm.i64
// CHECK: %[[alloc:.*]] = llvm.call @malloc(%[[s]]) : (!llvm.i64) -> !llvm<"i8*">
@ -36,9 +36,9 @@ func @range(%arg0: index) {
return
}
// CHECK-LABEL: func @range(%{{.*}}: !llvm.i64) {
// CHECK: llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: llvm.mlir.constant(0 : index) : !llvm.i64
// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.mlir.undef : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
@ -48,15 +48,15 @@ func @view(%arg0: !linalg.buffer<?xf32>, %arg1: !linalg.range) {
return
}
// CHECK-LABEL: func @view
// CHECK-NEXT: llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.alloca {{.*}} x !llvm<"{ float*, i64, [1 x i64], [1 x i64] }"> {alignment = 8 : i64} : (!llvm.i64) -> !llvm<"{ float*, i64, [1 x i64], [1 x i64] }*">
// CHECK: llvm.load %{{.*}} : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }*">
// CHECK-NEXT: llvm.extractvalue %{{.*}}[1] : !llvm<"{ i8*, float*, i64 }">
// CHECK-NEXT: llvm.bitcast {{.*}} : !llvm<"float*"> to !llvm<"float*">
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: llvm.mlir.constant(0 : index) : !llvm.i64
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
@ -72,7 +72,7 @@ func @view3d(%arg0: !linalg.buffer<?xf32>, %arg1: !linalg.range, %arg2: !linalg.
return
}
// CHECK-LABEL: func @view3d
// CHECK-NEXT: llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: llvm.alloca {{.*}} x !llvm<"{ float*, i64, [3 x i64], [3 x i64] }"> {alignment = 8 : i64} : (!llvm.i64) -> !llvm<"{ float*, i64, [3 x i64], [3 x i64] }*">
// CHECK-NEXT: llvm.load {{.*}} : !llvm<"{ float*, i64, [3 x i64], [3 x i64] }*">
// CHECK: llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
@ -146,8 +146,8 @@ func @subview(%arg0: !linalg.view<?x?xf32>) {
//
// Subview lowers to range + slice op
// CHECK: llvm.alloca %{{.*}} x !llvm<"{ float*, i64, [2 x i64], [2 x i64] }"> {alignment = 8 : i64} : (!llvm.i64) -> !llvm<"{ float*, i64, [2 x i64], [2 x i64] }*">
// CHECK: llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: llvm.mlir.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: llvm.mlir.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: llvm.load %{{.*}} : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }*">
//
// Select occurs in slice op lowering

View File

@ -1,16 +1,16 @@
// RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s
// CHECK: @i32_global = internal global i32 42
llvm.global @i32_global(42: i32) : !llvm.i32
llvm.mlir.global @i32_global(42: i32) : !llvm.i32
// CHECK: @i32_global_const = internal constant i53 52
llvm.global constant @i32_global_const(52: i53) : !llvm.i53
llvm.mlir.global constant @i32_global_const(52: i53) : !llvm.i53
// CHECK: @float_global = internal global float 0.000000e+00
llvm.global @float_global(0.0: f32) : !llvm.float
llvm.mlir.global @float_global(0.0: f32) : !llvm.float
// CHECK: @string_const = internal constant [6 x i8] c"foobar"
llvm.global constant @string_const("foobar") : !llvm<"[6 x i8]">
llvm.mlir.global constant @string_const("foobar") : !llvm<"[6 x i8]">
//
// Declarations of the allocation functions to be linked against.
@ -37,13 +37,13 @@ func @empty() {
func @global_refs() {
// Check load from globals.
// CHECK: load i32, i32* @i32_global
%0 = llvm.addressof @i32_global : !llvm<"i32*">
%0 = llvm.mlir.addressof @i32_global : !llvm<"i32*">
%1 = llvm.load %0 : !llvm<"i32*">
// Check the contracted form of load from array constants.
// CHECK: load i8, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @string_const, i64 0, i64 0)
%2 = llvm.addressof @string_const : !llvm<"[6 x i8]*">
%c0 = llvm.constant(0 : index) : !llvm.i64
%2 = llvm.mlir.addressof @string_const : !llvm<"[6 x i8]*">
%c0 = llvm.mlir.constant(0 : index) : !llvm.i64
%3 = llvm.getelementptr %2[%c0, %c0] : (!llvm<"[6 x i8]*">, !llvm.i64, !llvm.i64) -> !llvm<"i8*">
%4 = llvm.load %3 : !llvm<"i8*">
@ -63,8 +63,8 @@ func @simple_loop() {
// CHECK: [[SIMPLE_bb1]]:
// CHECK-NEXT: br label %[[SIMPLE_bb2:[0-9]+]]
^bb1: // pred: ^bb0
%0 = llvm.constant(1 : index) : !llvm.i64
%1 = llvm.constant(42 : index) : !llvm.i64
%0 = llvm.mlir.constant(1 : index) : !llvm.i64
%1 = llvm.mlir.constant(42 : index) : !llvm.i64
llvm.br ^bb2(%0 : !llvm.i64)
// CHECK: [[SIMPLE_bb2]]:
@ -81,7 +81,7 @@ func @simple_loop() {
// CHECK-NEXT: br label %[[SIMPLE_bb2]]
^bb3: // pred: ^bb2
llvm.call @body(%2) : (!llvm.i64) -> ()
%4 = llvm.constant(1 : index) : !llvm.i64
%4 = llvm.mlir.constant(1 : index) : !llvm.i64
%5 = llvm.add %2, %4 : !llvm.i64
llvm.br ^bb2(%5 : !llvm.i64)
@ -126,14 +126,14 @@ func @other(!llvm.i64, !llvm.i32) -> !llvm.i32
// CHECK-LABEL: define i32 @func_args(i32 {{%.*}}, i32 {{%.*}}) {
// CHECK-NEXT: br label %[[ARGS_bb1:[0-9]+]]
func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 {
%0 = llvm.constant(0 : i32) : !llvm.i32
%0 = llvm.mlir.constant(0 : i32) : !llvm.i32
llvm.br ^bb1
// CHECK: [[ARGS_bb1]]:
// CHECK-NEXT: br label %[[ARGS_bb2:[0-9]+]]
^bb1: // pred: ^bb0
%1 = llvm.constant(0 : index) : !llvm.i64
%2 = llvm.constant(42 : index) : !llvm.i64
%1 = llvm.mlir.constant(0 : index) : !llvm.i64
%2 = llvm.mlir.constant(42 : index) : !llvm.i64
llvm.br ^bb2(%1 : !llvm.i64)
// CHECK: [[ARGS_bb2]]:
@ -156,7 +156,7 @@ func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 {
%6 = llvm.call @other(%5, %arg0) : (!llvm.i64, !llvm.i32) -> !llvm.i32
%7 = llvm.call @other(%5, %6) : (!llvm.i64, !llvm.i32) -> !llvm.i32
%8 = llvm.call @other(%5, %arg1) : (!llvm.i64, !llvm.i32) -> !llvm.i32
%9 = llvm.constant(1 : index) : !llvm.i64
%9 = llvm.mlir.constant(1 : index) : !llvm.i64
%10 = llvm.add %3, %9 : !llvm.i64
llvm.br ^bb2(%10 : !llvm.i64)
@ -164,7 +164,7 @@ func @func_args(%arg0: !llvm.i32, %arg1: !llvm.i32) -> !llvm.i32 {
// CHECK-NEXT: %14 = call i32 @other(i64 0, i32 0)
// CHECK-NEXT: ret i32 %14
^bb4: // pred: ^bb2
%11 = llvm.constant(0 : index) : !llvm.i64
%11 = llvm.mlir.constant(0 : index) : !llvm.i64
%12 = llvm.call @other(%11, %0) : (!llvm.i64, !llvm.i32) -> !llvm.i32
llvm.return %12 : !llvm.i32
}
@ -186,8 +186,8 @@ func @imperfectly_nested_loops() {
// CHECK: [[IMPER_bb1]]:
// CHECK-NEXT: br label %[[IMPER_bb2:[0-9]+]]
^bb1: // pred: ^bb0
%0 = llvm.constant(0 : index) : !llvm.i64
%1 = llvm.constant(42 : index) : !llvm.i64
%0 = llvm.mlir.constant(0 : index) : !llvm.i64
%1 = llvm.mlir.constant(42 : index) : !llvm.i64
llvm.br ^bb2(%0 : !llvm.i64)
// CHECK: [[IMPER_bb2]]:
@ -208,8 +208,8 @@ func @imperfectly_nested_loops() {
// CHECK: [[IMPER_bb4]]:
// CHECK-NEXT: br label %[[IMPER_bb5:[0-9]+]]
^bb4: // pred: ^bb3
%4 = llvm.constant(7 : index) : !llvm.i64
%5 = llvm.constant(56 : index) : !llvm.i64
%4 = llvm.mlir.constant(7 : index) : !llvm.i64
%5 = llvm.mlir.constant(56 : index) : !llvm.i64
llvm.br ^bb5(%4 : !llvm.i64)
// CHECK: [[IMPER_bb5]]:
@ -226,7 +226,7 @@ func @imperfectly_nested_loops() {
// CHECK-NEXT: br label %[[IMPER_bb5]]
^bb6: // pred: ^bb5
llvm.call @body2(%2, %6) : (!llvm.i64, !llvm.i64) -> ()
%8 = llvm.constant(2 : index) : !llvm.i64
%8 = llvm.mlir.constant(2 : index) : !llvm.i64
%9 = llvm.add %6, %8 : !llvm.i64
llvm.br ^bb5(%9 : !llvm.i64)
@ -236,7 +236,7 @@ func @imperfectly_nested_loops() {
// CHECK-NEXT: br label %[[IMPER_bb2]]
^bb7: // pred: ^bb5
llvm.call @post(%2) : (!llvm.i64) -> ()
%10 = llvm.constant(1 : index) : !llvm.i64
%10 = llvm.mlir.constant(1 : index) : !llvm.i64
%11 = llvm.add %2, %10 : !llvm.i64
llvm.br ^bb2(%11 : !llvm.i64)
@ -297,8 +297,8 @@ func @body3(!llvm.i64, !llvm.i64)
func @more_imperfectly_nested_loops() {
llvm.br ^bb1
^bb1: // pred: ^bb0
%0 = llvm.constant(0 : index) : !llvm.i64
%1 = llvm.constant(42 : index) : !llvm.i64
%0 = llvm.mlir.constant(0 : index) : !llvm.i64
%1 = llvm.mlir.constant(42 : index) : !llvm.i64
llvm.br ^bb2(%0 : !llvm.i64)
^bb2(%2: !llvm.i64): // 2 preds: ^bb1, ^bb11
%3 = llvm.icmp "slt" %2, %1 : !llvm.i64
@ -307,35 +307,35 @@ func @more_imperfectly_nested_loops() {
llvm.call @pre(%2) : (!llvm.i64) -> ()
llvm.br ^bb4
^bb4: // pred: ^bb3
%4 = llvm.constant(7 : index) : !llvm.i64
%5 = llvm.constant(56 : index) : !llvm.i64
%4 = llvm.mlir.constant(7 : index) : !llvm.i64
%5 = llvm.mlir.constant(56 : index) : !llvm.i64
llvm.br ^bb5(%4 : !llvm.i64)
^bb5(%6: !llvm.i64): // 2 preds: ^bb4, ^bb6
%7 = llvm.icmp "slt" %6, %5 : !llvm.i64
llvm.cond_br %7, ^bb6, ^bb7
^bb6: // pred: ^bb5
llvm.call @body2(%2, %6) : (!llvm.i64, !llvm.i64) -> ()
%8 = llvm.constant(2 : index) : !llvm.i64
%8 = llvm.mlir.constant(2 : index) : !llvm.i64
%9 = llvm.add %6, %8 : !llvm.i64
llvm.br ^bb5(%9 : !llvm.i64)
^bb7: // pred: ^bb5
llvm.call @mid(%2) : (!llvm.i64) -> ()
llvm.br ^bb8
^bb8: // pred: ^bb7
%10 = llvm.constant(18 : index) : !llvm.i64
%11 = llvm.constant(37 : index) : !llvm.i64
%10 = llvm.mlir.constant(18 : index) : !llvm.i64
%11 = llvm.mlir.constant(37 : index) : !llvm.i64
llvm.br ^bb9(%10 : !llvm.i64)
^bb9(%12: !llvm.i64): // 2 preds: ^bb8, ^bb10
%13 = llvm.icmp "slt" %12, %11 : !llvm.i64
llvm.cond_br %13, ^bb10, ^bb11
^bb10: // pred: ^bb9
llvm.call @body3(%2, %12) : (!llvm.i64, !llvm.i64) -> ()
%14 = llvm.constant(3 : index) : !llvm.i64
%14 = llvm.mlir.constant(3 : index) : !llvm.i64
%15 = llvm.add %12, %14 : !llvm.i64
llvm.br ^bb9(%15 : !llvm.i64)
^bb11: // pred: ^bb9
llvm.call @post(%2) : (!llvm.i64) -> ()
%16 = llvm.constant(1 : index) : !llvm.i64
%16 = llvm.mlir.constant(1 : index) : !llvm.i64
%17 = llvm.add %2, %16 : !llvm.i64
llvm.br ^bb2(%17 : !llvm.i64)
^bb12: // pred: ^bb2
@ -351,11 +351,11 @@ func @memref_alloc() {
// CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 400)
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0
%0 = llvm.constant(10 : index) : !llvm.i64
%1 = llvm.constant(10 : index) : !llvm.i64
%0 = llvm.mlir.constant(10 : index) : !llvm.i64
%1 = llvm.mlir.constant(10 : index) : !llvm.i64
%2 = llvm.mul %0, %1 : !llvm.i64
%3 = llvm.undef : !llvm<"{ float* }">
%4 = llvm.constant(4 : index) : !llvm.i64
%3 = llvm.mlir.undef : !llvm<"{ float* }">
%4 = llvm.mlir.constant(4 : index) : !llvm.i64
%5 = llvm.mul %2, %4 : !llvm.i64
%6 = llvm.call @malloc(%5) : (!llvm.i64) -> !llvm<"i8*">
%7 = llvm.bitcast %6 : !llvm<"i8*"> to !llvm<"float*">
@ -373,18 +373,18 @@ func @store_load_static() {
// CHECK-NEXT: %{{[0-9]+}} = call i8* @malloc(i64 40)
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float* } undef, float* %{{[0-9]+}}, 0
%0 = llvm.constant(10 : index) : !llvm.i64
%1 = llvm.undef : !llvm<"{ float* }">
%2 = llvm.constant(4 : index) : !llvm.i64
%0 = llvm.mlir.constant(10 : index) : !llvm.i64
%1 = llvm.mlir.undef : !llvm<"{ float* }">
%2 = llvm.mlir.constant(4 : index) : !llvm.i64
%3 = llvm.mul %0, %2 : !llvm.i64
%4 = llvm.call @malloc(%3) : (!llvm.i64) -> !llvm<"i8*">
%5 = llvm.bitcast %4 : !llvm<"i8*"> to !llvm<"float*">
%6 = llvm.insertvalue %5, %1[0] : !llvm<"{ float* }">
%7 = llvm.constant(1.000000e+00 : f32) : !llvm.float
%7 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float
llvm.br ^bb1
^bb1: // pred: ^bb0
%8 = llvm.constant(0 : index) : !llvm.i64
%9 = llvm.constant(10 : index) : !llvm.i64
%8 = llvm.mlir.constant(0 : index) : !llvm.i64
%9 = llvm.mlir.constant(10 : index) : !llvm.i64
llvm.br ^bb2(%8 : !llvm.i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb2(%10: !llvm.i64): // 2 preds: ^bb1, ^bb3
@ -396,11 +396,11 @@ func @store_load_static() {
// CHECK: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: store float 1.000000e+00, float* %{{[0-9]+}}
%12 = llvm.constant(10 : index) : !llvm.i64
%12 = llvm.mlir.constant(10 : index) : !llvm.i64
%13 = llvm.extractvalue %6[0] : !llvm<"{ float* }">
%14 = llvm.getelementptr %13[%10] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
llvm.store %7, %14 : !llvm<"float*">
%15 = llvm.constant(1 : index) : !llvm.i64
%15 = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%16 = llvm.add %10, %15 : !llvm.i64
// CHECK-NEXT: br label %{{[0-9]+}}
@ -408,8 +408,8 @@ func @store_load_static() {
^bb4: // pred: ^bb2
llvm.br ^bb5
^bb5: // pred: ^bb4
%17 = llvm.constant(0 : index) : !llvm.i64
%18 = llvm.constant(10 : index) : !llvm.i64
%17 = llvm.mlir.constant(0 : index) : !llvm.i64
%18 = llvm.mlir.constant(10 : index) : !llvm.i64
llvm.br ^bb6(%17 : !llvm.i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb6(%19: !llvm.i64): // 2 preds: ^bb5, ^bb7
@ -421,11 +421,11 @@ func @store_load_static() {
// CHECK: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
%21 = llvm.constant(10 : index) : !llvm.i64
%21 = llvm.mlir.constant(10 : index) : !llvm.i64
%22 = llvm.extractvalue %6[0] : !llvm<"{ float* }">
%23 = llvm.getelementptr %22[%19] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
%24 = llvm.load %23 : !llvm<"float*">
%25 = llvm.constant(1 : index) : !llvm.i64
%25 = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%26 = llvm.add %19, %25 : !llvm.i64
// CHECK-NEXT: br label %{{[0-9]+}}
@ -442,18 +442,18 @@ func @store_load_dynamic(%arg0: !llvm.i64) {
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
%0 = llvm.undef : !llvm<"{ float*, i64 }">
%1 = llvm.constant(4 : index) : !llvm.i64
%0 = llvm.mlir.undef : !llvm<"{ float*, i64 }">
%1 = llvm.mlir.constant(4 : index) : !llvm.i64
%2 = llvm.mul %arg0, %1 : !llvm.i64
%3 = llvm.call @malloc(%2) : (!llvm.i64) -> !llvm<"i8*">
%4 = llvm.bitcast %3 : !llvm<"i8*"> to !llvm<"float*">
%5 = llvm.insertvalue %4, %0[0] : !llvm<"{ float*, i64 }">
%6 = llvm.insertvalue %arg0, %5[1] : !llvm<"{ float*, i64 }">
%7 = llvm.constant(1.000000e+00 : f32) : !llvm.float
%7 = llvm.mlir.constant(1.000000e+00 : f32) : !llvm.float
// CHECK-NEXT: br label %{{[0-9]+}}
llvm.br ^bb1
^bb1: // pred: ^bb0
%8 = llvm.constant(0 : index) : !llvm.i64
%8 = llvm.mlir.constant(0 : index) : !llvm.i64
llvm.br ^bb2(%8 : !llvm.i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb2(%9: !llvm.i64): // 2 preds: ^bb1, ^bb3
@ -470,7 +470,7 @@ func @store_load_dynamic(%arg0: !llvm.i64) {
%12 = llvm.extractvalue %6[0] : !llvm<"{ float*, i64 }">
%13 = llvm.getelementptr %12[%9] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
llvm.store %7, %13 : !llvm<"float*">
%14 = llvm.constant(1 : index) : !llvm.i64
%14 = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%15 = llvm.add %9, %14 : !llvm.i64
// CHECK-NEXT: br label %{{[0-9]+}}
@ -478,7 +478,7 @@ func @store_load_dynamic(%arg0: !llvm.i64) {
^bb4: // pred: ^bb3
llvm.br ^bb5
^bb5: // pred: ^bb4
%16 = llvm.constant(0 : index) : !llvm.i64
%16 = llvm.mlir.constant(0 : index) : !llvm.i64
llvm.br ^bb6(%16 : !llvm.i64)
// CHECK: %{{[0-9]+}} = phi i64 [ %{{[0-9]+}}, %{{[0-9]+}} ], [ 0, %{{[0-9]+}} ]
^bb6(%17: !llvm.i64): // 2 preds: ^bb5, ^bb7
@ -495,7 +495,7 @@ func @store_load_dynamic(%arg0: !llvm.i64) {
%20 = llvm.extractvalue %6[0] : !llvm<"{ float*, i64 }">
%21 = llvm.getelementptr %20[%17] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
%22 = llvm.load %21 : !llvm<"float*">
%23 = llvm.constant(1 : index) : !llvm.i64
%23 = llvm.mlir.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %{{[0-9]+}} = add i64 %{{[0-9]+}}, 1
%24 = llvm.add %17, %23 : !llvm.i64
// CHECK-NEXT: br label %{{[0-9]+}}
@ -507,7 +507,7 @@ func @store_load_dynamic(%arg0: !llvm.i64) {
// CHECK-LABEL: define void @store_load_mixed(i64 {{%.*}})
func @store_load_mixed(%arg0: !llvm.i64) {
%0 = llvm.constant(10 : index) : !llvm.i64
%0 = llvm.mlir.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %{{[0-9]+}} = mul i64 2, %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 4
// CHECK-NEXT: %{{[0-9]+}} = mul i64 %{{[0-9]+}}, 10
@ -517,13 +517,13 @@ func @store_load_mixed(%arg0: !llvm.i64) {
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } undef, float* %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64, i64 } %{{[0-9]+}}, i64 10, 2
%1 = llvm.constant(2 : index) : !llvm.i64
%2 = llvm.constant(4 : index) : !llvm.i64
%1 = llvm.mlir.constant(2 : index) : !llvm.i64
%2 = llvm.mlir.constant(4 : index) : !llvm.i64
%3 = llvm.mul %1, %arg0 : !llvm.i64
%4 = llvm.mul %3, %2 : !llvm.i64
%5 = llvm.mul %4, %0 : !llvm.i64
%6 = llvm.undef : !llvm<"{ float*, i64, i64 }">
%7 = llvm.constant(4 : index) : !llvm.i64
%6 = llvm.mlir.undef : !llvm<"{ float*, i64, i64 }">
%7 = llvm.mlir.constant(4 : index) : !llvm.i64
%8 = llvm.mul %5, %7 : !llvm.i64
%9 = llvm.call @malloc(%8) : (!llvm.i64) -> !llvm<"i8*">
%10 = llvm.bitcast %9 : !llvm<"i8*"> to !llvm<"float*">
@ -533,12 +533,12 @@ func @store_load_mixed(%arg0: !llvm.i64) {
// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
%14 = llvm.constant(1 : index) : !llvm.i64
%15 = llvm.constant(2 : index) : !llvm.i64
%14 = llvm.mlir.constant(1 : index) : !llvm.i64
%15 = llvm.mlir.constant(2 : index) : !llvm.i64
%16 = llvm.call @get_index() : () -> !llvm.i64
%17 = llvm.call @get_index() : () -> !llvm.i64
%18 = llvm.constant(4.200000e+01 : f32) : !llvm.float
%19 = llvm.constant(2 : index) : !llvm.i64
%18 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float
%19 = llvm.mlir.constant(2 : index) : !llvm.i64
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 2
// CHECK-NEXT: %{{[0-9]+}} = mul i64 1, %{{[0-9]+}}
@ -551,7 +551,7 @@ func @store_load_mixed(%arg0: !llvm.i64) {
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
%20 = llvm.extractvalue %13[1] : !llvm<"{ float*, i64, i64 }">
%21 = llvm.constant(4 : index) : !llvm.i64
%21 = llvm.mlir.constant(4 : index) : !llvm.i64
%22 = llvm.extractvalue %13[2] : !llvm<"{ float*, i64, i64 }">
%23 = llvm.mul %14, %20 : !llvm.i64
%24 = llvm.add %23, %15 : !llvm.i64
@ -573,9 +573,9 @@ func @store_load_mixed(%arg0: !llvm.i64) {
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: %{{[0-9]+}} = load float, float* %{{[0-9]+}}
%31 = llvm.constant(2 : index) : !llvm.i64
%31 = llvm.mlir.constant(2 : index) : !llvm.i64
%32 = llvm.extractvalue %13[1] : !llvm<"{ float*, i64, i64 }">
%33 = llvm.constant(4 : index) : !llvm.i64
%33 = llvm.mlir.constant(4 : index) : !llvm.i64
%34 = llvm.extractvalue %13[2] : !llvm<"{ float*, i64, i64 }">
%35 = llvm.mul %17, %32 : !llvm.i64
%36 = llvm.add %35, %16 : !llvm.i64
@ -592,14 +592,14 @@ func @store_load_mixed(%arg0: !llvm.i64) {
// CHECK-LABEL: define { float*, i64 } @memref_args_rets({ float* } {{%.*}}, { float*, i64 } {{%.*}}, { float*, i64 } {{%.*}}) {
func @memref_args_rets(%arg0: !llvm<"{ float* }">, %arg1: !llvm<"{ float*, i64 }">, %arg2: !llvm<"{ float*, i64 }">) -> !llvm<"{ float*, i64 }"> {
%0 = llvm.constant(7 : index) : !llvm.i64
%0 = llvm.mlir.constant(7 : index) : !llvm.i64
// CHECK-NEXT: %{{[0-9]+}} = call i64 @get_index()
%1 = llvm.call @get_index() : () -> !llvm.i64
%2 = llvm.constant(4.200000e+01 : f32) : !llvm.float
%2 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float* } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 7
// CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
%3 = llvm.constant(10 : index) : !llvm.i64
%3 = llvm.mlir.constant(10 : index) : !llvm.i64
%4 = llvm.extractvalue %arg0[0] : !llvm<"{ float* }">
%5 = llvm.getelementptr %4[%0] : (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
llvm.store %2, %5 : !llvm<"float*">
@ -617,7 +617,7 @@ func @memref_args_rets(%arg0: !llvm<"{ float* }">, %arg1: !llvm<"{ float*, i64 }
// CHECK-NEXT: %{{[0-9]+}} = extractvalue { float*, i64 } %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = getelementptr float, float* %{{[0-9]+}}, i64 %{{[0-9]+}}
// CHECK-NEXT: store float 4.200000e+01, float* %{{[0-9]+}}
%9 = llvm.constant(10 : index) : !llvm.i64
%9 = llvm.mlir.constant(10 : index) : !llvm.i64
%10 = llvm.extractvalue %arg2[1] : !llvm<"{ float*, i64 }">
%11 = llvm.mul %0, %10 : !llvm.i64
%12 = llvm.add %11, %1 : !llvm.i64
@ -630,10 +630,10 @@ func @memref_args_rets(%arg0: !llvm<"{ float* }">, %arg1: !llvm<"{ float*, i64 }
// CHECK-NEXT: %{{[0-9]+}} = bitcast i8* %{{[0-9]+}} to float*
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } undef, float* %{{[0-9]+}}, 0
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { float*, i64 } %{{[0-9]+}}, i64 %{{[0-9]+}}, 1
%15 = llvm.constant(10 : index) : !llvm.i64
%15 = llvm.mlir.constant(10 : index) : !llvm.i64
%16 = llvm.mul %15, %1 : !llvm.i64
%17 = llvm.undef : !llvm<"{ float*, i64 }">
%18 = llvm.constant(4 : index) : !llvm.i64
%17 = llvm.mlir.undef : !llvm<"{ float*, i64 }">
%18 = llvm.mlir.constant(4 : index) : !llvm.i64
%19 = llvm.mul %16, %18 : !llvm.i64
%20 = llvm.call @malloc(%19) : (!llvm.i64) -> !llvm<"i8*">
%21 = llvm.bitcast %20 : !llvm<"i8*"> to !llvm<"float*">
@ -647,11 +647,11 @@ func @memref_args_rets(%arg0: !llvm<"{ float* }">, %arg1: !llvm<"{ float*, i64 }
// CHECK-LABEL: define i64 @memref_dim({ float*, i64, i64 } {{%.*}})
func @memref_dim(%arg0: !llvm<"{ float*, i64, i64 }">) -> !llvm.i64 {
// Expecting this to create an LLVM constant.
%0 = llvm.constant(42 : index) : !llvm.i64
%0 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK-NEXT: %2 = extractvalue { float*, i64, i64 } %0, 1
%1 = llvm.extractvalue %arg0[1] : !llvm<"{ float*, i64, i64 }">
// Expecting this to create an LLVM constant.
%2 = llvm.constant(10 : index) : !llvm.i64
%2 = llvm.mlir.constant(10 : index) : !llvm.i64
// CHECK-NEXT: %3 = extractvalue { float*, i64, i64 } %0, 2
%3 = llvm.extractvalue %arg0[2] : !llvm<"{ float*, i64, i64 }">
// Checking that the constant for d0 has been created.
@ -679,7 +679,7 @@ func @multireturn() -> !llvm<"{ i64, float, { float*, i64, i64 } }"> {
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, float %{{[0-9]+}}, 1
// CHECK-NEXT: %{{[0-9]+}} = insertvalue { i64, float, { float*, i64, i64 } } %{{[0-9]+}}, { float*, i64, i64 } %{{[0-9]+}}, 2
// CHECK-NEXT: ret { i64, float, { float*, i64, i64 } } %{{[0-9]+}}
%3 = llvm.undef : !llvm<"{ i64, float, { float*, i64, i64 } }">
%3 = llvm.mlir.undef : !llvm<"{ i64, float, { float*, i64, i64 } }">
%4 = llvm.insertvalue %0, %3[0] : !llvm<"{ i64, float, { float*, i64, i64 } }">
%5 = llvm.insertvalue %1, %4[1] : !llvm<"{ i64, float, { float*, i64, i64 } }">
%6 = llvm.insertvalue %2, %5[2] : !llvm<"{ i64, float, { float*, i64, i64 } }">
@ -697,17 +697,17 @@ func @multireturn_caller() {
%1 = llvm.extractvalue %0[0] : !llvm<"{ i64, float, { float*, i64, i64 } }">
%2 = llvm.extractvalue %0[1] : !llvm<"{ i64, float, { float*, i64, i64 } }">
%3 = llvm.extractvalue %0[2] : !llvm<"{ i64, float, { float*, i64, i64 } }">
%4 = llvm.constant(42) : !llvm.i64
%4 = llvm.mlir.constant(42) : !llvm.i64
// CHECK: add i64 [[ret0]], 42
%5 = llvm.add %1, %4 : !llvm.i64
%6 = llvm.constant(4.200000e+01 : f32) : !llvm.float
%6 = llvm.mlir.constant(4.200000e+01 : f32) : !llvm.float
// CHECK: fadd float [[ret1]], 4.200000e+01
%7 = llvm.fadd %2, %6 : !llvm.float
%8 = llvm.constant(0 : index) : !llvm.i64
%9 = llvm.constant(42 : index) : !llvm.i64
%8 = llvm.mlir.constant(0 : index) : !llvm.i64
%9 = llvm.mlir.constant(42 : index) : !llvm.i64
// CHECK: extractvalue { float*, i64, i64 } [[ret2]], 0
%10 = llvm.extractvalue %3[1] : !llvm<"{ float*, i64, i64 }">
%11 = llvm.constant(10 : index) : !llvm.i64
%11 = llvm.mlir.constant(10 : index) : !llvm.i64
%12 = llvm.extractvalue %3[2] : !llvm<"{ float*, i64, i64 }">
%13 = llvm.mul %8, %10 : !llvm.i64
%14 = llvm.add %13, %8 : !llvm.i64
@ -723,7 +723,7 @@ func @multireturn_caller() {
// CHECK-LABEL: define <4 x float> @vector_ops(<4 x float> {{%.*}}, <4 x i1> {{%.*}}, <4 x i64> {{%.*}}) {
func @vector_ops(%arg0: !llvm<"<4 x float>">, %arg1: !llvm<"<4 x i1>">, %arg2: !llvm<"<4 x i64>">) -> !llvm<"<4 x float>"> {
%0 = llvm.constant(dense<4.200000e+01> : vector<4xf32>) : !llvm<"<4 x float>">
%0 = llvm.mlir.constant(dense<4.200000e+01> : vector<4xf32>) : !llvm<"<4 x float>">
// CHECK-NEXT: %4 = fadd <4 x float> %0, <float 4.200000e+01, float 4.200000e+01, float 4.200000e+01, float 4.200000e+01>
%1 = llvm.fadd %arg0, %0 : !llvm<"<4 x float>">
// CHECK-NEXT: %5 = select <4 x i1> %1, <4 x float> %4, <4 x float> %0
@ -769,7 +769,7 @@ func @ops(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.i32, %arg3: !llvm
// CHECK-NEXT: %12 = urem i32 %2, %3
%7 = llvm.urem %arg2, %arg3 : !llvm.i32
%8 = llvm.undef : !llvm<"{ float, i32 }">
%8 = llvm.mlir.undef : !llvm<"{ float, i32 }">
%9 = llvm.insertvalue %0, %8[0] : !llvm<"{ float, i32 }">
%10 = llvm.insertvalue %3, %9[1] : !llvm<"{ float, i32 }">
@ -795,7 +795,7 @@ func @ops(%arg0: !llvm.float, %arg1: !llvm.float, %arg2: !llvm.i32, %arg3: !llvm
// CHECK-LABEL: define void @indirect_const_call(i64 {{%.*}}) {
func @indirect_const_call(%arg0: !llvm.i64) {
// CHECK-NEXT: call void @body(i64 %0)
%0 = llvm.constant(@body) : !llvm<"void (i64)*">
%0 = llvm.mlir.constant(@body) : !llvm<"void (i64)*">
llvm.call %0(%arg0) : (!llvm.i64) -> ()
// CHECK-NEXT: ret void
llvm.return
@ -849,7 +849,7 @@ func @intpointerconversion(%arg0 : !llvm.i32) -> !llvm.i32 {
}
func @stringconstant() -> !llvm<"i8*"> {
%1 = llvm.constant("Hello world!") : !llvm<"i8*">
%1 = llvm.mlir.constant("Hello world!") : !llvm<"i8*">
// CHECK: ret [12 x i8] c"Hello world!"
llvm.return %1 : !llvm<"i8*">
}
@ -916,7 +916,7 @@ func @alloca(%size : !llvm.i64) {
// CHECK-LABEL: @constants
func @constants() -> !llvm<"<4 x float>"> {
// CHECK: ret <4 x float> <float 4.2{{0*}}e+01, float 0.{{0*}}e+00, float 0.{{0*}}e+00, float 0.{{0*}}e+00>
%0 = llvm.constant(sparse<[[0]], [4.2e+01]> : vector<4xf32>) : !llvm<"<4 x float>">
%0 = llvm.mlir.constant(sparse<[[0]], [4.2e+01]> : vector<4xf32>) : !llvm<"<4 x float>">
llvm.return %0 : !llvm<"<4 x float>">
}