Pickup patches form 20.x into 21.x

llvm/cmake/modules/HandleLLVMOptions.cmake

@@ -797,6 +797,16 @@ if (MSVC)
 
   # Enable warnings
   if (LLVM_ENABLE_WARNINGS)
+    # Remove all -wd flag to enable warnings
+    if (NOT CLANG_CL)
+      set(msvc_warning_flags
+        # Promoted warnings.
+        -w14062 # Promote 'enumerator in switch of enum is not handled' to level 1 warning.
+
+        # Promoted warnings to errors.
+        -we4238 # Promote 'nonstandard extension used : class rvalue used as lvalue' to error.
+      )
+    endif(NOT CLANG_CL)
     # Put /W4 in front of all the -we flags. cl.exe doesn't care, but for
     # clang-cl having /W4 after the -we flags will re-enable the warnings
     # disabled by -we.

llvm/include/llvm/ADT/FunctionExtras.h

@@ -153,7 +153,7 @@ template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
       void *StoragePtr;
       size_t Size;
       size_t Alignment;
-    } OutOfLineStorage;
+    } OutOfLineStorage = {};
     static_assert(
         sizeof(OutOfLineStorageT) <= InlineStorageSize,
         "Should always use all of the out-of-line storage for inline storage!");

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

@@ -1444,8 +1444,8 @@ void DWARFVerifier::verifyNameIndexAttribute(
   }
 
   if (AttrEnc.Index == dwarf::DW_IDX_parent) {
-    constexpr static auto AllowedForms = {dwarf::Form::DW_FORM_flag_present,
-                                          dwarf::Form::DW_FORM_ref4};
+    static constexpr dwarf::Form AllowedForms[] = {
+        dwarf::Form::DW_FORM_flag_present, dwarf::Form::DW_FORM_ref4};
     if (!is_contained(AllowedForms, AttrEnc.Form)) {
       ErrorCategory.Report("Unexpected NameIndex Abbreviation", [&]() {
         error() << formatv(

llvm/lib/Support/Windows/Threading.inc

@@ -42,6 +42,9 @@ void llvm_thread_join_impl(HANDLE hThread) {
   if (::WaitForSingleObject(hThread, INFINITE) == WAIT_FAILED) {
     ReportLastErrorFatal("WaitForSingleObject failed");
   }
+  if (::CloseHandle(hThread) == FALSE) {
+    ReportLastErrorFatal("CloseHandle failed");
+  }
 }
 
 void llvm_thread_detach_impl(HANDLE hThread) {

mlir/docs/DefiningDialects/AttributesAndTypes.md

@@ -565,6 +565,11 @@ For Attributes, these methods will have the form:
 
 - `void MyAttr::print(AsmPrinter &p) const`
 
+It is possible to use newlines and indents in custom `print` methods.
+However, multiline Types or Attributes are not recommended nor allowed in the upstream MLIR dialects.
+They can be used in custom dialects to improve flexibility and readability, e.g. in cases of
+multiple nested Types and Attributes.
+
 #### Using `assemblyFormat`
 
 Attributes and types defined in ODS with a mnemonic can define an

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h

@@ -260,12 +260,12 @@ struct BufferizationOptions {
       std::function<LogicalResult(OpBuilder &, Location, Value, Value)>;
   /// Initializer function for analysis state.
   using AnalysisStateInitFn = std::function<void(AnalysisState &)>;
-  /// Tensor -> MemRef type converter.
-  /// Parameters: tensor type, memory space, func op, bufferization options
+  /// Tensor-like -> Buffer-like type conversion.
+  /// Parameters: tensor-like type, memory space, func op, bufferization options
   using FunctionArgTypeConverterFn =
-      std::function<BaseMemRefType(TensorType, Attribute memorySpace,
+      std::function<BufferLikeType(TensorLikeType, Attribute memorySpace,
                                    func::FuncOp, const BufferizationOptions &)>;
-  /// Tensor -> MemRef type converter.
+  /// Tensor -> MemRef type conversion.
   /// Parameters: tensor type, memory space, bufferization options
   using UnknownTypeConverterFn = std::function<BaseMemRefType(
       TensorType, Attribute memorySpace, const BufferizationOptions &)>;
@@ -335,10 +335,12 @@ struct BufferizationOptions {
   /// predictable.
   void setFunctionBoundaryTypeConversion(LayoutMapOption layoutMapOption);
 
-  /// Type converter from tensors to memrefs. This type converter is used to
-  /// determine bufferized function argument and result types. By default, a
-  /// type converter that returns a memref type with a fully dynamic layout map
-  /// is used.
+  /// Type conversion from tensors to buffers. This type conversion is used to
+  /// determine bufferized function argument and result types.
+  ///
+  /// By default, if tensor is a (builtin) tensor type, it is converted to a
+  /// memref type with a fully dynamic layout map; if tensor is a (generic)
+  /// tensor-like type, it is converted using TensorLikeType::getBufferType().
   ///
   /// If `bufferizeFunctionBoundaries` is not set, this function isn't used.
   FunctionArgTypeConverterFn functionArgTypeConverterFn = nullptr;
@@ -350,10 +352,9 @@ struct BufferizationOptions {
   /// If `bufferizeFunctionBoundaries` is not set, this flag has no effect.
   bool inferFunctionResultLayout = true;
 
-  /// Type converter from tensors to memrefs. This type converter is used if no
-  /// memref type could be inferred during bufferization. By default, a type
-  /// converter that returns a memref type with a fully dynamic layout map is
-  /// used.
+  /// Type conversion from tensors to memrefs. This type conversion is used if
+  /// no memref type could be inferred during bufferization. By default, returns
+  /// a memref type with a fully dynamic layout map.
   UnknownTypeConverterFn unknownTypeConverterFn = nullptr;
 
   // Use during type conversion to determine the memory space for memref based

mlir/include/mlir/Dialect/Quant/IR/QuantBase.td

@@ -402,6 +402,26 @@ class quant_ScalarOrTensorOf<Type etype> :
 def quant_QuantizedType :
     Type<CPred<"::llvm::isa<mlir::quant::QuantizedType>($_self)">, "quantized type">;
 
+// UniformQuantizedPerAxisType
+def quant_UniformQuantizedPerAxisType :
+    DialectType<Quant_Dialect,
+    CPred<"::llvm::isa<::mlir::quant::UniformQuantizedPerAxisType>($_self)">,
+    "UniformQuantizedPerAxisType">;
+
+// QuantileQuantizedPerAxisType
+def quant_QuantileQuantizedPerAxisType :
+    DialectType<Quant_Dialect,
+    CPred<"::llvm::isa<::mlir::quant::QuantileQuantizedPerAxisType>($_self)">,
+    "QuantileQuantizedPerAxisType">;
+
+// Predicate for detecting a container or primitive of UniformQuantizedPerAxisType.
+def quant_UniformQuantizedPerAxisValueType :
+    quant_ScalarOrTensorOf<quant_UniformQuantizedPerAxisType>;
+
+// Predicate for detecting a container or primitive of QuantileQuantizedPerAxisType.
+def quant_QuantileQuantizedPerAxisValueType :
+    quant_ScalarOrTensorOf<quant_QuantileQuantizedPerAxisType>;
+
 def quant_ScalarType :
     Type<Or<[
       AnySignlessInteger.predicate,

mlir/include/mlir/Dialect/Quant/IR/QuantDialectBytecode.td

@@ -97,6 +97,37 @@ def UniformQuantizedSubChannelType
   }];
 }
 
+def QuantileQuantizedType: DialectType<(type
+  VarInt:$flags,
+  Type:$storageType,
+  Type:$quantileType,
+  Type:$expressedType,
+  Array<DoubleAPFloatList>:$quantiles,
+  DoubleAPFloat:$scale,
+  SignedVarInt:$zeroPoint,
+  SignedVarInt:$storageTypeMin,
+  SignedVarInt:$storageTypeMax
+)>;
+
+def QuantileQuantizedPerAxisType: DialectType<(type
+  VarInt:$flags,
+  Type:$storageType,
+  Type:$quantileType,
+  Type:$expressedType,
+  VarInt:$quantizedDimension,
+  SignedVarInt:$storageTypeMin,
+  SignedVarInt:$storageTypeMax,
+  Array<DoubleAPFloatList>:$quantiles,
+  Array<DoubleAPFloatList>:$scales,
+  Array<SignedVarIntList>:$zeroPoints
+)> {
+  // Note: builder order differs from bytecode.
+  let cBuilder = [{
+      get<$_resultType>(context, flags, storageType, quantileType, expressedType, quantiles, scales,
+        zeroPoints, quantizedDimension, storageTypeMin, storageTypeMax)
+  }];
+}
+
 /// This enum contains marker codes used to indicate which attribute is
 /// currently being decoded, and how it should be decoded. The order of these
 /// codes should generally be unchanged, as any changes will inevitably break
@@ -106,7 +137,8 @@ def QuantDialectTypes : DialectTypes<"Quant"> {
   let elems = [ReservedOrDead, AnyQuantizedType,
                AnyQuantizedTypeWithExpressedType, CalibratedQuantizedType,
                UniformQuantizedType, UniformQuantizedPerAxisType,
-               UniformQuantizedSubChannelType];
+               UniformQuantizedSubChannelType,
+               QuantileQuantizedType, QuantileQuantizedPerAxisType];
 }
 
 #endif // QUANT_BYTECODE