Add default DataLayout support for complex numbers

[ftynse]

Thanks! Please update DataLayout.md to describe this default.

mlir/lib/Interfaces/DataLayoutInterfaces.cpp

57–59

How do we handle size in bytes for, e.g. complex<i4> (if that is even allowed)? The size in bits is 8, but the byte size may be 2 if each i4 should be aligned at byte boundary.

[tpopp]

Change complex DataLayout size computation to include alignment padding between elements.

[tpopp]

Please let me know what you think of my interpretation of the default sizes for complex types.

mlir/lib/Interfaces/DataLayoutInterfaces.cpp

57–59

Good point. I changed this to also include any padding needed to keep both elements in the structure aligned.

I'm proposing that bitsize be 12 in the case of complex<i4> (the 2 elements and the padding to align the second element). This is the most accurate representation if treating complex like a C struct.

This would not guarantee that collections of the struct are aligned when only considering bitsize of the object and would require the users to remember to compute the aligned size, but I think that's best rather than giving a false representation.

mlir/docs/DataLayout.md

 ```
 
 specifies that `index` has 32 bits. All other layout properties of `index` match
 those of the integer type with the same bitwidth defined above.
 
 In absence of the corresponding entry, `index` is assumed to be a 64-bit
 integer.
 
+#### `complex` type
+
+By default complex type is treated like a 2 element structure of its given
+element type. This is to say that each of its elements are aligned to their
+preferred alignment, the entire complex type is also aligned to this preference,
+and the complex type size includes the possible padding between elements to enforce
+alignment.
+
 ### Byte Size
 
 The default data layout assumes 8-bit bytes.
 
 ### DLTI Dialect
 
 The [DLTI](Dialects/DLTI.md) dialect provides the attributes implementing
 `DataLayoutSpecInterface` and `DataLayoutEntryInterface`, as well as a dialect
 attribute that can be used to attach the specification to a given operation. The
 verifier of this attribute triggers those of the specification and checks the
 compatiblity of nested specifications.

mlir/lib/Interfaces/DataLayoutInterfaces.cpp

 //===- DataLayoutInterfaces.cpp - Data Layout Interface 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Operation.h"
 
 #include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Support/MathExtras.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // Default implementations
 //===----------------------------------------------------------------------===//
 
 /// Reports that the given type is missing the data layout information and

 }
 
 unsigned mlir::detail::getDefaultTypeSizeInBits(Type type,
                                                 const DataLayout &dataLayout,
                                                 DataLayoutEntryListRef params) {
   if (type.isa<IntegerType, FloatType>())
     return type.getIntOrFloatBitWidth();
 
+  if (auto ctype = type.dyn_cast<ComplexType>()) {
+    auto et = ctype.getElementType();
+    auto innerAlignment =
+        getDefaultPreferredAlignment(et, dataLayout, params) * 8;
+    auto innerSize = getDefaultTypeSizeInBits(et, dataLayout, params);
+
+    // Include padding required to align the imaginary value in the complex
+    // type.
+    return llvm::alignTo(innerSize, innerAlignment) + innerSize;
+  }
+
   // Index is an integer of some bitwidth.
   if (type.isa<IndexType>())
     return dataLayout.getTypeSizeInBits(
         IntegerType::get(type.getContext(), getIndexBitwidth(params)));
 
   // Sizes of vector types are rounded up to those of types with closest
   // power-of-two number of elements in the innermost dimension. We also assume
   // there is no bit-packing at the moment element sizes are taken in bytes and
return dataLayout.getTypeABIAlignment(
         IntegerType::get(type.getContext(), getIndexBitwidth(params)));
 
   if (auto intType = type.dyn_cast<IntegerType>()) {
     return intType.getWidth() < 64
                ? llvm::PowerOf2Ceil(llvm::divideCeil(intType.getWidth(), 8))
                : 4;
   }
 
+  if (auto ctype = type.dyn_cast<ComplexType>())
+    return getDefaultABIAlignment(ctype.getElementType(), dataLayout, params);
+
   if (auto typeInterface = type.dyn_cast<DataLayoutTypeInterface>())
     return typeInterface.getABIAlignment(dataLayout, params);
 
   reportMissingDataLayout(type);
 }
 
 unsigned mlir::detail::getDefaultPreferredAlignment(
     Type type, const DataLayout &dataLayout,
     ArrayRef<DataLayoutEntryInterface> params) {
   // Preferred alignment is same as natural for floats and vectors.
   if (type.isa<FloatType, VectorType>())
     return dataLayout.getTypeABIAlignment(type);
 
   // Preferred alignment is the cloest power-of-two number above for integers
   // (ABI alignment may be smaller).
   if (type.isa<IntegerType, IndexType>())
     return llvm::PowerOf2Ceil(dataLayout.getTypeSize(type));
 
+  if (auto ctype = type.dyn_cast<ComplexType>())
+    return getDefaultPreferredAlignment(ctype.getElementType(), dataLayout,
+                                        params);
+
   if (auto typeInterface = type.dyn_cast<DataLayoutTypeInterface>())
     return typeInterface.getPreferredAlignment(dataLayout, params);
 
   reportMissingDataLayout(type);
 }
 
 DataLayoutEntryList
 mlir::detail::filterEntriesForType(DataLayoutEntryListRef entries,

mlir/test/Interfaces/DataLayoutInterfaces/query.mlir

 // RUN: mlir-opt --test-data-layout-query %s | FileCheck %s
 
 // CHECK-LABEL: @no_layout_builtin
 func @no_layout_builtin() {
   // CHECK: alignment = 4
   // CHECK: bitsize = 32
   // CHECK: preferred = 4
   // CHECK: size = 4
   "test.data_layout_query"() : () -> i32
   // CHECK: alignment = 8
   // CHECK: bitsize = 64
   // CHECK: preferred = 8
   // CHECK: size = 8
   "test.data_layout_query"() : () -> f64
+  // CHECK: alignment = 4
+  // CHECK: bitsize = 64
+  // CHECK: preferred = 4
+  // CHECK: size = 8
+  "test.data_layout_query"() : () -> complex<f32>
+  // CHECK: alignment = 1
+  // CHECK: bitsize = 14
+  // CHECK: preferred = 1
+  // CHECK: size = 2
+  "test.data_layout_query"() : () -> complex<i6>
   return
+
 }
 
 // CHECK-LABEL: @no_layout_custom
 func @no_layout_custom() {
   // CHECK: alignment = 1
   // CHECK: bitsize = 1
   // CHECK: preferred = 1
   // CHECK: size = 1