[mlir][AVX512] Start a primitive AVX512 dialect

[nicolasvasilache]

Summary

The Vector Dialect document discusses the vector abstractions that MLIR supports and the various tradeoffs involved.

One of the layer that is missing in OSS atm is the Hardware Vector Ops (HWV) level.

This revision proposes an AVX512-specific to add a new Dialect/Targets/AVX512 Dialect that would directly target AVX512-specific intrinsics.

Atm, we rely too much on LLVM’s peephole optimizer to do a good job from small insertelement/extractelement/shufflevector. In the future, when possible, generic abstractions such as VP intrinsics should be preferred.

This is related to the discussion in: https://llvm.discourse.group/t/rfc-starting-an-avx512-target-specific-dialect-rebooted/688/9

The revision will allow trading off HW-specific vs generic abstractions in MLIR.

[jpienaar]

Just fly by :) It seems you'll need to update the cmake file for mlir-translate as your translate pass is not getting linked in.

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

22–34

Accidental paste?

[nicolasvasilache]

Add CMake

[nicolasvasilache]

Update commit message.

[nicolasvasilache]

Use side effect interfaces.
Remove spurious license.

[nicolasvasilache]

Update cmake.

[rriddle]

mlir/include/mlir/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.h

13

Can we trim this include, and replace with forward declare?

25

nit: Prefer std::unique_ptr<> here instead.

mlir/include/mlir/Dialect/AVX512/AVX512.td

39

nit: Can you use let arguments = and let results = for these ops instead of using Arguments/Results? It is much cleaner IMO

63

This should be possible now by using the TypesMatchWith constraint

94

Same here.

mlir/include/mlir/Dialect/AVX512/AVX512Dialect.h

14

This header guard seems wrong.

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

46

This doesn't look like it has been formatted.

84

Can you hoist most of this so that we don't need to spread it across five lines?

106

Same here.

mlir/lib/Target/LLVMIR/AVX512Intr.cpp

30 ↗

