| //===-- SPIRVInstrInfo.td - Target Description for SPIR-V Target ----------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file describes the SPIR-V instructions in TableGen format. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| include "SPIRVInstrFormats.td" | |
| include "SPIRVSymbolicOperands.td" | |
| // Codegen only metadata instructions | |
| let isCodeGenOnly=1 in { | |
| def ASSIGN_TYPE: Pseudo<(outs ANYID:$dst_id), (ins ANYID:$src_id, TYPE:$src_ty)>; | |
| def DECL_TYPE: Pseudo<(outs ANYID:$dst_id), (ins ANYID:$src_id, TYPE:$src_ty)>; | |
| def GET_ID: Pseudo<(outs ID:$dst_id), (ins ANYID:$src)>; | |
| def GET_fID: Pseudo<(outs fID:$dst_id), (ins ANYID:$src)>; | |
| def GET_pID: Pseudo<(outs pID:$dst_id), (ins ANYID:$src)>; | |
| def GET_vID: Pseudo<(outs vID:$dst_id), (ins ANYID:$src)>; | |
| def GET_vfID: Pseudo<(outs vfID:$dst_id), (ins ANYID:$src)>; | |
| } | |
| def SPVTypeBin : SDTypeProfile<1, 2, []>; | |
| def assigntype : SDNode<"SPIRVISD::AssignType", SPVTypeBin>; | |
| def : GINodeEquiv<ASSIGN_TYPE, assigntype>; | |
| class BinOp<string name, bits<16> opCode, list<dag> pattern=[]> | |
| : Op<opCode, (outs ANYID:$dst), (ins TYPE:$src_ty, ANYID:$src, ANYID:$src2), | |
| "$dst = "#name#" $src_ty $src $src2", pattern>; | |
| class BinOpTyped<string name, bits<16> opCode, RegisterClass CID, SDNode node> | |
| : Op<opCode, (outs ID:$dst), (ins TYPE:$src_ty, CID:$src, CID:$src2), | |
| "$dst = "#name#" $src_ty $src $src2", [(set ID:$dst, (assigntype (node CID:$src, CID:$src2), TYPE:$src_ty))]>; | |
| class TernOpTyped<string name, bits<16> opCode, RegisterClass CCond, RegisterClass CID, SDNode node> | |
| : Op<opCode, (outs ID:$dst), (ins TYPE:$src_ty, CCond:$cond, CID:$src1, CID:$src2), | |
| "$dst = "#name#" $src_ty $cond $src1 $src2", [(set ID:$dst, (assigntype (node CCond:$cond, CID:$src1, CID:$src2), TYPE:$src_ty))]>; | |
| multiclass BinOpTypedGen<string name, bits<16> opCode, SDNode node, bit genF = 0, bit genV = 0> { | |
| if genF then | |
| def S: BinOpTyped<name, opCode, fID, node>; | |
| else | |
| def S: BinOpTyped<name, opCode, ID, node>; | |
| if genV then { | |
| if genF then | |
| def V: BinOpTyped<name, opCode, vfID, node>; | |
| else | |
| def V: BinOpTyped<name, opCode, vID, node>; | |
| } | |
| } | |
| multiclass TernOpTypedGen<string name, bits<16> opCode, SDNode node, bit genI = 1, bit genF = 0, bit genV = 0> { | |
| if genF then { | |
| def SFSCond: TernOpTyped<name, opCode, ID, fID, node>; | |
| def SFVCond: TernOpTyped<name, opCode, vID, fID, node>; | |
| } | |
| if genI then { | |
| def SISCond: TernOpTyped<name, opCode, ID, ID, node>; | |
| def SIVCond: TernOpTyped<name, opCode, vID, ID, node>; | |
| } | |
| if genV then { | |
| if genF then { | |
| def VFSCond: TernOpTyped<name, opCode, ID, vfID, node>; | |
| def VFVCond: TernOpTyped<name, opCode, vID, vfID, node>; | |
| } | |
| if genI then { | |
| def VISCond: TernOpTyped<name, opCode, ID, vID, node>; | |
| def VIVCond: TernOpTyped<name, opCode, vID, vID, node>; | |
| } | |
| } | |
| } | |
| class UnOp<string name, bits<16> opCode, list<dag> pattern=[]> | |
| : Op<opCode, (outs ANYID:$dst), (ins TYPE:$type, ANYID:$src), | |
| "$dst = "#name#" $type $src", pattern>; | |
| class UnOpTyped<string name, bits<16> opCode, RegisterClass CID, SDNode node> | |
| : Op<opCode, (outs ID:$dst), (ins TYPE:$src_ty, CID:$src), | |
| "$dst = "#name#" $src_ty $src", [(set ID:$dst, (assigntype (node CID:$src), TYPE:$src_ty))]>; | |
| class SimpleOp<string name, bits<16> opCode>: Op<opCode, (outs), (ins), name>; | |
| // 3.42.1 Miscellaneous Instructions | |
| def OpNop: SimpleOp<"OpNop", 0>; | |
| def OpUndef: Op<1, (outs ID:$res), (ins TYPE:$type), "$res = OpUndef $type">; | |
| def OpSizeOf: Op<321, (outs ID:$res), (ins TYPE:$ty, ID:$ptr), "$res = OpSizeOf $ty $ptr">; | |
| // 3.42.2 Debug Instructions | |
| def OpSourceContinued: Op<2, (outs), (ins StringImm:$str, variable_ops), | |
| "OpSourceContinued $str">; | |
| def OpSource: Op<3, (outs), (ins SourceLanguage:$lang, i32imm:$version, variable_ops), | |
| "OpSource $lang $version">; | |
| def OpSourceExtension: Op<4, (outs), (ins StringImm:$extension, variable_ops), | |
| "OpSourceExtension $extension">; | |
| def OpName: Op<5, (outs), (ins ANY:$tar, StringImm:$name, variable_ops), "OpName $tar $name">; | |
| def OpMemberName: Op<6, (outs), (ins TYPE:$ty, i32imm:$mem, StringImm:$name, variable_ops), | |
| "OpMemberName $ty $mem $name">; | |
| def OpString: Op<7, (outs ID:$r), (ins StringImm:$s, variable_ops), "$r = OpString $s">; | |
| def OpLine: Op<8, (outs), (ins ID:$file, i32imm:$ln, i32imm:$col), "OpLine $file $ln $col">; | |
| def OpNoLine: Op<317, (outs), (ins), "OpNoLine">; | |
| def OpModuleProcessed: Op<330, (outs), (ins StringImm:$process, variable_ops), | |
| "OpModuleProcessed $process">; | |
| // 3.42.3 Annotation Instructions | |
| def OpDecorate: Op<71, (outs), (ins ANY:$target, Decoration:$dec, variable_ops), | |
| "OpDecorate $target $dec">; | |
| def OpMemberDecorate: Op<72, (outs), (ins TYPE:$t, i32imm:$m, Decoration:$d, variable_ops), | |
| "OpMemberDecorate $t $m $d">; | |
| // TODO Currently some deprecated opcodes are missing: OpDecorationGroup, | |
| // OpGroupDecorate and OpGroupMemberDecorate | |
| def OpDecorateId: Op<332, (outs), (ins ANY:$target, Decoration:$dec, variable_ops), | |
| "OpDecorateId $target $dec">; | |
| def OpDecorateString: Op<5632, (outs), (ins ANY:$t, Decoration:$d, StringImm:$s, variable_ops), | |
| "OpDecorateString $t $d $s">; | |
| def OpMemberDecorateString: Op<5633, (outs), | |
| (ins TYPE:$ty, i32imm:$mem, Decoration:$dec, StringImm:$str, variable_ops), | |
| "OpMemberDecorateString $ty $mem $dec $str">; | |
| // 3.42.4 Extension Instructions | |
| def OpExtension: Op<10, (outs), (ins StringImm:$name, variable_ops), "OpExtension $name">; | |
| def OpExtInstImport: Op<11, (outs ID:$res), (ins StringImm:$extInstsName, variable_ops), | |
| "$res = OpExtInstImport $extInstsName">; | |
| def OpExtInst: Op<12, (outs ID:$res), (ins TYPE:$ty, ID:$set, Extension:$inst, variable_ops), | |
| "$res = OpExtInst $ty $set $inst">; | |
| // 3.42.5 Mode-Setting Instructions | |
| def OpMemoryModel: Op<14, (outs), (ins AddressingModel:$addr, MemoryModel:$mem), | |
| "OpMemoryModel $addr $mem">; | |
| def OpEntryPoint: Op<15, (outs), | |
| (ins ExecutionModel:$model, ID:$entry, StringImm:$name, variable_ops), | |
| "OpEntryPoint $model $entry $name">; | |
| def OpExecutionMode: Op<16, (outs), (ins ID:$entry, ExecutionMode:$mode, variable_ops), | |
| "OpExecutionMode $entry $mode">; | |
| def OpCapability: Op<17, (outs), (ins Capability:$cap), "OpCapability $cap">; | |
| def OpExecutionModeId: Op<331, (outs), (ins ID:$entry, ExecutionMode:$mode, variable_ops), | |
| "OpExecutionModeId $entry $mode">; | |
| // 3.42.6 Type-Declaration Instructions | |
| def OpTypeVoid: Op<19, (outs TYPE:$type), (ins), "$type = OpTypeVoid">; | |
| def OpTypeBool: Op<20, (outs TYPE:$type), (ins), "$type = OpTypeBool">; | |
| def OpTypeInt: Op<21, (outs TYPE:$type), (ins i32imm:$width, i32imm:$signedness), | |
| "$type = OpTypeInt $width $signedness">; | |
| def OpTypeFloat: Op<22, (outs TYPE:$type), (ins i32imm:$width), | |
| "$type = OpTypeFloat $width">; | |
| def OpTypeVector: Op<23, (outs TYPE:$type), (ins TYPE:$compType, i32imm:$compCount), | |
| "$type = OpTypeVector $compType $compCount">; | |
| def OpTypeMatrix: Op<24, (outs TYPE:$type), (ins TYPE:$colType, i32imm:$colCount), | |
| "$type = OpTypeMatrix $colType $colCount">; | |
| def OpTypeImage: Op<25, (outs TYPE:$res), (ins TYPE:$sampTy, Dim:$dim, i32imm:$depth, | |
| i32imm:$arrayed, i32imm:$MS, i32imm:$sampled, ImageFormat:$imFormat, variable_ops), | |
| "$res = OpTypeImage $sampTy $dim $depth $arrayed $MS $sampled $imFormat">; | |
| def OpTypeSampler: Op<26, (outs TYPE:$res), (ins), "$res = OpTypeSampler">; | |
| def OpTypeSampledImage: Op<27, (outs TYPE:$res), (ins TYPE:$imageType), | |
| "$res = OpTypeSampledImage $imageType">; | |
| def OpTypeArray: Op<28, (outs TYPE:$type), (ins TYPE:$elementType, ID:$length), | |
| "$type = OpTypeArray $elementType $length">; | |
| def OpTypeRuntimeArray: Op<29, (outs TYPE:$type), (ins TYPE:$elementType), | |
| "$type = OpTypeRuntimeArray $elementType">; | |
| def OpTypeStruct: Op<30, (outs TYPE:$res), (ins variable_ops), "$res = OpTypeStruct">; | |
| def OpTypeOpaque: Op<31, (outs TYPE:$res), (ins StringImm:$name, variable_ops), | |
| "$res = OpTypeOpaque $name">; | |
| def OpTypePointer: Op<32, (outs TYPE:$res), (ins StorageClass:$storage, TYPE:$type), | |
| "$res = OpTypePointer $storage $type">; | |
| def OpTypeFunction: Op<33, (outs TYPE:$funcType), (ins TYPE:$returnType, variable_ops), | |
| "$funcType = OpTypeFunction $returnType">; | |
| def OpTypeEvent: Op<34, (outs TYPE:$res), (ins), "$res = OpTypeEvent">; | |
| def OpTypeDeviceEvent: Op<35, (outs TYPE:$res), (ins), "$res = OpTypeDeviceEvent">; | |
| def OpTypeReserveId: Op<36, (outs TYPE:$res), (ins), "$res = OpTypeReserveId">; | |
| def OpTypeQueue: Op<37, (outs TYPE:$res), (ins), "$res = OpTypeQueue">; | |
| def OpTypePipe: Op<38, (outs TYPE:$res), (ins AccessQualifier:$a), "$res = OpTypePipe $a">; | |
| def OpTypeForwardPointer: Op<39, (outs), (ins TYPE:$ptrType, StorageClass:$storageClass), | |
| "OpTypeForwardPointer $ptrType $storageClass">; | |
| def OpTypePipeStorage: Op<322, (outs TYPE:$res), (ins), "$res = OpTypePipeStorage">; | |
| def OpTypeNamedBarrier: Op<327, (outs TYPE:$res), (ins), "$res = OpTypeNamedBarrier">; | |
| def OpTypeAccelerationStructureNV: Op<5341, (outs TYPE:$res), (ins), | |
| "$res = OpTypeAccelerationStructureNV">; | |
| def OpTypeCooperativeMatrixNV: Op<5358, (outs TYPE:$res), | |
| (ins TYPE:$compType, ID:$scope, ID:$rows, ID:$cols), | |
| "$res = OpTypeCooperativeMatrixNV $compType $scope $rows $cols">; | |
| // 3.42.7 Constant-Creation Instructions | |
| def imm_to_i32 : SDNodeXForm<imm, [{ | |
| return CurDAG->getTargetConstant( | |
| N->getValueAP().bitcastToAPInt().getZExtValue(), SDLoc(N), MVT::i32); | |
| }]>; | |
| def fimm_to_i32 : SDNodeXForm<imm, [{ | |
| return CurDAG->getTargetConstant( | |
| N->getValueAPF().bitcastToAPInt().getZExtValue(), SDLoc(N), MVT::i32); | |
| }]>; | |
| def gi_bitcast_fimm_to_i32 : GICustomOperandRenderer<"renderFImm32">, | |
| GISDNodeXFormEquiv<fimm_to_i32>; | |
| def gi_bitcast_imm_to_i32 : GICustomOperandRenderer<"renderImm32">, | |
| GISDNodeXFormEquiv<imm_to_i32>; | |
| def PseudoConstI: IntImmLeaf<i32, [{ return Imm.getBitWidth() <= 32; }], imm_to_i32>; | |
| def PseudoConstF: FPImmLeaf<f32, [{ return true; }], fimm_to_i32>; | |
| def ConstPseudoTrue: IntImmLeaf<i32, [{ return Imm.getBitWidth() == 1 && Imm.getZExtValue() == 1; }]>; | |
| def ConstPseudoFalse: IntImmLeaf<i32, [{ return Imm.getBitWidth() == 1 && Imm.getZExtValue() == 0; }]>; | |
| def ConstPseudoNull: IntImmLeaf<i64, [{ return Imm.isNullValue(); }]>; | |
| multiclass IntFPImm<bits<16> opCode, string name> { | |
| def I: Op<opCode, (outs ID:$dst), (ins TYPE:$type, ID:$src, variable_ops), | |
| "$dst = "#name#" $type $src", [(set ID:$dst, (assigntype PseudoConstI:$src, TYPE:$type))]>; | |
| def F: Op<opCode, (outs ID:$dst), (ins TYPE:$type, fID:$src, variable_ops), | |
| "$dst = "#name#" $type $src", [(set ID:$dst, (assigntype PseudoConstF:$src, TYPE:$type))]>; | |
| } | |
| def OpConstantTrue: Op<41, (outs ID:$dst), (ins TYPE:$src_ty), "$dst = OpConstantTrue $src_ty", | |
| [(set ID:$dst, (assigntype ConstPseudoTrue, TYPE:$src_ty))]>; | |
| def OpConstantFalse: Op<42, (outs ID:$dst), (ins TYPE:$src_ty), "$dst = OpConstantFalse $src_ty", | |
| [(set ID:$dst, (assigntype ConstPseudoFalse, TYPE:$src_ty))]>; | |
| defm OpConstant: IntFPImm<43, "OpConstant">; | |
| def OpConstantComposite: Op<44, (outs ID:$res), (ins TYPE:$type, variable_ops), | |
| "$res = OpConstantComposite $type">; | |
| def OpConstantSampler: Op<45, (outs ID:$res), | |
| (ins TYPE:$t, SamplerAddressingMode:$s, i32imm:$p, SamplerFilterMode:$f), | |
| "$res = OpConstantSampler $t $s $p $f">; | |
| def OpConstantNull: Op<46, (outs ID:$dst), (ins TYPE:$src_ty), "$dst = OpConstantNull $src_ty", | |
| [(set ID:$dst, (assigntype ConstPseudoNull, TYPE:$src_ty))]>; | |
| def OpSpecConstantTrue: Op<48, (outs ID:$r), (ins TYPE:$t), "$r = OpSpecConstantTrue $t">; | |
| def OpSpecConstantFalse: Op<49, (outs ID:$r), (ins TYPE:$t), "$r = OpSpecConstantFalse $t">; | |
| def OpSpecConstant: Op<50, (outs ID:$res), (ins TYPE:$type, i32imm:$imm, variable_ops), | |
| "$res = OpSpecConstant $type $imm">; | |
| def OpSpecConstantComposite: Op<51, (outs ID:$res), (ins TYPE:$type, variable_ops), | |
| "$res = OpSpecConstantComposite $type">; | |
| def OpSpecConstantOp: Op<52, (outs ID:$res), (ins TYPE:$t, i32imm:$c, ID:$o, variable_ops), | |
| "$res = OpSpecConstantOp $t $c $o">; | |
| // 3.42.8 Memory Instructions | |
| def OpVariable: Op<59, (outs ID:$res), (ins TYPE:$type, StorageClass:$sc, variable_ops), | |
| "$res = OpVariable $type $sc">; | |
| def OpImageTexelPointer: Op<60, (outs ID:$res), | |
| (ins TYPE:$resType, ID:$image, ID:$coord, ID:$sample), | |
| "$res = OpImageTexelPointer $resType $image $coord $sample">; | |
| def OpLoad: Op<61, (outs ID:$res), (ins TYPE:$resType, ID:$pointer, variable_ops), | |
| "$res = OpLoad $resType $pointer">; | |
| def OpStore: Op<62, (outs), (ins ID:$pointer, ID:$objectToStore, variable_ops), | |
| "OpStore $pointer $objectToStore">; | |
| def OpCopyMemory: Op<63, (outs), (ins ID:$dest, ID:$src, variable_ops), | |
| "OpCopyMemory $dest $src">; | |
| def OpCopyMemorySized: Op<64, (outs), (ins ID:$dest, ID:$src, ID:$size, variable_ops), | |
| "OpCopyMemorySized $dest $src $size">; | |
| def OpAccessChain: Op<65, (outs ID:$res), (ins TYPE:$type, ID:$base, variable_ops), | |
| "$res = OpAccessChain $type $base">; | |
| def OpInBoundsAccessChain: Op<66, (outs ID:$res), | |
| (ins TYPE:$type, ID:$base, variable_ops), | |
| "$res = OpInBoundsAccessChain $type $base">; | |
| def OpPtrAccessChain: Op<67, (outs ID:$res), | |
| (ins TYPE:$type, ID:$base, ID:$element, variable_ops), | |
| "$res = OpPtrAccessChain $type $base $element">; | |
| def OpArrayLength: Op<68, (outs ID:$res), (ins TYPE:$resTy, ID:$struct, i32imm:$arrayMember), | |
| "$res = OpArrayLength $resTy $struct $arrayMember">; | |
| def OpGenericPtrMemSemantics: Op<69, (outs ID:$res), (ins TYPE:$resType, ID:$pointer), | |
| "$res = OpGenericPtrMemSemantics $resType $pointer">; | |
| def OpInBoundsPtrAccessChain: Op<70, (outs ID:$res), | |
| (ins TYPE:$type, ID:$base, ID:$element, variable_ops), | |
| "$res = OpInBoundsPtrAccessChain $type $base $element">; | |
| def OpPtrEqual: Op<401, (outs ID:$res), (ins TYPE:$resType, ID:$a, ID:$b), | |
| "$res = OpPtrEqual $resType $a $b">; | |
| def OpPtrNotEqual: Op<402, (outs ID:$res), (ins TYPE:$resType, ID:$a, ID:$b), | |
| "$res = OpPtrNotEqual $resType $a $b">; | |
| def OpPtrDiff: Op<403, (outs ID:$res), (ins TYPE:$resType, ID:$a, ID:$b), | |
| "$res = OpPtrDiff $resType $a $b">; | |
| // 3.42.9 Function Instructions | |
| def OpFunction: Op<54, (outs ID:$func), | |
| (ins TYPE:$resType, FunctionControl:$funcControl, TYPE:$funcType), | |
| "$func = OpFunction $resType $funcControl $funcType">; | |
| def OpFunctionParameter: Op<55, (outs ID:$arg), (ins TYPE:$type), | |
| "$arg = OpFunctionParameter $type">; | |
| def OpFunctionEnd: Op<56, (outs), (ins), "OpFunctionEnd"> { | |
| let isTerminator=1; | |
| } | |
| def OpFunctionCall: Op<57, (outs ID:$res), (ins TYPE:$resType, ID:$function, variable_ops), | |
| "$res = OpFunctionCall $resType $function">; | |
| // 3.42.10 Image Instructions | |
| def OpSampledImage: BinOp<"OpSampledImage", 86>; | |
| def OpImageSampleImplicitLod: Op<87, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, variable_ops), | |
| "$res = OpImageSampleImplicitLod $type $sampledImage $coord">; | |
| def OpImageSampleExplicitLod: Op<88, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$sImage, ID:$uv, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSampleExplicitLod $ty $sImage $uv $op $i">; | |
| def OpImageSampleDrefImplicitLod: Op<89, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, ID:$dref, variable_ops), | |
| "$res = OpImageSampleDrefImplicitLod $type $sampledImage $dref $coord">; | |
| def OpImageSampleDrefExplicitLod: Op<90, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$im, ID:$uv, ID:$d, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSampleDrefExplicitLod $ty $im $uv $d $op $i">; | |
| def OpImageSampleProjImplicitLod: Op<91, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, variable_ops), | |
| "$res = OpImageSampleProjImplicitLod $type $sampledImage $coord">; | |
| def OpImageSampleProjExplicitLod: Op<92, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$im, ID:$uv, ID:$d, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSampleProjExplicitLod $ty $im $uv $op $i">; | |
| def OpImageSampleProjDrefImplicitLod: Op<93, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, ID:$dref, variable_ops), | |
| "$res = OpImageSampleProjDrefImplicitLod $type $sampledImage $dref $coord">; | |
| def OpImageSampleProjDrefExplicitLod: Op<94, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$im, ID:$uv, ID:$d, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSampleProjDrefExplicitLod $ty $im $uv $d $op $i">; | |
| def OpImageFetch: Op<95, (outs ID:$res), | |
| (ins TYPE:$type, ID:$image, ID:$coord, variable_ops), | |
| "$res = OpImageFetch $type $image $coord">; | |
| def OpImageGather: Op<96, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, ID:$component, variable_ops), | |
| "$res = OpImageGather $type $sampledImage $coord $component">; | |
| def OpImageDrefGather: Op<97, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, ID:$dref, variable_ops), | |
| "$res = OpImageDrefGather $type $sampledImage $coord $dref">; | |
| def OpImageRead: Op<98, (outs ID:$res), | |
| (ins TYPE:$type, ID:$image, ID:$coord, variable_ops), | |
| "$res = OpImageRead $type $image $coord">; | |
| def OpImageWrite: Op<99, (outs), (ins ID:$image, ID:$coord, ID:$texel, variable_ops), | |
| "OpImageWrite $image $coord $texel">; | |
| def OpImage: UnOp<"OpImage", 100>; | |
| def OpImageQueryFormat: UnOp<"OpImageQueryFormat", 101>; | |
| def OpImageQueryOrder: UnOp<"OpImageQueryOrder", 102>; | |
| def OpImageQuerySizeLod: BinOp<"OpImageQuerySizeLod", 103>; | |
| def OpImageQuerySize: UnOp<"OpImageQuerySize", 104>; | |
| def OpImageQueryLod: BinOp<"OpImageQueryLod", 105>; | |
| def OpImageQueryLevels: UnOp<"OpImageQueryLevels", 106>; | |
| def OpImageQuerySamples: UnOp<"OpImageQuerySamples", 107>; | |
| def OpImageSparseSampleImplicitLod: Op<305, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, variable_ops), | |
| "$res = OpImageSparseSampleImplicitLod $type $sampledImage $coord">; | |
| def OpImageSparseSampleExplicitLod: Op<306, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$sImage, ID:$uv, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSparseSampleExplicitLod $ty $sImage $uv $op $i">; | |
| def OpImageSparseSampleDrefImplicitLod: Op<307, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImg, ID:$coord, ID:$dref, variable_ops), | |
| "$res = OpImageSparseSampleDrefImplicitLod $type $sampledImg $dref $coord">; | |
| def OpImageSparseSampleDrefExplicitLod: Op<308, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$im, ID:$uv, ID:$d, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSparseSampleDrefExplicitLod $ty $im $uv $d $op $i">; | |
| def OpImageSparseSampleProjImplicitLod: Op<309, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, variable_ops), | |
| "$res = OpImageSparseSampleProjImplicitLod $type $sampledImage $coord">; | |
| def OpImageSparseSampleProjExplicitLod: Op<310, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$im, ID:$uv, ID:$d, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSparseSampleProjExplicitLod $ty $im $uv $op $i">; | |
| def OpImageSparseSampleProjDrefImplicitLod: Op<311, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sImage, ID:$coord, ID:$dref, variable_ops), | |
| "$res = OpImageSparseSampleProjDrefImplicitLod $type $sImage $dref $coord">; | |
| def OpImageSparseSampleProjDrefExplicitLod: Op<312, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$im, ID:$uv, ID:$d, ImageOperand:$op, ID:$i, variable_ops), | |
| "$res = OpImageSparseSampleProjDrefExplicitLod $ty $im $uv $d $op $i">; | |
| def OpImageSparseFetch: Op<313, (outs ID:$res), | |
| (ins TYPE:$type, ID:$image, ID:$coord, variable_ops), | |
| "$res = OpImageSparseFetch $type $image $coord">; | |
| def OpImageSparseGather: Op<314, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, ID:$component, variable_ops), | |
| "$res = OpImageSparseGather $type $sampledImage $coord $component">; | |
| def OpImageSparseDrefGather: Op<315, (outs ID:$res), | |
| (ins TYPE:$type, ID:$sampledImage, ID:$coord, ID:$dref, variable_ops), | |
| "$res = OpImageSparseDrefGather $type $sampledImage $coord $dref">; | |
| def OpImageSparseTexelsResident: UnOp<"OpImageSparseTexelsResident", 316>; | |
| def OpImageSparseRead: Op<320, (outs ID:$res), | |
| (ins TYPE:$type, ID:$image, ID:$coord, variable_ops), | |
| "$res = OpImageSparseRead $type $image $coord">; | |
| def OpImageSampleFootprintNV: Op<5283, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$sImg, ID:$uv, ID:$granularity, ID:$coarse, variable_ops), | |
| "$res = OpImageSampleFootprintNV $ty $sImg $uv $granularity $coarse">; | |
| // 3.42.11 Conversion instructions | |
| def OpConvertFToU : UnOp<"OpConvertFToU", 109>; | |
| def OpConvertFToS : UnOp<"OpConvertFToS", 110>; | |
| def OpConvertSToF : UnOp<"OpConvertSToF", 111>; | |
| def OpConvertUToF : UnOp<"OpConvertUToF", 112>; | |
| def OpUConvert : UnOp<"OpUConvert", 113>; | |
| def OpSConvert : UnOp<"OpSConvert", 114>; | |
| def OpFConvert : UnOp<"OpFConvert", 115>; | |
| def OpQuantizeToF16 : UnOp<"OpQuantizeToF16", 116>; | |
| def OpConvertPtrToU : UnOp<"OpConvertPtrToU", 117>; | |
| def OpSatConvertSToU : UnOp<"OpSatConvertSToU", 118>; | |
| def OpSatConvertUToS : UnOp<"OpSatConvertUToS", 119>; | |
| def OpConvertUToPtr : UnOp<"OpConvertUToPtr", 120>; | |
| def OpPtrCastToGeneric : UnOp<"OpPtrCastToGeneric", 121>; | |
| def OpGenericCastToPtr : UnOp<"OpGenericCastToPtr", 122>; | |
| def OpGenericCastToPtrExplicit : Op<123, (outs ID:$r), (ins TYPE:$t, ID:$p, StorageClass:$s), | |
| "$r = OpGenericCastToPtrExplicit $t $p $s">; | |
| def OpBitcast : UnOp<"OpBitcast", 124>; | |
| // 3.42.12 Composite Instructions | |
| def OpVectorExtractDynamic: Op<77, (outs ID:$res), (ins TYPE:$type, vID:$vec, ID:$idx), | |
| "$res = OpVectorExtractDynamic $type $vec $idx", [(set ID:$res, (assigntype (extractelt vID:$vec, ID:$idx), TYPE:$type))]>; | |
| def OpVectorInsertDynamic: Op<78, (outs ID:$res), (ins TYPE:$ty, ID:$vec, ID:$comp, ID:$idx), | |
| "$res = OpVectorInsertDynamic $ty $vec $comp $idx">; | |
| def OpVectorShuffle: Op<79, (outs ID:$res), (ins TYPE:$ty, ID:$v1, ID:$v2, variable_ops), | |
| "$res = OpVectorShuffle $ty $v1 $v2">; | |
| def OpCompositeConstruct: Op<80, (outs ID:$res), (ins TYPE:$type, variable_ops), | |
| "$res = OpCompositeConstruct $type">; | |
| def OpCompositeExtract: Op<81, (outs ID:$res), (ins TYPE:$type, ID:$base, variable_ops), | |
| "$res = OpCompositeExtract $type $base">; | |
| def OpCompositeInsert: Op<82, (outs ID:$r), (ins TYPE:$ty, ID:$obj, ID:$base, variable_ops), | |
| "$r = OpCompositeInsert $ty $obj $base">; | |
| def OpCopyObject: UnOp<"OpCopyObject", 83>; | |
| def OpTranspose: UnOp<"OpTranspose", 84>; | |
| def OpCopyLogical: UnOp<"OpCopyLogical", 400>; | |
| // 3.42.13 Arithmetic Instructions | |
| def OpSNegate: UnOp<"OpSNegate", 126>; | |
| def OpFNegate: UnOpTyped<"OpFNegate", 127, fID, fneg>; | |
| def OpFNegateV: UnOpTyped<"OpFNegate", 127, vfID, fneg>; | |
| defm OpIAdd: BinOpTypedGen<"OpIAdd", 128, add, 0, 1>; | |
| defm OpFAdd: BinOpTypedGen<"OpFAdd", 129, fadd, 1, 1>; | |
| defm OpISub: BinOpTypedGen<"OpISub", 130, sub, 0, 1>; | |
| defm OpFSub: BinOpTypedGen<"OpFSub", 131, fsub, 1, 1>; | |
| defm OpIMul: BinOpTypedGen<"OpIMul", 132, mul, 0, 1>; | |
| defm OpFMul: BinOpTypedGen<"OpFMul", 133, fmul, 1, 1>; | |
| defm OpUDiv: BinOpTypedGen<"OpUDiv", 134, udiv, 0, 1>; | |
| defm OpSDiv: BinOpTypedGen<"OpSDiv", 135, sdiv, 0, 1>; | |
| defm OpFDiv: BinOpTypedGen<"OpFDiv", 136, fdiv, 1, 1>; | |
| defm OpUMod: BinOpTypedGen<"OpUMod", 137, urem, 0, 1>; | |
| defm OpSRem: BinOpTypedGen<"OpSRem", 138, srem, 0, 1>; | |
| def OpSMod: BinOp<"OpSMod", 139>; | |
| defm OpFRem: BinOpTypedGen<"OpFRem", 140, frem, 1, 1>; | |
| def OpFMod: BinOp<"OpFMod", 141>; | |
| def OpVectorTimesScalar: BinOp<"OpVectorTimesScalar", 142>; | |
| def OpMatrixTimesScalar: BinOp<"OpMatrixTimesScalar", 143>; | |
| def OpVectorTimesMatrix: BinOp<"OpVectorTimesMatrix", 144>; | |
| def OpMatrixTimesVector: BinOp<"OpMatrixTimesVector", 145>; | |
| def OpMatrixTimesMatrix: BinOp<"OpMatrixTimesMatrix", 146>; | |
| def OpOuterProduct: BinOp<"OpOuterProduct", 147>; | |
| def OpDot: BinOp<"OpDot", 148>; | |
| def OpIAddCarry: BinOpTyped<"OpIAddCarry", 149, ID, addc>; | |
| def OpISubBorrow: BinOpTyped<"OpISubBorrow", 150, ID, subc>; | |
| def OpUMulExtended: BinOp<"OpUMulExtended", 151>; | |
| def OpSMulExtended: BinOp<"OpSMulExtended", 152>; | |
| // 3.42.14 Bit Instructions | |
| defm OpShiftRightLogical: BinOpTypedGen<"OpShiftRightLogical", 194, srl, 0, 1>; | |
| defm OpShiftRightArithmetic: BinOpTypedGen<"OpShiftRightArithmetic", 195, sra, 0, 1>; | |
| defm OpShiftLeftLogical: BinOpTypedGen<"OpShiftLeftLogical", 196, shl, 0, 1>; | |
| defm OpBitwiseOr: BinOpTypedGen<"OpBitwiseOr", 197, or, 0, 1>; | |
| defm OpBitwiseXor: BinOpTypedGen<"OpBitwiseXor", 198, xor, 0, 1>; | |
| defm OpBitwiseAnd: BinOpTypedGen<"OpBitwiseAnd", 199, and, 0, 1>; | |
| def OpNot: UnOp<"OpNot", 200>; | |
| def OpBitFieldInsert: Op<201, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$base, ID:$insert, ID:$offset, ID:$count), | |
| "$res = OpBitFieldInsert $ty $base $insert $offset $count">; | |
| def OpBitFieldSExtract: Op<202, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$base, ID:$offset, ID:$count), | |
| "$res = OpBitFieldSExtract $ty $base $offset $count">; | |
| def OpBitFieldUExtract: Op<203, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$base, ID:$offset, ID:$count), | |
| "$res = OpBitFieldUExtract $ty $base $offset $count">; | |
| def OpBitReverse: Op<204, (outs ID:$r), (ins TYPE:$ty, ID:$b), "$r = OpBitReverse $ty $b">; | |
| def OpBitCount: Op<205, (outs ID:$r), (ins TYPE:$ty, ID:$b), "$r = OpBitCount $ty $b">; | |
| // 3.42.15 Relational and Logical Instructions | |
| def OpAny: Op<154, (outs ID:$res), (ins TYPE:$ty, ID:$vec), | |
| "$res = OpAny $ty $vec">; | |
| def OpAll: Op<155, (outs ID:$res), (ins TYPE:$ty, ID:$vec), | |
| "$res = OpAll $ty $vec">; | |
| def OpIsNan: UnOp<"OpIsNan", 156>; | |
| def OpIsInf: UnOp<"OpIsInf", 157>; | |
| def OpIsFinite: UnOp<"OpIsFinite", 158>; | |
| def OpIsNormal: UnOp<"OpIsNormal", 159>; | |
| def OpSignBitSet: UnOp<"OpSignBitSet", 160>; | |
| def OpLessOrGreater: BinOp<"OpLessOrGreater", 161>; | |
| def OpOrdered: BinOp<"OpOrdered", 162>; | |
| def OpUnordered: BinOp<"OpUnordered", 163>; | |
| def OpLogicalEqual: BinOp<"OpLogicalEqual", 164>; | |
| def OpLogicalNotEqual: BinOp<"OpLogicalNotEqual", 165>; | |
| def OpLogicalOr: BinOp<"OpLogicalOr", 166>; | |
| def OpLogicalAnd: BinOp<"OpLogicalAnd", 167>; | |
| def OpLogicalNot: UnOp<"OpLogicalNot", 168>; | |
| defm OpSelect: TernOpTypedGen<"OpSelect", 169, select, 1, 1, 1>; | |
| def OpIEqual: BinOp<"OpIEqual", 170>; | |
| def OpINotEqual: BinOp<"OpINotEqual", 171>; | |
| def OpUGreaterThan: BinOp<"OpUGreaterThan", 172>; | |
| def OpSGreaterThan: BinOp<"OpSGreaterThan", 173>; | |
| def OpUGreaterThanEqual: BinOp<"OpUGreaterThanEqual", 174>; | |
| def OpSGreaterThanEqual: BinOp<"OpSGreaterThanEqual", 175>; | |
| def OpULessThan: BinOp<"OpULessThan", 176>; | |
| def OpSLessThan: BinOp<"OpSLessThan", 177>; | |
| def OpULessThanEqual: BinOp<"OpULessThanEqual", 178>; | |
| def OpSLessThanEqual: BinOp<"OpSLessThanEqual", 179>; | |
| def OpFOrdEqual: BinOp<"OpFOrdEqual", 180>; | |
| def OpFUnordEqual: BinOp<"OpFUnordEqual", 181>; | |
| def OpFOrdNotEqual: BinOp<"OpFOrdNotEqual", 182>; | |
| def OpFUnordNotEqual: BinOp<"OpFUnordNotEqual", 183>; | |
| def OpFOrdLessThan: BinOp<"OpFOrdLessThan", 184>; | |
| def OpFUnordLessThan: BinOp<"OpFUnordLessThan", 185>; | |
| def OpFOrdGreaterThan: BinOp<"OpFOrdGreaterThan", 186>; | |
| def OpFUnordGreaterThan: BinOp<"OpFUnordGreaterThan", 187>; | |
| def OpFOrdLessThanEqual: BinOp<"OpFOrdLessThanEqual", 188>; | |
| def OpFUnordLessThanEqual: BinOp<"OpFUnordLessThanEqual", 189>; | |
| def OpFOrdGreaterThanEqual: BinOp<"OpFOrdGreaterThanEqual", 190>; | |
| def OpFUnordGreaterThanEqual: BinOp<"OpFUnordGreaterThanEqual", 191>; | |
| // 3.42.16 Derivative Instructions | |
| def OpDPdx: UnOp<"OpDPdx", 207>; | |
| def OpDPdy: UnOp<"OpDPdy", 208>; | |
| def OpFwidth: UnOp<"OpFwidth", 209>; | |
| def OpDPdxFine: UnOp<"OpDPdxFine", 210>; | |
| def OpDPdyFine: UnOp<"OpDPdyFine", 211>; | |
| def OpFwidthFine: UnOp<"OpFwidthFine", 212>; | |
| def OpDPdxCoarse: UnOp<"OpDPdxCoarse", 213>; | |
| def OpDPdyCoarse: UnOp<"OpDPdyCoarse", 214>; | |
| def OpFwidthCoarse: UnOp<"OpFwidthCoarse", 215>; | |
| // 3.42.17 Control-Flow Instructions | |
| def OpPhi: Op<245, (outs ID:$res), (ins TYPE:$type, ID:$var0, ID:$block0, variable_ops), | |
| "$res = OpPhi $type $var0 $block0">; | |
| def OpLoopMerge: Op<246, (outs), (ins ID:$merge, ID:$continue, LoopControl:$lc, variable_ops), | |
| "OpLoopMerge $merge $merge $continue $lc">; | |
| def OpSelectionMerge: Op<247, (outs), (ins ID:$merge, SelectionControl:$sc), | |
| "OpSelectionMerge $merge $sc">; | |
| def OpLabel: Op<248, (outs ID:$label), (ins), "$label = OpLabel">; | |
| let isTerminator=1 in { | |
| def OpBranch: Op<249, (outs), (ins ID:$label), "OpBranch $label">; | |
| def OpBranchConditional: Op<250, (outs), (ins ID:$cond, ID:$true, ID:$false, variable_ops), | |
| "OpBranchConditional $cond $true $false">; | |
| def OpSwitch: Op<251, (outs), (ins ID:$sel, ID:$dflt, variable_ops), "OpSwitch $sel $dflt">; | |
| } | |
| let isReturn = 1, hasDelaySlot=0, isBarrier = 0, isTerminator=1, isNotDuplicable = 1 in { | |
| def OpKill: SimpleOp<"OpKill", 252>; | |
| def OpReturn: SimpleOp<"OpReturn", 253>; | |
| def OpReturnValue: Op<254, (outs), (ins ANYID:$ret), "OpReturnValue $ret">; | |
| def OpUnreachable: SimpleOp<"OpUnreachable", 255>; | |
| } | |
| def OpLifetimeStart: Op<256, (outs), (ins ID:$ptr, i32imm:$sz), "OpLifetimeStart $ptr, $sz">; | |
| def OpLifetimeStop: Op<257, (outs), (ins ID:$ptr, i32imm:$sz), "OpLifetimeStop $ptr, $sz">; | |
| // 3.42.18 Atomic Instructions | |
| class AtomicOp<string name, bits<16> opCode>: Op<opCode, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$ptr, ID:$sc, ID:$sem), | |
| "$res = "#name#" $ty $ptr $sc $sem">; | |
| class AtomicOpVal<string name, bits<16> opCode>: Op<opCode, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$ptr, ID:$sc, ID:$sem, ID:$val), | |
| "$res = "#name#" $ty $ptr $sc $sem $val">; | |
| def OpAtomicLoad: AtomicOp<"OpAtomicLoad", 227>; | |
| def OpAtomicStore: Op<228, (outs), (ins ID:$ptr, ID:$sc, ID:$sem, ID:$val), | |
| "OpAtomicStore $ptr $sc $sem $val">; | |
| def OpAtomicExchange: Op<229, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$ptr, ID:$sc, ID:$sem, ID:$val), | |
| "$res = OpAtomicExchange $ty $ptr $sc $sem $val">; | |
| def OpAtomicCompareExchange: Op<230, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$ptr, ID:$sc, ID:$eq, | |
| ID:$neq, ID:$val, ID:$cmp), | |
| "$res = OpAtomicCompareExchange $ty $ptr $sc $eq $neq $val $cmp">; | |
| def OpAtomicCompareExchangeWeak: Op<231, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$ptr, ID:$sc, ID:$eq, | |
| ID:$neq, ID:$val, ID:$cmp), | |
| "$res = OpAtomicCompareExchangeWeak $ty $ptr $sc $eq $neq $val $cmp">; | |
| def OpAtomicIIncrement: AtomicOp<"OpAtomicIIncrement", 232>; | |
| def OpAtomicIDecrement: AtomicOp<"OpAtomicIDecrement", 233>; | |
| def OpAtomicIAdd: AtomicOpVal<"OpAtomicIAdd", 234>; | |
| def OpAtomicISub: AtomicOpVal<"OpAtomicISub", 235>; | |
| def OpAtomicSMin: AtomicOpVal<"OpAtomicSMin", 236>; | |
| def OpAtomicUMin: AtomicOpVal<"OpAtomicUMin", 237>; | |
| def OpAtomicSMax: AtomicOpVal<"OpAtomicSMax", 238>; | |
| def OpAtomicUMax: AtomicOpVal<"OpAtomicUMax", 239>; | |
| def OpAtomicAnd: AtomicOpVal<"OpAtomicAnd", 240>; | |
| def OpAtomicOr: AtomicOpVal<"OpAtomicOr", 241>; | |
| def OpAtomicXor: AtomicOpVal<"OpAtomicXor", 242>; | |
| def OpAtomicFlagTestAndSet: AtomicOp<"OpAtomicFlagTestAndSet", 318>; | |
| def OpAtomicFlagClear: Op<319, (outs), (ins ID:$ptr, ID:$sc, ID:$sem), | |
| "OpAtomicFlagClear $ptr $sc $sem">; | |
| // 3.42.19 Primitive Instructions | |
| def OpEmitVertex: SimpleOp<"OpEmitVertex", 218>; | |
| def OpEndPrimitive: SimpleOp<"OpEndPrimitive", 219>; | |
| def OpEmitStreamVertex: Op<220, (outs), (ins ID:$stream), "OpEmitStreamVertex $stream">; | |
| def OpEndStreamPrimitive: Op<221, (outs), (ins ID:$stream), "OpEndStreamPrimitive $stream">; | |
| // 3.42.20 Barrier Instructions | |
| def OpControlBarrier: Op<224, (outs), (ins ID:$exec, ID:$mem, ID:$sem), | |
| "OpControlBarrier $exec $mem $sem">; | |
| def OpMemoryBarrier: Op<225, (outs), (ins ID:$mem, ID:$sem), | |
| "OpMemoryBarrier $mem $sem">; | |
| def OpNamedBarrierInitialize: UnOp<"OpNamedBarrierInitialize", 328>; | |
| def OpMemoryNamedBarrier: Op<329, (outs), (ins ID:$barr, ID:$mem, ID:$sem), | |
| "OpMemoryNamedBarrier $barr $mem $sem">; | |
| // 3.42.21. Group and Subgroup Instructions | |
| def OpGroupAsyncCopy: Op<259, (outs ID:$res), (ins TYPE:$ty, ID:$scope, | |
| ID:$dst, ID:$src, ID:$nelts, ID:$stride, ID:$event), | |
| "$res = OpGroupAsyncCopy $ty $scope $dst $src $nelts $stride $event">; | |
| def OpGroupWaitEvents: Op<260, (outs), (ins ID:$scope, ID:$nelts, ID:$elist), | |
| "OpGroupWaitEvents $scope $nelts $elist">; | |
| def OpGroupAll: Op<261, (outs ID:$res), (ins TYPE:$ty, ID:$scope, ID:$pr), | |
| "$res = OpGroupAll $ty $scope $pr">; | |
| def OpGroupAny: Op<262, (outs ID:$res), (ins TYPE:$ty, ID:$scope, ID:$pr), | |
| "$res = OpGroupAny $ty $scope $pr">; | |
| def OpGroupBroadcast: Op<263, (outs ID:$res), (ins TYPE:$ty, ID:$scope, | |
| ID:$val, ID:$id), | |
| "$res = OpGroupBroadcast $ty $scope $val $id">; | |
| class OpGroup<string name, bits<16> opCode>: Op<opCode, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$scope, GroupOperation:$groupOp, ID:$x), | |
| "$res = OpGroup"#name#" $ty $scope $groupOp $x">; | |
| def OpGroupIAdd: OpGroup<"IAdd", 264>; | |
| def OpGroupFAdd: OpGroup<"FAdd", 265>; | |
| def OpGroupFMin: OpGroup<"FMin", 266>; | |
| def OpGroupUMin: OpGroup<"UMin", 267>; | |
| def OpGroupSMin: OpGroup<"SMin", 268>; | |
| def OpGroupFMax: OpGroup<"FMax", 269>; | |
| def OpGroupUMax: OpGroup<"UMax", 270>; | |
| def OpGroupSMax: OpGroup<"SMax", 271>; | |
| // TODO: 3.42.22. Device-Side Enqueue Instructions | |
| def OpEnqueueKernel: Op<292, (outs ID:$res), (ins TYPE:$type, ID:$queue, ID:$flags, ID:$NDR, ID:$nevents, ID:$wevents, | |
| ID:$revent, ID:$invoke, ID:$param, ID:$psize, ID:$palign, variable_ops), | |
| "$res = OpEnqueueKernel $type $queue $flags $NDR $nevents $wevents $revent $invoke $param $psize $palign">; | |
| def OpRetainEvent: Op<297, (outs), (ins ID:$event), "OpRetainEvent $event">; | |
| def OpReleaseEvent: Op<298, (outs), (ins ID:$event), "OpReleaseEvent $event">; | |
| def OpCreateUserEvent: Op<299, (outs ID:$res), (ins TYPE:$type), | |
| "$res = OpCreateUserEvent $type">; | |
| def OpIsValidEvent: Op<300, (outs ID:$res), (ins TYPE:$type, ID:$event), | |
| "$res = OpIsValidEvent $type $event ">; | |
| def OpSetUserEventStatus: Op<301, (outs), (ins ID:$event, ID:$status), | |
| "OpSetUserEventStatus $event $status">; | |
| def OpCaptureEventProfilingInfo: Op<302, (outs), | |
| (ins ID:$event, ID:$info, ID:$value), | |
| "OpCaptureEventProfilingInfo $event $info $value">; | |
| def OpGetDefaultQueue: Op<303, (outs ID:$res), (ins TYPE:$type), | |
| "$res = OpGetDefaultQueue $type">; | |
| def OpBuildNDRange: Op<304, (outs ID:$res), (ins TYPE:$type, ID:$GWS, ID:$LWS, ID:$GWO), | |
| "$res = OpBuildNDRange $type $GWS $LWS $GWO">; | |
| // TODO: 3.42.23. Pipe Instructions | |
| // 3.42.24. Non-Uniform Instructions | |
| def OpGroupNonUniformElect: Op<333, (outs ID:$res), (ins TYPE:$ty, ID:$scope), | |
| "$res = OpGroupNonUniformElect $ty $scope">; | |
| class OpGroupNU3<string name, bits<16> opCode>: Op<opCode, | |
| (outs ID:$res), (ins TYPE:$ty, ID:$scope, ID:$pred), | |
| "$res = OpGroupNonUniform"#name#" $ty $scope $pred">; | |
| class OpGroupNU4<string name, bits<16> opCode>: Op<opCode, | |
| (outs ID:$res), (ins TYPE:$ty, ID:$scope, ID:$val, ID:$id), | |
| "$res = OpGroupNonUniform"#name#" $ty $scope $val $id">; | |
| def OpGroupNonUniformAll: OpGroupNU3<"All", 334>; | |
| def OpGroupNonUniformAny: OpGroupNU3<"Any", 335>; | |
| def OpGroupNonUniformAllEqual: OpGroupNU3<"AllEqual", 336>; | |
| def OpGroupNonUniformBroadcast: OpGroupNU4<"Broadcast", 337>; | |
| def OpGroupNonUniformBroadcastFirst: OpGroupNU3<"BroadcastFirst", 338>; | |
| def OpGroupNonUniformBallot: OpGroupNU3<"Ballot", 339>; | |
| def OpGroupNonUniformInverseBallot: OpGroupNU3<"InverseBallot", 340>; | |
| def OpGroupNonUniformBallotBitExtract: OpGroupNU4<"BallotBitExtract", 341>; | |
| def OpGroupNonUniformBallotBitCount: Op<342, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$scope, GroupOperation:$groupOp, ID:$val), | |
| "$res = OpGroupNonUniformBallotBitCount " | |
| "$ty $scope $groupOp $val">; | |
| def OpGroupNonUniformBallotFindLSB: OpGroupNU3<"BallotFindLSB", 343>; | |
| def OpGroupNonUniformBallotFindMSB: OpGroupNU3<"BallotFindMSB", 344>; | |
| def OpGroupNonUniformShuffle: OpGroupNU4<"Shuffle", 345>; | |
| def OpGroupNonUniformShuffleXor: OpGroupNU4<"ShuffleXor", 346>; | |
| def OpGroupNonUniformShuffleUp: OpGroupNU4<"ShuffleUp", 347>; | |
| def OpGroupNonUniformShuffleDown: OpGroupNU4<"ShuffleDown", 348>; | |
| class OpGroupNUGroup<string name, bits<16> opCode>: Op<opCode, (outs ID:$res), | |
| (ins TYPE:$ty, ID:$scope, GroupOperation:$groupOp, | |
| ID:$val, variable_ops), | |
| "$res = OpGroupNonUniform"#name#" $ty $scope $groupOp $val">; | |
| def OpGroupNonUniformIAdd: OpGroupNUGroup<"IAdd", 349>; | |
| def OpGroupNonUniformFAdd: OpGroupNUGroup<"FAdd", 350>; | |
| def OpGroupNonUniformIMul: OpGroupNUGroup<"IMul", 351>; | |
| def OpGroupNonUniformFMul: OpGroupNUGroup<"FMul", 352>; | |
| def OpGroupNonUniformSMin: OpGroupNUGroup<"SMin", 353>; | |
| def OpGroupNonUniformUMin: OpGroupNUGroup<"UMin", 354>; | |
| def OpGroupNonUniformFMin: OpGroupNUGroup<"FMin", 355>; | |
| def OpGroupNonUniformSMax: OpGroupNUGroup<"SMax", 356>; | |
| def OpGroupNonUniformUMax: OpGroupNUGroup<"UMax", 357>; | |
| def OpGroupNonUniformFMax: OpGroupNUGroup<"FMax", 358>; | |
| def OpGroupNonUniformBitwiseAnd: OpGroupNUGroup<"BitwiseAnd", 359>; | |
| def OpGroupNonUniformBitwiseOr: OpGroupNUGroup<"BitwiseOr", 360>; | |
| def OpGroupNonUniformBitwiseXor: OpGroupNUGroup<"BitwiseXor", 361>; | |
| def OpGroupNonUniformLogicalAnd: OpGroupNUGroup<"LogicalAnd", 362>; | |
| def OpGroupNonUniformLogicalOr: OpGroupNUGroup<"LogicalOr", 363>; | |
| def OpGroupNonUniformLogicalXor: OpGroupNUGroup<"LogicalXor", 364>; |