string builderFunc, list<OpTrait> traits = []> :
LLVM_OneResultOp<mnemonic,
!listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
- Arguments<(ins LLVM_ScalarOrVectorOf<type>:$lhs,
- LLVM_ScalarOrVectorOf<type>:$rhs)>,
LLVM_Builder<"$res = builder." # builderFunc # "($lhs, $rhs);"> {
+ let arguments = (ins LLVM_ScalarOrVectorOf<type>:$lhs,
+ LLVM_ScalarOrVectorOf<type>:$rhs);
let parser =
[{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
let printer = [{ mlir::impl::printOneResultOp(this->getOperation(), p); }];
string builderFunc, list<OpTrait> traits = []> :
LLVM_OneResultOp<mnemonic,
!listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
- Arguments<(ins type:$operand)>,
LLVM_Builder<"$res = builder." # builderFunc # "($operand);"> {
+ let arguments = (ins type:$operand);
let parser =
[{ return impl::parseOneResultSameOperandTypeOp(parser, result); }];
let printer = [{ mlir::impl::printOneResultOp(this->getOperation(), p); }];
}
// Other integer operations.
-def LLVM_ICmpOp : LLVM_OneResultOp<"icmp", [NoSideEffect]>,
- Arguments<(ins ICmpPredicate:$predicate,
- LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$lhs,
- LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$rhs)> {
+def LLVM_ICmpOp : LLVM_OneResultOp<"icmp", [NoSideEffect]> {
+ let arguments = (ins ICmpPredicate:$predicate,
+ LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$lhs,
+ LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$rhs);
let llvmBuilder = [{
$res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
}];
}
// Other integer operations.
-def LLVM_FCmpOp : LLVM_OneResultOp<"fcmp", [NoSideEffect]>,
- Arguments<(ins FCmpPredicate:$predicate,
- LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$lhs,
- LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$rhs)> {
+def LLVM_FCmpOp : LLVM_OneResultOp<"fcmp", [NoSideEffect]> {
+ let arguments = (ins FCmpPredicate:$predicate,
+ LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$lhs,
+ LLVM_ScalarOrVectorOf<LLVM_AnyFloat>:$rhs);
let llvmBuilder = [{
$res = builder.CreateFCmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
}];
// Memory-related operations.
def LLVM_AllocaOp :
MemoryOpWithAlignmentBase,
- LLVM_OneResultOp<"alloca">,
- Arguments<(ins LLVM_AnyInteger:$arraySize,
- OptionalAttr<I64Attr>:$alignment)> {
+ LLVM_OneResultOp<"alloca"> {
+ let arguments = (ins LLVM_AnyInteger:$arraySize,
+ OptionalAttr<I64Attr>:$alignment);
string llvmBuilder = [{
auto *inst = builder.CreateAlloca(
$_resultType->getPointerElementType(), $arraySize);
}
def LLVM_GEPOp : LLVM_OneResultOp<"getelementptr", [NoSideEffect]>,
- Arguments<(ins LLVM_ScalarOrVectorOf<LLVM_AnyPointer>:$base,
- Variadic<LLVM_ScalarOrVectorOf<
- LLVM_AnyInteger>>:$indices)>,
LLVM_Builder<"$res = builder.CreateGEP($base, $indices);"> {
+ let arguments = (ins LLVM_ScalarOrVectorOf<LLVM_AnyPointer>:$base,
+ Variadic<LLVM_ScalarOrVectorOf<LLVM_AnyInteger>>:$indices);
let assemblyFormat = [{
$base `[` $indices `]` attr-dict `:` functional-type(operands, results)
}];
}
+
def LLVM_LoadOp :
MemoryOpWithAlignmentAndAttributes,
- LLVM_OneResultOp<"load">,
- Arguments<(ins LLVM_PointerTo<LLVM_LoadableType>:$addr,
- OptionalAttr<I64Attr>:$alignment,
- UnitAttr:$volatile_,
- UnitAttr:$nontemporal)> {
+ LLVM_OneResultOp<"load"> {
+ let arguments = (ins LLVM_PointerTo<LLVM_LoadableType>:$addr,
+ OptionalAttr<I64Attr>:$alignment, UnitAttr:$volatile_,
+ UnitAttr:$nontemporal);
string llvmBuilder = [{
auto *inst = builder.CreateLoad($addr, $volatile_);
}] # setAlignmentCode # setNonTemporalMetadataCode # [{
}
def LLVM_StoreOp :
MemoryOpWithAlignmentAndAttributes,
- LLVM_ZeroResultOp<"store">,
- Arguments<(ins LLVM_LoadableType:$value,
+ LLVM_ZeroResultOp<"store"> {
+ let arguments = (ins LLVM_LoadableType:$value,
LLVM_PointerTo<LLVM_LoadableType>:$addr,
- OptionalAttr<I64Attr>:$alignment,
- UnitAttr:$volatile_,
- UnitAttr:$nontemporal)> {
+ OptionalAttr<I64Attr>:$alignment, UnitAttr:$volatile_,
+ UnitAttr:$nontemporal);
string llvmBuilder = [{
auto *inst = builder.CreateStore($value, $addr, $volatile_);
}] # setAlignmentCode # setNonTemporalMetadataCode;
list<OpTrait> traits = []> :
LLVM_OneResultOp<mnemonic,
!listconcat([NoSideEffect], traits)>,
- Arguments<(ins type:$arg)>,
LLVM_Builder<"$res = builder." # builderFunc # "($arg, $_resultType);"> {
+ let arguments = (ins type:$arg);
let parser = [{ return mlir::impl::parseCastOp(parser, result); }];
let printer = [{ mlir::impl::printCastOp(this->getOperation(), p); }];
}
DeclareOpInterfaceMethods<BranchOpInterface>,
Terminator
]>,
- Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
- Variadic<LLVM_Type>:$operands,
- Variadic<LLVM_Type>:$normalDestOperands,
- Variadic<LLVM_Type>:$unwindDestOperands)>,
Results<(outs Variadic<LLVM_Type>)> {
+ let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
+ Variadic<LLVM_Type>:$operands,
+ Variadic<LLVM_Type>:$normalDestOperands,
+ Variadic<LLVM_Type>:$unwindDestOperands);
let successors = (successor AnySuccessor:$normalDest,
AnySuccessor:$unwindDest);
let printer = [{ printInvokeOp(p, *this); }];
}
-def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad">,
- Arguments<(ins UnitAttr:$cleanup,
- Variadic<LLVM_Type>)> {
+def LLVM_LandingpadOp : LLVM_OneResultOp<"landingpad"> {
+ let arguments = (ins UnitAttr:$cleanup, Variadic<LLVM_Type>);
let verifier = [{ return ::verify(*this); }];
let parser = [{ return parseLandingpadOp(parser, result); }];
let printer = [{ printLandingpadOp(p, *this); }];
}
def LLVM_CallOp : LLVM_Op<"call">,
- Arguments<(ins OptionalAttr<FlatSymbolRefAttr>:$callee,
- Variadic<LLVM_Type>)>,
Results<(outs Variadic<LLVM_Type>)> {
+ let arguments = (ins OptionalAttr<FlatSymbolRefAttr>:$callee,
+ Variadic<LLVM_Type>);
let builders = [OpBuilder<
"LLVMFuncOp func, ValueRange operands, "
"ArrayRef<NamedAttribute> attributes = {}",
let parser = [{ return parseCallOp(parser, result); }];
let printer = [{ printCallOp(p, *this); }];
}
-def LLVM_ExtractElementOp : LLVM_OneResultOp<"extractelement", [NoSideEffect]>,
- Arguments<(ins LLVM_AnyVector:$vector,
- LLVM_AnyInteger:$position)> {
+def LLVM_ExtractElementOp : LLVM_OneResultOp<"extractelement", [NoSideEffect]> {
+ let arguments = (ins LLVM_AnyVector:$vector, LLVM_AnyInteger:$position);
string llvmBuilder = [{
$res = builder.CreateExtractElement($vector, $position);
}];
let parser = [{ return parseExtractElementOp(parser, result); }];
let printer = [{ printExtractElementOp(p, *this); }];
}
-def LLVM_ExtractValueOp : LLVM_OneResultOp<"extractvalue", [NoSideEffect]>,
- Arguments<(ins LLVM_AnyAggregate:$container,
- ArrayAttr:$position)> {
+def LLVM_ExtractValueOp : LLVM_OneResultOp<"extractvalue", [NoSideEffect]> {
+ let arguments = (ins LLVM_AnyAggregate:$container, ArrayAttr:$position);
string llvmBuilder = [{
$res = builder.CreateExtractValue($container, extractPosition($position));
}];
let parser = [{ return parseExtractValueOp(parser, result); }];
let printer = [{ printExtractValueOp(p, *this); }];
}
-def LLVM_InsertElementOp : LLVM_OneResultOp<"insertelement", [NoSideEffect]>,
- Arguments<(ins LLVM_AnyVector:$vector,
- LLVM_PrimitiveType:$value,
- LLVM_AnyInteger:$position)> {
+def LLVM_InsertElementOp : LLVM_OneResultOp<"insertelement", [NoSideEffect]> {
+ let arguments = (ins LLVM_AnyVector:$vector, LLVM_PrimitiveType:$value,
+ LLVM_AnyInteger:$position);
string llvmBuilder = [{
$res = builder.CreateInsertElement($vector, $value, $position);
}];
let parser = [{ return parseInsertElementOp(parser, result); }];
let printer = [{ printInsertElementOp(p, *this); }];
}
-def LLVM_InsertValueOp : LLVM_OneResultOp<"insertvalue", [NoSideEffect]>,
- Arguments<(ins LLVM_AnyAggregate:$container,
- LLVM_PrimitiveType:$value,
- ArrayAttr:$position)> {
+def LLVM_InsertValueOp : LLVM_OneResultOp<"insertvalue", [NoSideEffect]> {
+ let arguments = (ins LLVM_AnyAggregate:$container, LLVM_PrimitiveType:$value,
+ ArrayAttr:$position);
string llvmBuilder = [{
$res = builder.CreateInsertValue($container, $value,
extractPosition($position));
let parser = [{ return parseInsertValueOp(parser, result); }];
let printer = [{ printInsertValueOp(p, *this); }];
}
-def LLVM_ShuffleVectorOp
- : LLVM_OneResultOp<"shufflevector", [NoSideEffect]>,
- Arguments<(ins LLVM_AnyVector:$v1, LLVM_AnyVector:$v2, ArrayAttr:$mask)> {
+def LLVM_ShuffleVectorOp : LLVM_OneResultOp<"shufflevector", [NoSideEffect]> {
+ let arguments = (ins LLVM_AnyVector:$v1, LLVM_AnyVector:$v2, ArrayAttr:$mask);
string llvmBuilder = [{
SmallVector<unsigned, 4> position = extractPosition($mask);
SmallVector<int, 4> mask(position.begin(), position.end());
def LLVM_SelectOp
: LLVM_OneResultOp<"select",
[NoSideEffect, AllTypesMatch<["trueValue", "falseValue", "res"]>]>,
- Arguments<(ins LLVM_ScalarOrVectorOf<LLVM_i1>:$condition,
- LLVM_Type:$trueValue,
- LLVM_Type:$falseValue)>,
LLVM_Builder<
"$res = builder.CreateSelect($condition, $trueValue, $falseValue);"> {
+ let arguments = (ins LLVM_ScalarOrVectorOf<LLVM_i1>:$condition,
+ LLVM_Type:$trueValue, LLVM_Type:$falseValue);
let builders = [OpBuilder<
"Value condition, Value lhs, Value rhs", [{
build($_builder, $_state, lhs.getType(), condition, lhs, rhs);
}]>];
let assemblyFormat = "operands attr-dict `:` type($condition) `,` type($res)";
}
-def LLVM_FreezeOp : LLVM_OneResultOp<"freeze", [SameOperandsAndResultType]>,
- Arguments<(ins LLVM_Type:$val)> {
+def LLVM_FreezeOp : LLVM_OneResultOp<"freeze", [SameOperandsAndResultType]> {
+ let arguments = (ins LLVM_Type:$val);
let assemblyFormat = "$val attr-dict `:` type($val)";
string llvmBuilder = "builder.CreateFreeze($val);";
}
falseOperands);
}]>, LLVM_TerminatorPassthroughOpBuilder];
}
-def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [NoSideEffect]>,
- Arguments<(ins Variadic<LLVM_Type>:$args)> {
+def LLVM_ReturnOp : LLVM_TerminatorOp<"return", [NoSideEffect]> {
+ let arguments = (ins Variadic<LLVM_Type>:$args);
string llvmBuilder = [{
if ($_numOperands != 0)
builder.CreateRet($args[0]);
}
-def LLVM_AddressOfOp
- : LLVM_OneResultOp<"mlir.addressof">,
- Arguments<(ins FlatSymbolRefAttr:$global_name)> {
+def LLVM_AddressOfOp : LLVM_OneResultOp<"mlir.addressof"> {
+ let arguments = (ins FlatSymbolRefAttr:$global_name);
+
let summary = "Creates a pointer pointing to a global or a function";
let builders = [
def LLVM_LLVMFuncOp
: LLVM_ZeroResultOp<"func", [AutomaticAllocationScope, IsolatedFromAbove,
- FunctionLike, Symbol]>,
- Arguments<(ins DefaultValuedAttr<Linkage,
- "Linkage::External">:$linkage,
- OptionalAttr<FlatSymbolRefAttr>:$personality,
- OptionalAttr<ArrayAttr>:$passthrough)> {
+ FunctionLike, Symbol]> {
let summary = "LLVM dialect function, has wrapped LLVM IR function type";
+ let arguments = (ins DefaultValuedAttr<Linkage, "Linkage::External">:$linkage,
+ OptionalAttr<FlatSymbolRefAttr>:$personality,
+ OptionalAttr<ArrayAttr>:$passthrough);
+
let regions = (region AnyRegion:$body);
let skipDefaultBuilders = 1;
}
def LLVM_ConstantOp
: LLVM_OneResultOp<"mlir.constant", [NoSideEffect]>,
- Arguments<(ins AnyAttr:$value)>,
LLVM_Builder<"$res = getLLVMConstant($_resultType, $value, $_location);">
{
+ let arguments = (ins AnyAttr:$value);
let assemblyFormat = "`(` $value `)` attr-dict `:` type($res)";
let verifier = [{ return ::verify(*this); }];
}
def LLVM_DialectCastOp : LLVM_Op<"mlir.cast", [NoSideEffect]>,
- Results<(outs AnyType:$res)>,
- Arguments<(ins AnyType:$in)> {
+ Results<(outs AnyType:$res)> {
let summary = "Type cast between LLVM dialect and Standard.";
let description = [{
llvm.mlir.cast op casts between Standard and LLVM dialects. It only changes
llvm.mlir.cast %v : llvm.float to f32
llvm.mlir.cast %v : !llvm<"<2 x float>"> to vector<2xf32>
}];
+ let arguments = (ins AnyType:$in);
let assemblyFormat = "$in attr-dict `:` type($in) `to` type($res)";
let verifier = "return ::verify(*this);";
}
class LLVM_UnaryIntrinsicOp<string func, list<OpTrait> traits = []> :
LLVM_OneResultIntrOp<func, [], [0],
- !listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
- Arguments<(ins LLVM_Type:$in)>;
+ !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
+ let arguments = (ins LLVM_Type:$in);
+}
class LLVM_BinarySameArgsIntrinsicOp<string func, list<OpTrait> traits = []> :
LLVM_OneResultIntrOp<func, [], [0],
- !listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
- Arguments<(ins LLVM_Type:$a, LLVM_Type:$b)>;
+ !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
+ let arguments = (ins LLVM_Type:$a, LLVM_Type:$b);
+}
class LLVM_TernarySameArgsIntrinsicOp<string func, list<OpTrait> traits = []> :
LLVM_OneResultIntrOp<func, [], [0],
- !listconcat([NoSideEffect, SameOperandsAndResultType], traits)>,
- Arguments<(ins LLVM_Type:$a, LLVM_Type:$b, LLVM_Type:$c)>;
+ !listconcat([NoSideEffect, SameOperandsAndResultType], traits)> {
+ let arguments = (ins LLVM_Type:$a, LLVM_Type:$b, LLVM_Type:$c);
+}
def LLVM_CopySignOp : LLVM_BinarySameArgsIntrinsicOp<"copysign">;
def LLVM_CosOp : LLVM_UnaryIntrinsicOp<"cos">;
def LLVM_Log10Op : LLVM_UnaryIntrinsicOp<"log10">;
def LLVM_Log2Op : LLVM_UnaryIntrinsicOp<"log2">;
def LLVM_LogOp : LLVM_UnaryIntrinsicOp<"log">;
-def LLVM_Prefetch : LLVM_ZeroResultIntrOp<"prefetch", [0]>,
- Arguments<(ins LLVM_Type:$addr, LLVM_Type:$rw,
- LLVM_Type:$hint, LLVM_Type:$cache)>;
+def LLVM_Prefetch : LLVM_ZeroResultIntrOp<"prefetch", [0]> {
+ let arguments = (ins LLVM_Type:$addr, LLVM_Type:$rw, LLVM_Type:$hint,
+ LLVM_Type:$cache);
+}
def LLVM_SinOp : LLVM_UnaryIntrinsicOp<"sin">;
def LLVM_SqrtOp : LLVM_UnaryIntrinsicOp<"sqrt">;
def LLVM_PowOp : LLVM_BinarySameArgsIntrinsicOp<"pow">;
def LLVM_SMaxOp : LLVM_BinarySameArgsIntrinsicOp<"smax">;
def LLVM_SMinOp : LLVM_BinarySameArgsIntrinsicOp<"smin">;
-def LLVM_MemcpyOp : LLVM_ZeroResultIntrOp<"memcpy", [0, 1, 2]>,
- Arguments<(ins LLVM_Type:$dst, LLVM_Type:$src,
- LLVM_Type:$len, LLVM_Type:$isVolatile)>;
-def LLVM_MemcpyInlineOp : LLVM_ZeroResultIntrOp<"memcpy.inline", [0, 1, 2]>,
- Arguments<(ins LLVM_Type:$dst, LLVM_Type:$src,
- LLVM_Type:$len, LLVM_Type:$isVolatile)>;
+def LLVM_MemcpyOp : LLVM_ZeroResultIntrOp<"memcpy", [0, 1, 2]> {
+ let arguments = (ins LLVM_Type:$dst, LLVM_Type:$src, LLVM_Type:$len,
+ LLVM_Type:$isVolatile);
+}
+def LLVM_MemcpyInlineOp : LLVM_ZeroResultIntrOp<"memcpy.inline", [0, 1, 2]> {
+ let arguments = (ins LLVM_Type:$dst, LLVM_Type:$src, LLVM_Type:$len,
+ LLVM_Type:$isVolatile);
+}
//
// Vector Reductions.
/// columns - Number of columns in matrix (must be a constant)
/// stride - Space between columns
def LLVM_MatrixColumnMajorLoadOp
- : LLVM_OneResultOp<"intr.matrix.column.major.load">,
- Arguments<(ins LLVM_Type:$data, LLVM_Type:$stride, I1Attr:$isVolatile,
- I32Attr:$rows, I32Attr:$columns)> {
+ : LLVM_OneResultOp<"intr.matrix.column.major.load"> {
+ let arguments = (ins LLVM_Type:$data, LLVM_Type:$stride, I1Attr:$isVolatile,
+ I32Attr:$rows, I32Attr:$columns);
string llvmBuilder = [{
llvm::MatrixBuilder<decltype(builder)> mb(builder);
const llvm::DataLayout &dl =
/// columns - Number of columns in matrix (must be a constant)
/// stride - Space between columns
def LLVM_MatrixColumnMajorStoreOp
- : LLVM_ZeroResultOp<"intr.matrix.column.major.store">,
- Arguments<(ins LLVM_Type:$matrix, LLVM_Type:$data, LLVM_Type:$stride,
- I1Attr:$isVolatile, I32Attr:$rows, I32Attr:$columns)> {
+ : LLVM_ZeroResultOp<"intr.matrix.column.major.store"> {
+ let arguments = (ins LLVM_Type:$matrix, LLVM_Type:$data, LLVM_Type:$stride,
+ I1Attr:$isVolatile, I32Attr:$rows, I32Attr:$columns);
string llvmBuilder = [{
llvm::MatrixBuilder<decltype(builder)> mb(builder);
const llvm::DataLayout &dl =
/// Create a llvm.matrix.multiply call, multiplying 2-D matrices LHS and RHS, as
/// specified in the LLVM MatrixBuilder.
def LLVM_MatrixMultiplyOp
- : LLVM_OneResultOp<"intr.matrix.multiply">,
- Arguments<(
- ins LLVM_Type:$lhs, LLVM_Type:$rhs,
- I32Attr:$lhs_rows, I32Attr:$lhs_columns, I32Attr:$rhs_columns)> {
+ : LLVM_OneResultOp<"intr.matrix.multiply"> {
+ let arguments = (ins LLVM_Type:$lhs, LLVM_Type:$rhs, I32Attr:$lhs_rows,
+ I32Attr:$lhs_columns, I32Attr:$rhs_columns);
string llvmBuilder = [{
llvm::MatrixBuilder<decltype(builder)> mb(builder);
$res = mb.CreateMatrixMultiply(
/// Create a llvm.matrix.transpose call, transposing a `rows` x `columns` 2-D
/// `matrix`, as specified in the LLVM MatrixBuilder.
-def LLVM_MatrixTransposeOp
- : LLVM_OneResultOp<"intr.matrix.transpose">,
- Arguments<(ins LLVM_Type:$matrix, I32Attr:$rows, I32Attr:$columns)> {
+def LLVM_MatrixTransposeOp : LLVM_OneResultOp<"intr.matrix.transpose"> {
+ let arguments = (ins LLVM_Type:$matrix, I32Attr:$rows, I32Attr:$columns);
string llvmBuilder = [{
llvm::MatrixBuilder<decltype(builder)> mb(builder);
$res = mb.CreateMatrixTranspose(
/// Create a llvm.get.active.lane.mask to set a mask up to a given position.
def LLVM_GetActiveLaneMaskOp
- : LLVM_OneResultIntrOp<"get.active.lane.mask", [0], [0], [NoSideEffect]>,
- Arguments<(ins LLVM_Type:$base, LLVM_Type:$n)> {
+ : LLVM_OneResultIntrOp<"get.active.lane.mask", [0], [0], [NoSideEffect]> {
+ let arguments = (ins LLVM_Type:$base, LLVM_Type:$n);
let assemblyFormat = "$base `,` $n attr-dict `:` "
"type($base) `,` type($n) `to` type($res)";
}
/// Create a call to Masked Load intrinsic.
-def LLVM_MaskedLoadOp
- : LLVM_OneResultOp<"intr.masked.load">,
- Arguments<(ins LLVM_Type:$data, LLVM_Type:$mask,
- Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment)> {
+def LLVM_MaskedLoadOp : LLVM_OneResultOp<"intr.masked.load"> {
+ let arguments = (ins LLVM_Type:$data, LLVM_Type:$mask,
+ Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment);
string llvmBuilder = [{
$res = $pass_thru.empty() ? builder.CreateMaskedLoad(
$data, llvm::Align($alignment), $mask) :
}
/// Create a call to Masked Store intrinsic.
-def LLVM_MaskedStoreOp
- : LLVM_ZeroResultOp<"intr.masked.store">,
- Arguments<(ins LLVM_Type:$value, LLVM_Type:$data, LLVM_Type:$mask,
- I32Attr:$alignment)> {
+def LLVM_MaskedStoreOp : LLVM_ZeroResultOp<"intr.masked.store"> {
+ let arguments = (ins LLVM_Type:$value, LLVM_Type:$data, LLVM_Type:$mask,
+ I32Attr:$alignment);
string llvmBuilder = [{
builder.CreateMaskedStore(
$value, $data, llvm::Align($alignment), $mask);
}
/// Create a call to Masked Gather intrinsic.
-def LLVM_masked_gather
- : LLVM_OneResultOp<"intr.masked.gather">,
- Arguments<(ins LLVM_Type:$ptrs, LLVM_Type:$mask,
- Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment)> {
+def LLVM_masked_gather : LLVM_OneResultOp<"intr.masked.gather"> {
+ let arguments = (ins LLVM_Type:$ptrs, LLVM_Type:$mask,
+ Variadic<LLVM_Type>:$pass_thru, I32Attr:$alignment);
string llvmBuilder = [{
$res = $pass_thru.empty() ? builder.CreateMaskedGather(
$ptrs, llvm::Align($alignment), $mask) :
}
/// Create a call to Masked Scatter intrinsic.
-def LLVM_masked_scatter
- : LLVM_ZeroResultOp<"intr.masked.scatter">,
- Arguments<(ins LLVM_Type:$value, LLVM_Type:$ptrs, LLVM_Type:$mask,
- I32Attr:$alignment)> {
+def LLVM_masked_scatter : LLVM_ZeroResultOp<"intr.masked.scatter"> {
+ let arguments = (ins LLVM_Type:$value, LLVM_Type:$ptrs, LLVM_Type:$mask,
+ I32Attr:$alignment);
string llvmBuilder = [{
builder.CreateMaskedScatter(
$value, $ptrs, llvm::Align($alignment), $mask);
}
/// Create a call to Masked Expand Load intrinsic.
-def LLVM_masked_expandload
- : LLVM_IntrOp<"masked.expandload", [0], [], [], 1>,
- Arguments<(ins LLVM_Type, LLVM_Type, LLVM_Type)>;
+def LLVM_masked_expandload : LLVM_IntrOp<"masked.expandload", [0], [], [], 1> {
+ let arguments = (ins LLVM_Type, LLVM_Type, LLVM_Type);
+}
/// Create a call to Masked Compress Store intrinsic.
def LLVM_masked_compressstore
- : LLVM_IntrOp<"masked.compressstore", [], [0], [], 0>,
- Arguments<(ins LLVM_Type, LLVM_Type, LLVM_Type)>;
+ : LLVM_IntrOp<"masked.compressstore", [], [0], [], 0> {
+ let arguments = (ins LLVM_Type, LLVM_Type, LLVM_Type);
+}
//
// Atomic operations.
def LLVM_AtomicRMWType : AnyTypeOf<[LLVM_AnyFloat, LLVM_AnyInteger]>;
def LLVM_AtomicRMWOp : LLVM_Op<"atomicrmw">,
- Arguments<(ins AtomicBinOp:$bin_op, LLVM_PointerTo<LLVM_AtomicRMWType>:$ptr,
- LLVM_AtomicRMWType:$val, AtomicOrdering:$ordering)>,
Results<(outs LLVM_Type:$res)> {
+ let arguments = (ins AtomicBinOp:$bin_op,
+ LLVM_PointerTo<LLVM_AtomicRMWType>:$ptr,
+ LLVM_AtomicRMWType:$val, AtomicOrdering:$ordering);
let llvmBuilder = [{
$res = builder.CreateAtomicRMW(getLLVMAtomicBinOp($bin_op), $ptr, $val,
getLLVMAtomicOrdering($ordering));
def LLVM_AtomicCmpXchgType : AnyTypeOf<[LLVM_AnyInteger, LLVM_AnyPointer]>;
-def LLVM_AtomicCmpXchgOp : LLVM_Op<"cmpxchg">,
- Arguments<(ins LLVM_PointerTo<LLVM_AtomicCmpXchgType>:$ptr,
+def LLVM_AtomicCmpXchgOp : LLVM_Op<"cmpxchg">, Results<(outs LLVM_Type:$res)> {
+ let arguments = (ins LLVM_PointerTo<LLVM_AtomicCmpXchgType>:$ptr,
LLVM_AtomicCmpXchgType:$cmp, LLVM_AtomicCmpXchgType:$val,
AtomicOrdering:$success_ordering,
- AtomicOrdering:$failure_ordering)>,
- Results<(outs LLVM_Type:$res)> {
+ AtomicOrdering:$failure_ordering);
let llvmBuilder = [{
$res = builder.CreateAtomicCmpXchg($ptr, $cmp, $val,
getLLVMAtomicOrdering($success_ordering),
let verifier = "return ::verify(*this);";
}
-def LLVM_AssumeOp : LLVM_Op<"intr.assume", []>,
- Arguments<(ins LLVM_Type:$cond)> {
+def LLVM_AssumeOp : LLVM_Op<"intr.assume", []> {
+ let arguments = (ins LLVM_Type:$cond);
let llvmBuilder = [{
llvm::Module *module = builder.GetInsertBlock()->getModule();
llvm::Function *fn =
}];
}
-def LLVM_FenceOp : LLVM_ZeroResultOp<"fence", []>,
- Arguments<(ins AtomicOrdering:$ordering,
- StrAttr:$syncscope)> {
+def LLVM_FenceOp : LLVM_ZeroResultOp<"fence", []> {
+ let arguments = (ins AtomicOrdering:$ordering, StrAttr:$syncscope);
let llvmBuilder = [{
llvm::LLVMContext &llvmContext = builder.getContext();
builder.CreateFence(getLLVMAtomicOrdering($ordering),