(On Diff #250968)

Not sure if this is possible yet, but we should really remove the need to use inheritance for extension.

[rriddle]

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

37

Note that a few things have changed at head:

PatternMatchResult -> LogicalResult
matchSuccess -> success
matchFailure -> failure

[nicolasvasilache]

Address review comments.

[nicolasvasilache]

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

46

tried both internal and oss git-clang-format, they seem to agree here.

[nicolasvasilache]

Address comments.

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

37

Rebased.

mlir/lib/Target/LLVMIR/AVX512Intr.cpp

30 ↗

(On Diff #250968)

I don't see any CRTP on ModuleTranslation yet, can we keep this as an NFC followup refactor?

[ftynse]

What's the plan with separating ops taking std types from ops taking LLVM types? According to a comment, you want to do that, maybe do it immediately to avoid file moves and build system updates later.

mlir/include/mlir/Dialect/AVX512/AVX512.td

66

It should be possible to just omit this

126

Nit: can we use consistent formatting? Previous block has 4 leading spaces in exactly the same sitatuion.

mlir/include/mlir/IR/OpImplementation.h

112

Use git-clang-format to avoid spurious reformatting in future commits

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

132

It looks like you could have

template <typename OpTy>
Type getVectorElementType(OpTy op) {
  return op.src().getType().cast<VectorType>().getElementType();
}

that you could reuse in all four patterns as

if (getVectorElementType(cast<OpTy>(op)).isF32()) { ... }

164

Nit: let's turn off clang-format here and just have one pattern per line. It reduces history churn due to reflowing lines every time one adds a new pattern in the list.

186

We can go full metaprogramming and generate this function (and potentially the intrinsic-related ops as well)

mlir/lib/Target/LLVMIR/AVX512Intr.cpp

30 ↗

(On Diff #250968)

@rriddle it is not possible yet, but it is on my todo list. I won't get to it in the next couple of weeks, so if somebody else has cycles, please go ahead :)

mlir/tools/mlir-opt/CMakeLists.txt

8 ↗

(On Diff #250985)

Leftover debug?

[nicolasvasilache]

mlir/include/mlir/IR/OpImplementation.h

112

I have, it is another one of those cases where the config in phab does not agree.
@mehdi_amini and @jpienaar are the most up to date on this.
Forcing manually to what phab wants.

604

same here re format

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

186

Ack

[nicolasvasilache]

Address review comments.

[nicolasvasilache]

Rebase

[nicolasvasilache]

Rebase

[ftynse]

mlir/include/mlir/Dialect/AVX512/AVX512.td

17

Is this still necessary?

45

Nit: I think it lowers to MLIR dialect operations rather than llvm intrinsics

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

179

I think you can now do addIllegalDialect<AVX512Dialect>

mlir/lib/Target/LLVMIR/LLVMAVX512Intr.cpp

45

I don't see a problem including this into the "main" mlir to llvm translation.

[nicolasvasilache]

mlir/lib/Target/LLVMIR/LLVMAVX512Intr.cpp

45

I am not sure how to do that while still controlling opt-in at link time.
Let's iterate on this in-tree if you don't mind.

[nicolasvasilache]

Address review comments.

[nicolasvasilache]

Addressed

mlir/include/mlir/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.h

+//===- ConvertAVX512ToLLVM.h - Conversion Patterns from AVX512 to LLVM ----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_EDGE_CONVERSION_AVX512TOLLVM_CONVERTAVX512TOLLVM_H_
+#define MLIR_EDGE_CONVERSION_AVX512TOLLVM_CONVERTAVX512TOLLVM_H_
+
+#include <memory>
+
+namespace mlir {
+class LLVMTypeConverter;
+class ModuleOp;
+template <typename T> class OpPassBase;
+class OwningRewritePatternList;
+
+/// Collect a set of patterns to convert from the AVX512 dialect to LLVM.
+void populateAVX512ToLLVMConversionPatterns(LLVMTypeConverter &converter,
+                                            OwningRewritePatternList &patterns);
+
+/// Create a pass to convert AVX512 operations to the LLVMIR dialect.
+std::unique_ptr<OpPassBase<ModuleOp>> createConvertAVX512ToLLVMPass();
+
+} // namespace mlir
+
+#endif // MLIR_EDGE_CONVERSION_AVX512TOLLVM_CONVERTAVX512TOLLVM_H_

mlir/include/mlir/Dialect/AVX512/AVX512.td

+//===-- AVX512Ops.td - AVX512 dialect operation definitions *- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the basic operations for the AVX512 dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef AVX512_OPS
+#define AVX512_OPS
+
+include "mlir/Interfaces/SideEffects.td"
+
+//===----------------------------------------------------------------------===//
+// AVX512 dialect definition
+//===----------------------------------------------------------------------===//
+
+def AVX512_Dialect : Dialect {
+  let name = "avx512";
+  let cppNamespace = "avx512";
+}
+
+//===----------------------------------------------------------------------===//
+// AVX512 op definitions
+//===----------------------------------------------------------------------===//
+
+class AVX512_Op<string mnemonic, list<OpTrait> traits = []> :
+  Op<AVX512_Dialect, mnemonic, traits> {}
+
+def MaskRndScaleOp : AVX512_Op<"mask.rndscale", [NoSideEffect,
+  AllTypesMatch<["src", "a", "dst"]>,
+  TypesMatchWith<"imm has the same number of bits as elements in dst",
+                 "dst", "imm",
+                 "IntegerType::get(($_self.cast<VectorType>().getShape()[0]),"
+                 "  $_self.getContext())">]> {
+  let summary = "Masked roundscale op";
+  let description = [{
+    The mask.rndscale op is an AVX512 specific op that can lower to the proper
+    LLVMAVX512 operation: `llvm.mask.rndscale.ps.512` or
+    `llvm.mask.rndscale.pd.512` instruction depending on the type of vectors it
+    is applied to.
+
+    From the Intel Intrinsics Guide:
+    ================================
+    Round packed floating-point elements in `a` to the number of fraction bits
+    specified by `imm`, and store the results in `dst` using writemask `k`
+    (elements are copied from src when the corresponding mask bit is not set).
+  }];
+  // Supports vector<16xf32> and vector<8xf64>.
+  let arguments = (ins VectorOfLengthAndType<[16, 8], [F32, F64]>:$src,
+                   I32:$k,
+                   VectorOfLengthAndType<[16, 8], [F32, F64]>:$a,
+                   AnyTypeOf<[I16, I8]>:$imm,
+                   // TODO(ntv): figure rounding out (optional operand?).
+                   I32:$rounding
+            );
+  let results = (outs VectorOfLengthAndType<[16, 8], [F32, F64]>:$dst);
+  let assemblyFormat =
+    "$src `,` $k `,` $a `,` $imm `,` $rounding attr-dict `:` type($dst)";
+}
+
+def MaskScaleFOp : AVX512_Op<"mask.scalef", [NoSideEffect,
+  AllTypesMatch<["src", "a", "b", "dst"]>,
+  TypesMatchWith<"k has the same number of bits as elements in dst",
+                 "dst", "k",
+                 "IntegerType::get(($_self.cast<VectorType>().getShape()[0]),"
+                 "  $_self.getContext())">]> {
+  let summary = "ScaleF op";
+  let description = [{
+    The `mask.scalef` op is an AVX512 specific op that can lower to the proper
+    LLVMAVX512 operation: `llvm.mask.scalef.ps.512` or
+    `llvm.mask.scalef.pd.512` depending on the type of MLIR vectors it is
+    applied to.
+
+    From the Intel Intrinsics Guide:
+    ================================
+    Scale the packed floating-point elements in `a` using values from `b`, and
+    store the results in `dst` using writemask `k` (elements are copied from src
+    when the corresponding mask bit is not set).
+  }];
+  // Supports vector<16xf32> and vector<8xf64>.
+  let arguments = (ins VectorOfLengthAndType<[16, 8], [F32, F64]>:$src,
+                   VectorOfLengthAndType<[16, 8], [F32, F64]>:$a,
+                   VectorOfLengthAndType<[16, 8], [F32, F64]>:$b,
+                   AnyTypeOf<[I16, I8]>:$k,
+                   // TODO(ntv): figure rounding out (optional operand?).
+                   I32:$rounding
+            );
+  let results = (outs VectorOfLengthAndType<[16, 8], [F32, F64]>:$dst);
+  // Fully specified by traits.
+  let assemblyFormat =
+    "$src `,` $a `,` $b `,` $k `,` $rounding attr-dict `:` type($dst)";
+}
+
+#endif // AVX512_OPS

mlir/include/mlir/Dialect/AVX512/AVX512Dialect.h

+//===- AVX512Dialect.h - MLIR Dialect for AVX512 ----------------*- C++ -*-===//
+//
+// 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 declares the Target dialect for AVX512 in MLIR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_AVX512_AVX512DIALECT_H_
+#define MLIR_DIALECT_AVX512_AVX512DIALECT_H_
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+#include "mlir/Interfaces/SideEffects.h"
+
+namespace mlir {
+namespace avx512 {
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/AVX512/AVX512.h.inc"
+
+#include "mlir/Dialect/AVX512/AVX512Dialect.h.inc"
+
+} // namespace avx512
+} // namespace mlir
+
+#endif // MLIR_DIALECT_AVX512_AVX512DIALECT_H_

mlir/include/mlir/Dialect/AVX512/CMakeLists.txt

+add_mlir_dialect(AVX512 avx512 AVX512Doc)

mlir/include/mlir/Dialect/CMakeLists.txt

 add_subdirectory(AffineOps)
+add_subdirectory(AVX512)
 add_subdirectory(FxpMathOps)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(LoopOps)
 add_subdirectory(OpenMP)
 add_subdirectory(Quant)
 add_subdirectory(Shape)
 add_subdirectory(SPIRV)
 add_subdirectory(StandardOps)
 add_subdirectory(Vector)

mlir/include/mlir/Dialect/LLVMIR/CMakeLists.txt

 mlir_tablegen(LLVMConversionEnumsFromLLVM.inc -gen-enum-from-llvmir-conversions)
 add_public_tablegen_target(MLIRLLVMConversionsIncGen)
 set(LLVM_TARGET_DEFINITIONS NVVMOps.td)
 mlir_tablegen(NVVMConversions.inc -gen-llvmir-conversions)
 add_public_tablegen_target(MLIRNVVMConversionsIncGen)
 set(LLVM_TARGET_DEFINITIONS ROCDLOps.td)
 mlir_tablegen(ROCDLConversions.inc -gen-llvmir-conversions)
 add_public_tablegen_target(MLIRROCDLConversionsIncGen)
+
+add_mlir_dialect(LLVMAVX512 llvm_avx512 LLVMAVX512Doc)
+
+set(LLVM_TARGET_DEFINITIONS LLVMAVX512.td)
+mlir_tablegen(LLVMAVX512Conversions.inc -gen-llvmir-conversions)
+add_public_tablegen_target(MLIRLLVMAVX512ConversionsIncGen)

mlir/include/mlir/Dialect/LLVMIR/LLVMAVX512.td

+//===-- LLVMAVX512.td - LLVMAVX512 dialect op definitions --*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the basic operations for the LLVMAVX512 dialect.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVMIR_AVX512_OPS
+#define LLVMIR_AVX512_OPS
+
+include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
+
+//===----------------------------------------------------------------------===//
+// LLVMAVX512 dialect definition
+//===----------------------------------------------------------------------===//
+
+def LLVMAVX512_Dialect : Dialect {
+  let name = "llvm_avx512";
+  let cppNamespace = "LLVM";
+}
+
+//----------------------------------------------------------------------------//
+// MLIR LLVM AVX512 intrinsics using the MLIR LLVM Dialect type system
+//----------------------------------------------------------------------------//
+
+class LLVMAVX512_IntrOp<string mnemonic, list<OpTrait> traits = []> :
+  LLVM_IntrOpBase<LLVMAVX512_Dialect, mnemonic,
+                  "x86_avx512_" # !subst(".", "_", mnemonic),
+                  [], [], traits, 1>;
+
+def LLVM_x86_avx512_mask_rndscale_ps_512 :
+  LLVMAVX512_IntrOp<"mask.rndscale.ps.512">,
+  Arguments<(ins LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type)>;
+
+def LLVM_x86_avx512_mask_rndscale_pd_512 :
+  LLVMAVX512_IntrOp<"mask.rndscale.pd.512">,
+  Arguments<(ins LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type)>;
+
+def LLVM_x86_avx512_mask_scalef_ps_512 :
+  LLVMAVX512_IntrOp<"mask.scalef.ps.512">,
+  Arguments<(ins LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type)>;
+
+def LLVM_x86_avx512_mask_scalef_pd_512 :
+  LLVMAVX512_IntrOp<"mask.scalef.pd.512">,
+  Arguments<(ins LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type, LLVM_Type)>;
+
+#endif // AVX512_OPS

mlir/include/mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h

+//===- LLVMAVX512Dialect.h - MLIR Dialect for LLVMAVX512 --------*- C++ -*-===//
+//
+// 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 declares the Target dialect for LLVMAVX512 in MLIR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_DIALECT_LLVMIR_LLVMAVX512DIALECT_H_
+#define MLIR_DIALECT_LLVMIR_LLVMAVX512DIALECT_H_
+
+#include "mlir/IR/Dialect.h"
+#include "mlir/IR/OpDefinition.h"
+
+namespace mlir {
+namespace LLVM {
+
+#define GET_OP_CLASSES
+#include "mlir/Dialect/LLVMIR/LLVMAVX512.h.inc"
+
+#include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h.inc"
+
+} // namespace LLVM
+} // namespace mlir
+
+#endif // MLIR_DIALECT_LLVMIR_LLVMAVX512DIALECT_H_

mlir/include/mlir/IR/OpImplementation.h

public:
 
   /// Print an optional arrow followed by a type list.
   template <typename TypeRange>
   void printOptionalArrowTypeList(TypeRange &&types) {
     if (types.begin() != types.end())
       printArrowTypeList(types);
   }
   template <typename TypeRange>
   void printArrowTypeList(TypeRange &&types) {
     auto &os = getStream() << " -> ";
 
     bool wrapped = !has_single_element(types) ||
                    (*types.begin()).template isa<FunctionType>();
     if (wrapped)
       os << '(';
     interleaveComma(types, *this);
     if (wrapped)
public:
   }
   template <typename Operands>
   ParseResult resolveOperands(Operands &&operands, Type type, llvm::SMLoc loc,
                               SmallVectorImpl<Value> &result) {
     return resolveOperands(std::forward<Operands>(operands),
                            ArrayRef<Type>(type), loc, result);
   }
   template <typename Operands, typename Types>
-  ParseResult resolveOperands(Operands &&operands, Types &&types,
-                              llvm::SMLoc loc, SmallVectorImpl<Value> &result) {
+  std::enable_if_t<!std::is_convertible<Types, Type>::value, ParseResult>
+  resolveOperands(Operands &&operands, Types &&types, llvm::SMLoc loc,
+                  SmallVectorImpl<Value> &result) {
     size_t operandSize = std::distance(operands.begin(), operands.end());
     size_t typeSize = std::distance(types.begin(), types.end());
     if (operandSize != typeSize)
       return emitError(loc)
              << operandSize << " operands present, but expected " << typeSize;
 
     for (auto it : llvm::zip(operands, types))
       if (resolveOperand(std::get<0>(it), std::get<1>(it), result))
public:
   // Type Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a type.
   virtual ParseResult parseType(Type &result) = 0;
 
   /// Parse a type of a specific type.
   template <typename TypeT>
   ParseResult parseType(TypeT &result) {
     llvm::SMLoc loc = getCurrentLocation();
 
     // Parse any kind of type.
     Type type;
     if (parseType(type))
       return failure();
 
     // Check for the right kind of attribute.

mlir/include/mlir/InitAllDialects.h

 //===- InitAllDialects.h - MLIR Dialects Registration -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a helper to trigger the registration of all dialects and
 // passes to the system.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INITALLDIALECTS_H_
 #define MLIR_INITALLDIALECTS_H_
 
+#include "mlir/Dialect/AVX512/AVX512Dialect.h"
 #include "mlir/Dialect/AffineOps/AffineOps.h"
 #include "mlir/Dialect/FxpMathOps/FxpMathOps.h"
 #include "mlir/Dialect/GPU/GPUDialect.h"
+#include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 #include "mlir/Dialect/LLVMIR/ROCDLDialect.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/LoopOps/LoopOps.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Dialect/Quant/QuantOps.h"
 #include "mlir/Dialect/SDBM/SDBMDialect.h"
 #include "mlir/Dialect/SPIRV/SPIRVDialect.h"
 #include "mlir/Dialect/Shape/IR/Shape.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/Dialect.h"
 
 namespace mlir {
 
 // This function should be called before creating any MLIRContext if one expect
 // all the possible dialects to be made available to the context automatically.
 inline void registerAllDialects() {
   static bool init_once = []() {
     registerDialect<AffineOpsDialect>();
+    registerDialect<avx512::AVX512Dialect>();
     registerDialect<fxpmath::FxpMathOpsDialect>();
     registerDialect<gpu::GPUDialect>();
+    registerDialect<LLVM::LLVMAVX512Dialect>();
     registerDialect<LLVM::LLVMDialect>();
     registerDialect<linalg::LinalgDialect>();
     registerDialect<loop::LoopOpsDialect>();
     registerDialect<omp::OpenMPDialect>();
     registerDialect<quant::QuantizationDialect>();
     registerDialect<spirv::SPIRVDialect>();
     registerDialect<StandardOpsDialect>();
     registerDialect<vector::VectorDialect>();

mlir/include/mlir/InitAllPasses.h

 // passes to the system.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_INITALLPASSES_H_
 #define MLIR_INITALLPASSES_H_
 
 #include "mlir/Analysis/Passes.h"
+#include "mlir/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.h"
 #include "mlir/Conversion/GPUToCUDA/GPUToCUDAPass.h"
 #include "mlir/Conversion/GPUToNVVM/GPUToNVVMPass.h"
 #include "mlir/Conversion/GPUToROCDL/GPUToROCDLPass.h"
 #include "mlir/Conversion/GPUToSPIRV/ConvertGPUToSPIRVPass.h"
 #include "mlir/Conversion/GPUToVulkan/ConvertGPUToVulkanPass.h"
 #include "mlir/Conversion/LinalgToLLVM/LinalgToLLVM.h"
 #include "mlir/Conversion/LinalgToSPIRV/LinalgToSPIRVPass.h"
 #include "mlir/Conversion/LoopsToGPU/LoopsToGPUPass.h"
inline void registerAllPasses() {
   createAffineDataCopyGenerationPass(0, 0);
   createMemRefDataFlowOptPass();
   createStripDebugInfoPass();
   createPrintOpStatsPass();
   createInlinerPass();
   createSymbolDCEPass();
   createLocationSnapshotPass({});
 
+  // AVX512
+  createConvertAVX512ToLLVMPass();
+
   // GPUtoRODCLPass
   createLowerGpuOpsToROCDLOpsPass();
 
   // FxpOpsDialect passes
   fxpmath::createLowerUniformRealMathPass();
   fxpmath::createLowerUniformCastsPass();
 
   // GPU

mlir/lib/Conversion/AVX512ToLLVM/CMakeLists.txt

+add_mlir_conversion_library(MLIRAVX512ToLLVM
+  ConvertAVX512ToLLVM.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Conversion/AVX512ToLLVM
+)
+
+set(LIBS
+  MLIRAVX512
+  MLIRLLVMAVX512
+  MLIRLLVMIR
+  MLIRStandardToLLVM
+  MLIRTransforms
+  LLVMCore
+  LLVMSupport
+  )
+
+add_dependencies(MLIRAVX512ToLLVM ${LIBS})
+target_link_libraries(MLIRAVX512ToLLVM PUBLIC ${LIBS})

mlir/lib/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.cpp

+//===- ConvertAVX512ToLLVM.cpp - Convert AVX512 to the LLVM dialect -------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Conversion/AVX512ToLLVM/ConvertAVX512ToLLVM.h"
+
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h"
+#include "mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h"
+#include "mlir/Conversion/VectorToLLVM/ConvertVectorToLLVM.h"
+#include "mlir/Dialect/AVX512/AVX512Dialect.h"
+#include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/Dialect/Vector/VectorOps.h"
+#include "mlir/EDSC/Intrinsics.h"
+#include "mlir/IR/Module.h"
+#include "mlir/IR/PatternMatch.h"
+#include "mlir/Pass/Pass.h"
+
+using namespace mlir;
+using namespace mlir::edsc;
+using namespace mlir::edsc::intrinsics;
+using namespace mlir::vector;
+using namespace mlir::avx512;
+
+template <typename OpTy> Type getSrcVectorElementType(OpTy op) {
+  return op.src().getType().template cast<VectorType>().getElementType();
+}
+
+// TODO(ntv, zinenko): Code is currently copy-pasted and adapted from the code
+// 1-1 LLVM conversion. It would better if it were properly exposed in core and
+// reusable.
+/// Basic lowering implementation for one-to-one rewriting from AVX512 Ops to
+/// LLVM Dialect Ops. Convert the type of the result to an LLVM type, pass
+/// operands as is, preserve attributes.
+template <typename SourceOp, typename TargetOp>
+LogicalResult matchAndRewriteOneToOne(const ConvertToLLVMPattern &lowering,
+                                      LLVMTypeConverter &typeConverter,
+                                      Operation *op, ArrayRef<Value> operands,
+                                      ConversionPatternRewriter &rewriter) {
+  unsigned numResults = op->getNumResults();
+
+  Type packedType;
+  if (numResults != 0) {
+    packedType = typeConverter.packFunctionResults(op->getResultTypes());
+    if (!packedType)
+      return failure();
+  }
+
+  auto newOp = rewriter.create<TargetOp>(op->getLoc(), packedType, operands,
+                                         op->getAttrs());
+
+  // If the operation produced 0 or 1 result, return them immediately.
+  if (numResults == 0)
+    return rewriter.eraseOp(op), success();
+  if (numResults == 1)
+    return rewriter.replaceOp(op, newOp.getOperation()->getResult(0)),
+           success();
+
+  // Otherwise, it had been converted to an operation producing a structure.
+  // Extract individual results from the structure and return them as list.
+  SmallVector<Value, 4> results;
+  results.reserve(numResults);
+  for (unsigned i = 0; i < numResults; ++i) {
+    auto type = typeConverter.convertType(op->getResult(i).getType());
+    results.push_back(rewriter.create<LLVM::ExtractValueOp>(
+        op->getLoc(), type, newOp.getOperation()->getResult(0),
+        rewriter.getI64ArrayAttr(i)));
+  }
+  rewriter.replaceOp(op, results);
+  return success();
+}
+
+// TODO(ntv): Patterns are too verbose due to the fact that we have 1 op (e.g.
+// MaskRndScaleOp) and different possible target ops. It would be better to take
+// a Functor so that all these conversions become 1-liners.
+struct MaskRndScaleOpPS512Conversion : public ConvertToLLVMPattern {
+  explicit MaskRndScaleOpPS512Conversion(MLIRContext *context,
+                                         LLVMTypeConverter &typeConverter)
+      : ConvertToLLVMPattern(MaskRndScaleOp::getOperationName(), context,
+                             typeConverter) {}
+
+  LogicalResult
+  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    if (!getSrcVectorElementType(cast<MaskRndScaleOp>(op)).isF32())
+      return failure();
+    return matchAndRewriteOneToOne<MaskRndScaleOp,
+                                   LLVM::x86_avx512_mask_rndscale_ps_512>(
+        *this, this->typeConverter, op, operands, rewriter);
+  }
+};
+
+struct MaskRndScaleOpPD512Conversion : public ConvertToLLVMPattern {
+  explicit MaskRndScaleOpPD512Conversion(MLIRContext *context,
+                                         LLVMTypeConverter &typeConverter)
+      : ConvertToLLVMPattern(MaskRndScaleOp::getOperationName(), context,
+                             typeConverter) {}
+
+  LogicalResult
+  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    if (!getSrcVectorElementType(cast<MaskRndScaleOp>(op)).isF64())
+      return failure();
+    return matchAndRewriteOneToOne<MaskRndScaleOp,
+                                   LLVM::x86_avx512_mask_rndscale_pd_512>(
+        *this, this->typeConverter, op, operands, rewriter);
+  }
+};
+
+struct ScaleFOpPS512Conversion : public ConvertToLLVMPattern {
+  explicit ScaleFOpPS512Conversion(MLIRContext *context,
+                                   LLVMTypeConverter &typeConverter)
+      : ConvertToLLVMPattern(MaskScaleFOp::getOperationName(), context,
+                             typeConverter) {}
+
+  LogicalResult
+  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    if (!getSrcVectorElementType(cast<MaskScaleFOp>(op)).isF32())
+      return failure();
+    return matchAndRewriteOneToOne<MaskScaleFOp,
+                                   LLVM::x86_avx512_mask_scalef_ps_512>(
+        *this, this->typeConverter, op, operands, rewriter);
+  }
+};
+
+struct ScaleFOpPD512Conversion : public ConvertToLLVMPattern {
+  explicit ScaleFOpPD512Conversion(MLIRContext *context,
+                                   LLVMTypeConverter &typeConverter)
+      : ConvertToLLVMPattern(MaskScaleFOp::getOperationName(), context,
+                             typeConverter) {}
+
+  LogicalResult
+  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+                  ConversionPatternRewriter &rewriter) const override {
+    if (!getSrcVectorElementType(cast<MaskScaleFOp>(op)).isF64())
+      return failure();
+    return matchAndRewriteOneToOne<MaskScaleFOp,
+                                   LLVM::x86_avx512_mask_scalef_pd_512>(
+        *this, this->typeConverter, op, operands, rewriter);
+  }
+};
+
+/// Populate the given list with patterns that convert from AVX512 to LLVM.
+void mlir::populateAVX512ToLLVMConversionPatterns(
+    LLVMTypeConverter &converter, OwningRewritePatternList &patterns) {
+  MLIRContext *ctx = converter.getDialect()->getContext();
+  // clang-format off
+  patterns.insert<MaskRndScaleOpPS512Conversion,
+                  MaskRndScaleOpPD512Conversion,
+                  ScaleFOpPS512Conversion,
+                  ScaleFOpPD512Conversion>(ctx, converter);
+  // clang-format on
+}
+
+namespace {
+struct ConvertAVX512ToLLVMPass : public ModulePass<ConvertAVX512ToLLVMPass> {
+  void runOnModule() override;
+};
+} // namespace
+
+void ConvertAVX512ToLLVMPass::runOnModule() {
+  // Convert to the LLVM IR dialect.
+  OwningRewritePatternList patterns;
+  LLVMTypeConverter converter(&getContext());
+  populateAVX512ToLLVMConversionPatterns(converter, patterns);
+  populateVectorToLLVMConversionPatterns(converter, patterns);
+  populateStdToLLVMConversionPatterns(converter, patterns);
+
+  ConversionTarget target(getContext());
+  target.addLegalDialect<LLVM::LLVMDialect>();
+  target.addLegalDialect<LLVM::LLVMAVX512Dialect>();
+  target.addIllegalDialect<avx512::AVX512Dialect>();
+  target.addDynamicallyLegalOp<FuncOp>(
+      [&](FuncOp op) { return converter.isSignatureLegal(op.getType()); });
+  if (failed(
+          applyPartialConversion(getModule(), target, patterns, &converter))) {
+    signalPassFailure();
+  }
+}
+
+std::unique_ptr<OpPassBase<ModuleOp>> mlir::createConvertAVX512ToLLVMPass() {
+  return std::make_unique<ConvertAVX512ToLLVMPass>();
+}
+
+static PassRegistration<ConvertAVX512ToLLVMPass> pass(
+    "convert-avx512-to-llvm",
+    "Convert the operations from the avx512 dialect into the LLVM dialect");

mlir/lib/Conversion/CMakeLists.txt

 add_subdirectory(AffineToStandard)
+add_subdirectory(AVX512ToLLVM)
 add_subdirectory(GPUToCUDA)
 add_subdirectory(GPUToNVVM)
 add_subdirectory(GPUToROCDL)
 add_subdirectory(GPUToSPIRV)
 add_subdirectory(GPUToVulkan)
 add_subdirectory(LinalgToLLVM)
 add_subdirectory(LinalgToSPIRV)
 add_subdirectory(LoopsToGPU)
 add_subdirectory(LoopToStandard)
 add_subdirectory(StandardToLLVM)
 add_subdirectory(StandardToSPIRV)
 add_subdirectory(StandardToStandard)
 add_subdirectory(VectorToLLVM)
 add_subdirectory(VectorToLoops)

mlir/lib/Dialect/AVX512/CMakeLists.txt

+add_mlir_dialect_library(MLIRAVX512
+  IR/AVX512Dialect.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/AVX512
+
+  DEPENDS
+  MLIRAVX512IncGen
+  )
+target_link_libraries(MLIRAVX512
+  PUBLIC
+  MLIRIR
+  LLVMSupport
+  )

mlir/lib/Dialect/AVX512/IR/AVX512Dialect.cpp

+//===- AVX512Ops.cpp - MLIR AVX512 ops implementation ---------------------===//
+//
+// 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 implements the AVX512 dialect and its operations.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/AVX512/AVX512Dialect.h"
+#include "mlir/Dialect/Vector/VectorOps.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/TypeUtilities.h"
+
+using namespace mlir;
+
+avx512::AVX512Dialect::AVX512Dialect(MLIRContext *context)
+    : Dialect(getDialectNamespace(), context) {
+  addOperations<
+#define GET_OP_LIST
+#include "mlir/Dialect/AVX512/AVX512.cpp.inc"
+      >();
+}
+
+namespace mlir {
+namespace avx512 {
+#define GET_OP_CLASSES
+#include "mlir/Dialect/AVX512/AVX512.cpp.inc"
+}  // namespace avx512
+} // namespace mlir
+

mlir/lib/Dialect/CMakeLists.txt

+add_subdirectory(AVX512)
 add_subdirectory(AffineOps)
 add_subdirectory(FxpMathOps)
 add_subdirectory(GPU)
 add_subdirectory(Linalg)
 add_subdirectory(LLVMIR)
 add_subdirectory(LoopOps)
 add_subdirectory(OpenMP)
 add_subdirectory(Quant)

mlir/lib/Dialect/LLVMIR/CMakeLists.txt

target_link_libraries(MLIRLLVMIR
   MLIRCallInterfaces
   MLIRControlFlowInterfaces
   MLIROpenMP
   MLIRIR
   MLIRSideEffects
   MLIRSupport
   )
 
+add_mlir_dialect_library(MLIRLLVMAVX512
+  IR/LLVMAVX512Dialect.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
+
+  DEPENDS
+  MLIRLLVMAVX512IncGen
+  MLIRLLVMAVX512ConversionsIncGen
+  )
+target_link_libraries(MLIRLLVMAVX512
+  PUBLIC
+  LLVMAsmParser
+  MLIRIR
+  MLIRLLVMIR
+  MLIRSideEffects
+  LLVMSupport
+  LLVMCore
+  )
+
 add_mlir_dialect_library(MLIRNVVMIR
   IR/NVVMDialect.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Dialect/LLVMIR
 
   DEPENDS
   MLIRNVVMOpsIncGen

mlir/lib/Dialect/LLVMIR/IR/LLVMAVX512Dialect.cpp

+//===- LLVMAVX512Dialect.cpp - MLIR LLVMAVX512 ops implementation ---------===//
+//
+// 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 implements the LLVMAVX512 dialect and its operations.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/IntrinsicsX86.h"
+
+#include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
+#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/IR/Builders.h"
+#include "mlir/IR/OpImplementation.h"
+#include "mlir/IR/TypeUtilities.h"
+
+using namespace mlir;
+
+LLVM::LLVMAVX512Dialect::LLVMAVX512Dialect(MLIRContext *context)
+    : Dialect(getDialectNamespace(), context) {
+  addOperations<
+#define GET_OP_LIST
+#include "mlir/Dialect/LLVMIR/LLVMAVX512.cpp.inc"
+      >();
+}
+
+namespace mlir {
+namespace LLVM {
+#define GET_OP_CLASSES
+#include "mlir/Dialect/LLVMIR/LLVMAVX512.cpp.inc"
+} // namespace LLVM
+} // namespace mlir

mlir/lib/Target/CMakeLists.txt

target_link_libraries(MLIRTargetLLVMIRModuleTranslation
   MLIRLLVMIRTransforms
   LLVMCore
   LLVMIRReader
   LLVMSupport
   LLVMTransformUtils
   MLIRTranslation
   )
 
+add_mlir_library(MLIRTargetAVX512
+  LLVMIR/LLVMAVX512Intr.cpp
+
+  ADDITIONAL_HEADER_DIRS
+  ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
+  DEPENDS
+  MLIRLLVMAVX512ConversionsIncGen
+  )
+target_link_libraries(MLIRTargetAVX512
+  PUBLIC
+  MLIRIR
+  MLIRLLVMAVX512
+  MLIRLLVMIR
+  MLIRTargetLLVMIRModuleTranslation
+  )
+
 add_mlir_library(MLIRTargetLLVMIR
   LLVMIR/ConvertFromLLVMIR.cpp
   LLVMIR/ConvertToLLVMIR.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${MLIR_MAIN_INCLUDE_DIR}/mlir/Target/LLVMIR
   )
 target_link_libraries(MLIRTargetLLVMIR

mlir/lib/Target/LLVMIR/LLVMAVX512Intr.cpp

+//===- AVX512Intr.cpp - Convert MLIR LLVM dialect to LLVM intrinsics ------===//
+//
+// 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 implements a translation between the MLIR LLVM and AVX512 dialects
+// and LLVM IR with AVX intrinsics.
+//
+//===----------------------------------------------------------------------===//
+
+#include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h"
+#include "mlir/Target/LLVMIR/ModuleTranslation.h"
+#include "mlir/Translation.h"
+#include "llvm/IR/IntrinsicsX86.h"
+
+using namespace mlir;
+
+namespace {
+class LLVMAVX512ModuleTranslation : public LLVM::ModuleTranslation {
+  friend LLVM::ModuleTranslation;
+
+public:
+  using LLVM::ModuleTranslation::ModuleTranslation;
+
+protected:
+  LogicalResult convertOperation(Operation &opInst,
+                                 llvm::IRBuilder<> &builder) override {
+#include "mlir/Dialect/LLVMIR/LLVMAVX512Conversions.inc"
+
+    return LLVM::ModuleTranslation::convertOperation(opInst, builder);
+  }
+};
+
+std::unique_ptr<llvm::Module> translateLLVMAVX512ModuleToLLVMIR(Operation *m) {
+  return LLVM::ModuleTranslation::translateModule<LLVMAVX512ModuleTranslation>(
+      m);
+}
+} // end namespace
+
+static TranslateFromMLIRRegistration
+    reg("avx512-mlir-to-llvmir", [](ModuleOp module, raw_ostream &output) {
+      auto llvmModule = translateLLVMAVX512ModuleToLLVMIR(module);
+      if (!llvmModule)
+        return failure();
+
+      llvmModule->print(output, nullptr);
+      return success();
+    });

mlir/test/Conversion/AVX512ToLLVM/convert-to-llvm.mlir

+// RUN: mlir-opt %s -convert-avx512-to-llvm | mlir-opt | FileCheck %s
+
+func @avx512_mask_rndscale(%a: vector<16xf32>, %b: vector<8xf64>, %i32: i32, %i16: i16, %i8: i8)
+  -> (vector<16xf32>, vector<8xf64>)
+{
+  // CHECK: llvm_avx512.mask.rndscale.ps.512
+  %0 = avx512.mask.rndscale %a, %i32, %a, %i16, %i32: vector<16xf32>
+  // CHECK: llvm_avx512.mask.rndscale.pd.512
+  %1 = avx512.mask.rndscale %b, %i32, %b, %i8, %i32: vector<8xf64>
+
+  // CHECK: llvm_avx512.mask.scalef.ps.512
+  %a0 = avx512.mask.scalef %a, %a, %a, %i16, %i32: vector<16xf32>
+  // CHECK: llvm_avx512.mask.scalef.pd.512
+  %a1 = avx512.mask.scalef %b, %b, %b, %i8, %i32: vector<8xf64>
+
+  return %a0, %a1: vector<16xf32>, vector<8xf64>
+}

mlir/test/Dialect/AVX512/roundtrip.mlir

+// RUN: mlir-opt -verify-diagnostics %s | mlir-opt | FileCheck %s
+
+func @avx512_mask_rndscale(%a: vector<16xf32>, %b: vector<8xf64>, %i32: i32, %i16: i16, %i8: i8)
+  -> (vector<16xf32>, vector<8xf64>)
+{
+  // CHECK: avx512.mask.rndscale {{.*}}: vector<16xf32>
+  %0 = avx512.mask.rndscale %a, %i32, %a, %i16, %i32 : vector<16xf32>
+  // CHECK: avx512.mask.rndscale {{.*}}: vector<8xf64>
+  %1 = avx512.mask.rndscale %b, %i32, %b, %i8, %i32 : vector<8xf64>
+  return %0, %1: vector<16xf32>, vector<8xf64>
+}
+
+func @avx512_scalef(%a: vector<16xf32>, %b: vector<8xf64>, %i32: i32, %i16: i16, %i8: i8)
+  -> (vector<16xf32>, vector<8xf64>)
+{
+  // CHECK: avx512.mask.scalef {{.*}}: vector<16xf32>
+  %0 = avx512.mask.scalef %a, %a, %a, %i16, %i32: vector<16xf32>
+  // CHECK: avx512.mask.scalef {{.*}}: vector<8xf64>
+  %1 = avx512.mask.scalef %b, %b, %b, %i8, %i32 : vector<8xf64>
+  return %0, %1: vector<16xf32>, vector<8xf64>
+}

mlir/test/Target/avx512.mlir

+// RUN: mlir-opt -verify-diagnostics %s | mlir-opt | mlir-translate --avx512-mlir-to-llvmir | FileCheck %s
+
+// CHECK-LABEL: define <16 x float> @LLVM_x86_avx512_mask_ps_512
+llvm.func @LLVM_x86_avx512_mask_ps_512(%a: !llvm<"<16 x float>">,
+                                       %b: !llvm.i32,
+                                       %c: !llvm.i16)
+  -> (!llvm<"<16 x float>">)
+{
+  // CHECK: call <16 x float> @llvm.x86.avx512.mask.rndscale.ps.512(<16 x float>
+  %0 = "llvm_avx512.mask.rndscale.ps.512"(%a, %b, %a, %c, %b) :
+    (!llvm<"<16 x float>">, !llvm.i32, !llvm<"<16 x float>">, !llvm.i16, !llvm.i32) -> !llvm<"<16 x float>">
+  // CHECK: call <16 x float> @llvm.x86.avx512.mask.scalef.ps.512(<16 x float>
+  %1 = "llvm_avx512.mask.scalef.ps.512"(%a, %a, %a, %c, %b) :
+    (!llvm<"<16 x float>">, !llvm<"<16 x float>">, !llvm<"<16 x float>">, !llvm.i16, !llvm.i32) -> !llvm<"<16 x float>">
+  llvm.return %1: !llvm<"<16 x float>">
+}
+
+// CHECK-LABEL: define <8 x double> @LLVM_x86_avx512_mask_pd_512
+llvm.func @LLVM_x86_avx512_mask_pd_512(%a: !llvm<"<8 x double>">,
+                                       %b: !llvm.i32,
+                                       %c: !llvm.i8)
+  -> (!llvm<"<8 x double>">)
+{
+  // CHECK: call <8 x double> @llvm.x86.avx512.mask.rndscale.pd.512(<8 x double>
+  %0 = "llvm_avx512.mask.rndscale.pd.512"(%a, %b, %a, %c, %b) :
+    (!llvm<"<8 x double>">, !llvm.i32, !llvm<"<8 x double>">, !llvm.i8, !llvm.i32) -> !llvm<"<8 x double>">
+  // CHECK: call <8 x double> @llvm.x86.avx512.mask.scalef.pd.512(<8 x double>
+  %1 = "llvm_avx512.mask.scalef.pd.512"(%a, %a, %a, %c, %b) :
+    (!llvm<"<8 x double>">, !llvm<"<8 x double>">, !llvm<"<8 x double>">, !llvm.i8, !llvm.i32) -> !llvm<"<8 x double>">
+  llvm.return %1: !llvm<"<8 x double>">
+}

mlir/tools/mlir-translate/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 set(LIBS
   ${dialect_libs}
   MLIRParser
   MLIRPass
   MLIRSPIRV
   MLIRSPIRVSerialization
+  MLIRTargetAVX512
   MLIRTargetLLVMIR
   MLIRTargetNVVMIR
   MLIRTargetROCDLIR
   MLIRTranslation
   MLIRSupport
 )
 set(FULL_LIBS
   MLIRSPIRVSerialization
+  MLIRTargetAVX512
   MLIRTargetLLVMIR
   MLIRTargetNVVMIR
   MLIRTargetROCDLIR
 )
 add_llvm_tool(mlir-translate
   mlir-translate.cpp
 )
 llvm_update_compile_flags(mlir-translate)
 whole_archive_link(mlir-translate ${FULL_LIBS})
 target_link_libraries(mlir-translate PRIVATE MLIRIR MLIRTranslateClParser ${LIBS} LLVMSupport)