1//===- LLVMTypes.cpp - MLIR LLVM dialect types ------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the types for the LLVM dialect in MLIR. These MLIR types
10// correspond to the LLVM IR type system.
11//
12//===----------------------------------------------------------------------===//
13
14#include "TypeDetail.h"
15
16#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
17#include "mlir/Dialect/LLVMIR/LLVMTypes.h"
18#include "mlir/IR/BuiltinTypes.h"
19#include "mlir/IR/DialectImplementation.h"
20#include "mlir/IR/TypeSupport.h"
21
22#include "llvm/ADT/ScopeExit.h"
23#include "llvm/ADT/TypeSwitch.h"
24#include "llvm/Support/TypeSize.h"
25#include <optional>
26
27using namespace mlir;
28using namespace mlir::LLVM;
29
30constexpr const static uint64_t kBitsInByte = 8;
31
32//===----------------------------------------------------------------------===//
33// custom<FunctionTypes>
34//===----------------------------------------------------------------------===//
35
36static ParseResult parseFunctionTypes(AsmParser &p, SmallVector<Type> &params,
37 bool &isVarArg) {
38 isVarArg = false;
39 // `(` `)`
40 if (succeeded(Result: p.parseOptionalRParen()))
41 return success();
42
43 // `(` `...` `)`
44 if (succeeded(Result: p.parseOptionalEllipsis())) {
45 isVarArg = true;
46 return p.parseRParen();
47 }
48
49 // type (`,` type)* (`,` `...`)?
50 Type type;
51 if (parsePrettyLLVMType(p, type))
52 return failure();
53 params.push_back(Elt: type);
54 while (succeeded(Result: p.parseOptionalComma())) {
55 if (succeeded(Result: p.parseOptionalEllipsis())) {
56 isVarArg = true;
57 return p.parseRParen();
58 }
59 if (parsePrettyLLVMType(p, type))
60 return failure();
61 params.push_back(Elt: type);
62 }
63 return p.parseRParen();
64}
65
66static void printFunctionTypes(AsmPrinter &p, ArrayRef<Type> params,
67 bool isVarArg) {
68 llvm::interleaveComma(c: params, os&: p,
69 each_fn: [&](Type type) { printPrettyLLVMType(p, type); });
70 if (isVarArg) {
71 if (!params.empty())
72 p << ", ";
73 p << "...";
74 }
75 p << ')';
76}
77
78//===----------------------------------------------------------------------===//
79// custom<ExtTypeParams>
80//===----------------------------------------------------------------------===//
81
82/// Parses the parameter list for a target extension type. The parameter list
83/// contains an optional list of type parameters, followed by an optional list
84/// of integer parameters. Type and integer parameters cannot be interleaved in
85/// the list.
86/// extTypeParams ::= typeList? | intList? | (typeList "," intList)
87/// typeList ::= type ("," type)*
88/// intList ::= integer ("," integer)*
89static ParseResult
90parseExtTypeParams(AsmParser &p, SmallVectorImpl<Type> &typeParams,
91 SmallVectorImpl<unsigned int> &intParams) {
92 bool parseType = true;
93 auto typeOrIntParser = [&]() -> ParseResult {
94 unsigned int i;
95 auto intResult = p.parseOptionalInteger(result&: i);
96 if (intResult.has_value() && !failed(Result: *intResult)) {
97 // Successfully parsed an integer.
98 intParams.push_back(Elt: i);
99 // After the first integer was successfully parsed, no
100 // more types can be parsed.
101 parseType = false;
102 return success();
103 }
104 if (parseType) {
105 Type t;
106 if (!parsePrettyLLVMType(p, type&: t)) {
107 // Successfully parsed a type.
108 typeParams.push_back(Elt: t);
109 return success();
110 }
111 }
112 return failure();
113 };
114 if (p.parseCommaSeparatedList(parseElementFn: typeOrIntParser)) {
115 p.emitError(loc: p.getCurrentLocation(),
116 message: "failed to parse parameter list for target extension type");
117 return failure();
118 }
119 return success();
120}
121
122static void printExtTypeParams(AsmPrinter &p, ArrayRef<Type> typeParams,
123 ArrayRef<unsigned int> intParams) {
124 p << typeParams;
125 if (!typeParams.empty() && !intParams.empty())
126 p << ", ";
127
128 p << intParams;
129}
130
131//===----------------------------------------------------------------------===//
132// ODS-Generated Definitions
133//===----------------------------------------------------------------------===//
134
135/// These are unused for now.
136/// TODO: Move over to these once more types have been migrated to TypeDef.
137LLVM_ATTRIBUTE_UNUSED static OptionalParseResult
138generatedTypeParser(AsmParser &parser, StringRef *mnemonic, Type &value);
139LLVM_ATTRIBUTE_UNUSED static LogicalResult
140generatedTypePrinter(Type def, AsmPrinter &printer);
141
142#include "mlir/Dialect/LLVMIR/LLVMTypeInterfaces.cpp.inc"
143
144#define GET_TYPEDEF_CLASSES
145#include "mlir/Dialect/LLVMIR/LLVMTypes.cpp.inc"
146
147//===----------------------------------------------------------------------===//
148// LLVMArrayType
149//===----------------------------------------------------------------------===//
150
151bool LLVMArrayType::isValidElementType(Type type) {
152 return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
153 LLVMFunctionType, LLVMTokenType>(type);
154}
155
156LLVMArrayType LLVMArrayType::get(Type elementType, uint64_t numElements) {
157 assert(elementType && "expected non-null subtype");
158 return Base::get(elementType.getContext(), elementType, numElements);
159}
160
161LLVMArrayType
162LLVMArrayType::getChecked(function_ref<InFlightDiagnostic()> emitError,
163 Type elementType, uint64_t numElements) {
164 assert(elementType && "expected non-null subtype");
165 return Base::getChecked(emitError, elementType.getContext(), elementType,
166 numElements);
167}
168
169LogicalResult
170LLVMArrayType::verify(function_ref<InFlightDiagnostic()> emitError,
171 Type elementType, uint64_t numElements) {
172 if (!isValidElementType(elementType))
173 return emitError() << "invalid array element type: " << elementType;
174 return success();
175}
176
177//===----------------------------------------------------------------------===//
178// DataLayoutTypeInterface
179//===----------------------------------------------------------------------===//
180
181llvm::TypeSize
182LLVMArrayType::getTypeSizeInBits(const DataLayout &dataLayout,
183 DataLayoutEntryListRef params) const {
184 return llvm::TypeSize::getFixed(kBitsInByte *
185 getTypeSize(dataLayout, params));
186}
187
188llvm::TypeSize LLVMArrayType::getTypeSize(const DataLayout &dataLayout,
189 DataLayoutEntryListRef params) const {
190 return llvm::alignTo(dataLayout.getTypeSize(getElementType()),
191 dataLayout.getTypeABIAlignment(getElementType())) *
192 getNumElements();
193}
194
195uint64_t LLVMArrayType::getABIAlignment(const DataLayout &dataLayout,
196 DataLayoutEntryListRef params) const {
197 return dataLayout.getTypeABIAlignment(getElementType());
198}
199
200uint64_t
201LLVMArrayType::getPreferredAlignment(const DataLayout &dataLayout,
202 DataLayoutEntryListRef params) const {
203 return dataLayout.getTypePreferredAlignment(getElementType());
204}
205
206//===----------------------------------------------------------------------===//
207// Function type.
208//===----------------------------------------------------------------------===//
209
210bool LLVMFunctionType::isValidArgumentType(Type type) {
211 return !llvm::isa<LLVMVoidType, LLVMFunctionType>(type);
212}
213
214bool LLVMFunctionType::isValidResultType(Type type) {
215 return !llvm::isa<LLVMFunctionType, LLVMMetadataType, LLVMLabelType>(type);
216}
217
218LLVMFunctionType LLVMFunctionType::get(Type result, ArrayRef<Type> arguments,
219 bool isVarArg) {
220 assert(result && "expected non-null result");
221 return Base::get(result.getContext(), result, arguments, isVarArg);
222}
223
224LLVMFunctionType
225LLVMFunctionType::getChecked(function_ref<InFlightDiagnostic()> emitError,
226 Type result, ArrayRef<Type> arguments,
227 bool isVarArg) {
228 assert(result && "expected non-null result");
229 return Base::getChecked(emitError, result.getContext(), result, arguments,
230 isVarArg);
231}
232
233LLVMFunctionType LLVMFunctionType::clone(TypeRange inputs,
234 TypeRange results) const {
235 if (results.size() != 1 || !isValidResultType(results[0]))
236 return {};
237 if (!llvm::all_of(inputs, isValidArgumentType))
238 return {};
239 return get(results[0], llvm::to_vector(inputs), isVarArg());
240}
241
242ArrayRef<Type> LLVMFunctionType::getReturnTypes() const {
243 return static_cast<detail::LLVMFunctionTypeStorage *>(getImpl())->returnType;
244}
245
246LogicalResult
247LLVMFunctionType::verify(function_ref<InFlightDiagnostic()> emitError,
248 Type result, ArrayRef<Type> arguments, bool) {
249 if (!isValidResultType(result))
250 return emitError() << "invalid function result type: " << result;
251
252 for (Type arg : arguments)
253 if (!isValidArgumentType(arg))
254 return emitError() << "invalid function argument type: " << arg;
255
256 return success();
257}
258
259//===----------------------------------------------------------------------===//
260// DataLayoutTypeInterface
261//===----------------------------------------------------------------------===//
262
263constexpr const static uint64_t kDefaultPointerSizeBits = 64;
264constexpr const static uint64_t kDefaultPointerAlignment = 8;
265
266std::optional<uint64_t> mlir::LLVM::extractPointerSpecValue(Attribute attr,
267 PtrDLEntryPos pos) {
268 auto spec = cast<DenseIntElementsAttr>(Val&: attr);
269 auto idx = static_cast<int64_t>(pos);
270 if (idx >= spec.size())
271 return std::nullopt;
272 return spec.getValues<uint64_t>()[idx];
273}
274
275/// Returns the part of the data layout entry that corresponds to `pos` for the
276/// given `type` by interpreting the list of entries `params`. For the pointer
277/// type in the default address space, returns the default value if the entries
278/// do not provide a custom one, for other address spaces returns std::nullopt.
279static std::optional<uint64_t>
280getPointerDataLayoutEntry(DataLayoutEntryListRef params, LLVMPointerType type,
281 PtrDLEntryPos pos) {
282 // First, look for the entry for the pointer in the current address space.
283 Attribute currentEntry;
284 for (DataLayoutEntryInterface entry : params) {
285 if (!entry.isTypeEntry())
286 continue;
287 if (cast<LLVMPointerType>(cast<Type>(entry.getKey())).getAddressSpace() ==
288 type.getAddressSpace()) {
289 currentEntry = entry.getValue();
290 break;
291 }
292 }
293 if (currentEntry) {
294 std::optional<uint64_t> value = extractPointerSpecValue(attr: currentEntry, pos);
295 // If the optional `PtrDLEntryPos::Index` entry is not available, use the
296 // pointer size as the index bitwidth.
297 if (!value && pos == PtrDLEntryPos::Index)
298 value = extractPointerSpecValue(attr: currentEntry, pos: PtrDLEntryPos::Size);
299 bool isSizeOrIndex =
300 pos == PtrDLEntryPos::Size || pos == PtrDLEntryPos::Index;
301 return *value / (isSizeOrIndex ? 1 : kBitsInByte);
302 }
303
304 // If not found, and this is the pointer to the default memory space, assume
305 // 64-bit pointers.
306 if (type.getAddressSpace() == 0) {
307 bool isSizeOrIndex =
308 pos == PtrDLEntryPos::Size || pos == PtrDLEntryPos::Index;
309 return isSizeOrIndex ? kDefaultPointerSizeBits : kDefaultPointerAlignment;
310 }
311
312 return std::nullopt;
313}
314
315llvm::TypeSize
316LLVMPointerType::getTypeSizeInBits(const DataLayout &dataLayout,
317 DataLayoutEntryListRef params) const {
318 if (std::optional<uint64_t> size =
319 getPointerDataLayoutEntry(params, *this, PtrDLEntryPos::Size))
320 return llvm::TypeSize::getFixed(*size);
321
322 // For other memory spaces, use the size of the pointer to the default memory
323 // space.
324 return dataLayout.getTypeSizeInBits(get(getContext()));
325}
326
327uint64_t LLVMPointerType::getABIAlignment(const DataLayout &dataLayout,
328 DataLayoutEntryListRef params) const {
329 if (std::optional<uint64_t> alignment =
330 getPointerDataLayoutEntry(params, *this, PtrDLEntryPos::Abi))
331 return *alignment;
332
333 return dataLayout.getTypeABIAlignment(get(getContext()));
334}
335
336uint64_t
337LLVMPointerType::getPreferredAlignment(const DataLayout &dataLayout,
338 DataLayoutEntryListRef params) const {
339 if (std::optional<uint64_t> alignment =
340 getPointerDataLayoutEntry(params, *this, PtrDLEntryPos::Preferred))
341 return *alignment;
342
343 return dataLayout.getTypePreferredAlignment(get(getContext()));
344}
345
346std::optional<uint64_t>
347LLVMPointerType::getIndexBitwidth(const DataLayout &dataLayout,
348 DataLayoutEntryListRef params) const {
349 if (std::optional<uint64_t> indexBitwidth =
350 getPointerDataLayoutEntry(params, *this, PtrDLEntryPos::Index))
351 return *indexBitwidth;
352
353 return dataLayout.getTypeIndexBitwidth(get(getContext()));
354}
355
356bool LLVMPointerType::areCompatible(
357 DataLayoutEntryListRef oldLayout, DataLayoutEntryListRef newLayout,
358 DataLayoutSpecInterface newSpec,
359 const DataLayoutIdentifiedEntryMap &map) const {
360 for (DataLayoutEntryInterface newEntry : newLayout) {
361 if (!newEntry.isTypeEntry())
362 continue;
363 uint64_t size = kDefaultPointerSizeBits;
364 uint64_t abi = kDefaultPointerAlignment;
365 auto newType =
366 llvm::cast<LLVMPointerType>(llvm::cast<Type>(newEntry.getKey()));
367 const auto *it =
368 llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
369 if (auto type = llvm::dyn_cast_if_present<Type>(entry.getKey())) {
370 return llvm::cast<LLVMPointerType>(type).getAddressSpace() ==
371 newType.getAddressSpace();
372 }
373 return false;
374 });
375 if (it == oldLayout.end()) {
376 llvm::find_if(oldLayout, [&](DataLayoutEntryInterface entry) {
377 if (auto type = llvm::dyn_cast_if_present<Type>(entry.getKey())) {
378 return llvm::cast<LLVMPointerType>(type).getAddressSpace() == 0;
379 }
380 return false;
381 });
382 }
383 if (it != oldLayout.end()) {
384 size = *extractPointerSpecValue(*it, PtrDLEntryPos::Size);
385 abi = *extractPointerSpecValue(*it, PtrDLEntryPos::Abi);
386 }
387
388 Attribute newSpec = llvm::cast<DenseIntElementsAttr>(newEntry.getValue());
389 uint64_t newSize = *extractPointerSpecValue(newSpec, PtrDLEntryPos::Size);
390 uint64_t newAbi = *extractPointerSpecValue(newSpec, PtrDLEntryPos::Abi);
391 if (size != newSize || abi < newAbi || abi % newAbi != 0)
392 return false;
393 }
394 return true;
395}
396
397LogicalResult LLVMPointerType::verifyEntries(DataLayoutEntryListRef entries,
398 Location loc) const {
399 for (DataLayoutEntryInterface entry : entries) {
400 if (!entry.isTypeEntry())
401 continue;
402 auto key = llvm::cast<Type>(entry.getKey());
403 auto values = llvm::dyn_cast<DenseIntElementsAttr>(entry.getValue());
404 if (!values || (values.size() != 3 && values.size() != 4)) {
405 return emitError(loc)
406 << "expected layout attribute for " << key
407 << " to be a dense integer elements attribute with 3 or 4 "
408 "elements";
409 }
410 if (!values.getElementType().isInteger(64))
411 return emitError(loc) << "expected i64 parameters for " << key;
412
413 if (extractPointerSpecValue(values, PtrDLEntryPos::Abi) >
414 extractPointerSpecValue(values, PtrDLEntryPos::Preferred)) {
415 return emitError(loc) << "preferred alignment is expected to be at least "
416 "as large as ABI alignment";
417 }
418 }
419 return success();
420}
421
422//===----------------------------------------------------------------------===//
423// Struct type.
424//===----------------------------------------------------------------------===//
425
426bool LLVMStructType::isValidElementType(Type type) {
427 return !llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
428 LLVMFunctionType, LLVMTokenType>(type);
429}
430
431LLVMStructType LLVMStructType::getIdentified(MLIRContext *context,
432 StringRef name) {
433 return Base::get(context, name, /*opaque=*/false);
434}
435
436LLVMStructType LLVMStructType::getIdentifiedChecked(
437 function_ref<InFlightDiagnostic()> emitError, MLIRContext *context,
438 StringRef name) {
439 return Base::getChecked(emitError, context, name, /*opaque=*/false);
440}
441
442LLVMStructType LLVMStructType::getNewIdentified(MLIRContext *context,
443 StringRef name,
444 ArrayRef<Type> elements,
445 bool isPacked) {
446 std::string stringName = name.str();
447 unsigned counter = 0;
448 do {
449 auto type = LLVMStructType::getIdentified(context, stringName);
450 if (type.isInitialized() || failed(type.setBody(elements, isPacked))) {
451 counter += 1;
452 stringName = (Twine(name) + "." + std::to_string(counter)).str();
453 continue;
454 }
455 return type;
456 } while (true);
457}
458
459LLVMStructType LLVMStructType::getLiteral(MLIRContext *context,
460 ArrayRef<Type> types, bool isPacked) {
461 return Base::get(context, types, isPacked);
462}
463
464LLVMStructType
465LLVMStructType::getLiteralChecked(function_ref<InFlightDiagnostic()> emitError,
466 MLIRContext *context, ArrayRef<Type> types,
467 bool isPacked) {
468 return Base::getChecked(emitError, context, types, isPacked);
469}
470
471LLVMStructType LLVMStructType::getOpaque(StringRef name, MLIRContext *context) {
472 return Base::get(context, name, /*opaque=*/true);
473}
474
475LLVMStructType
476LLVMStructType::getOpaqueChecked(function_ref<InFlightDiagnostic()> emitError,
477 MLIRContext *context, StringRef name) {
478 return Base::getChecked(emitError, context, name, /*opaque=*/true);
479}
480
481LogicalResult LLVMStructType::setBody(ArrayRef<Type> types, bool isPacked) {
482 assert(isIdentified() && "can only set bodies of identified structs");
483 assert(llvm::all_of(types, LLVMStructType::isValidElementType) &&
484 "expected valid body types");
485 return Base::mutate(types, isPacked);
486}
487
488bool LLVMStructType::isPacked() const { return getImpl()->isPacked(); }
489bool LLVMStructType::isIdentified() const { return getImpl()->isIdentified(); }
490bool LLVMStructType::isOpaque() const {
491 return getImpl()->isIdentified() &&
492 (getImpl()->isOpaque() || !getImpl()->isInitialized());
493}
494bool LLVMStructType::isInitialized() { return getImpl()->isInitialized(); }
495StringRef LLVMStructType::getName() const { return getImpl()->getIdentifier(); }
496ArrayRef<Type> LLVMStructType::getBody() const {
497 return isIdentified() ? getImpl()->getIdentifiedStructBody()
498 : getImpl()->getTypeList();
499}
500
501LogicalResult
502LLVMStructType::verifyInvariants(function_ref<InFlightDiagnostic()>, StringRef,
503 bool) {
504 return success();
505}
506
507LogicalResult
508LLVMStructType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
509 ArrayRef<Type> types, bool) {
510 for (Type t : types)
511 if (!isValidElementType(t))
512 return emitError() << "invalid LLVM structure element type: " << t;
513
514 return success();
515}
516
517llvm::TypeSize
518LLVMStructType::getTypeSizeInBits(const DataLayout &dataLayout,
519 DataLayoutEntryListRef params) const {
520 auto structSize = llvm::TypeSize::getFixed(0);
521 uint64_t structAlignment = 1;
522 for (Type element : getBody()) {
523 uint64_t elementAlignment =
524 isPacked() ? 1 : dataLayout.getTypeABIAlignment(element);
525 // Add padding to the struct size to align it to the abi alignment of the
526 // element type before than adding the size of the element.
527 structSize = llvm::alignTo(structSize, elementAlignment);
528 structSize += dataLayout.getTypeSize(element);
529
530 // The alignment requirement of a struct is equal to the strictest alignment
531 // requirement of its elements.
532 structAlignment = std::max(elementAlignment, structAlignment);
533 }
534 // At the end, add padding to the struct to satisfy its own alignment
535 // requirement. Otherwise structs inside of arrays would be misaligned.
536 structSize = llvm::alignTo(structSize, structAlignment);
537 return structSize * kBitsInByte;
538}
539
540namespace {
541enum class StructDLEntryPos { Abi = 0, Preferred = 1 };
542} // namespace
543
544static std::optional<uint64_t>
545getStructDataLayoutEntry(DataLayoutEntryListRef params, LLVMStructType type,
546 StructDLEntryPos pos) {
547 const auto *currentEntry =
548 llvm::find_if(Range&: params, P: [](DataLayoutEntryInterface entry) {
549 return entry.isTypeEntry();
550 });
551 if (currentEntry == params.end())
552 return std::nullopt;
553
554 auto attr = llvm::cast<DenseIntElementsAttr>(currentEntry->getValue());
555 if (pos == StructDLEntryPos::Preferred &&
556 attr.size() <= static_cast<int64_t>(StructDLEntryPos::Preferred))
557 // If no preferred was specified, fall back to abi alignment
558 pos = StructDLEntryPos::Abi;
559
560 return attr.getValues<uint64_t>()[static_cast<size_t>(pos)];
561}
562
563static uint64_t calculateStructAlignment(const DataLayout &dataLayout,
564 DataLayoutEntryListRef params,
565 LLVMStructType type,
566 StructDLEntryPos pos) {
567 // Packed structs always have an abi alignment of 1
568 if (pos == StructDLEntryPos::Abi && type.isPacked()) {
569 return 1;
570 }
571
572 // The alignment requirement of a struct is equal to the strictest alignment
573 // requirement of its elements.
574 uint64_t structAlignment = 1;
575 for (Type iter : type.getBody()) {
576 structAlignment =
577 std::max(dataLayout.getTypeABIAlignment(iter), structAlignment);
578 }
579
580 // Entries are only allowed to be stricter than the required alignment
581 if (std::optional<uint64_t> entryResult =
582 getStructDataLayoutEntry(params, type, pos))
583 return std::max(a: *entryResult / kBitsInByte, b: structAlignment);
584
585 return structAlignment;
586}
587
588uint64_t LLVMStructType::getABIAlignment(const DataLayout &dataLayout,
589 DataLayoutEntryListRef params) const {
590 return calculateStructAlignment(dataLayout, params, *this,
591 StructDLEntryPos::Abi);
592}
593
594uint64_t
595LLVMStructType::getPreferredAlignment(const DataLayout &dataLayout,
596 DataLayoutEntryListRef params) const {
597 return calculateStructAlignment(dataLayout, params, *this,
598 StructDLEntryPos::Preferred);
599}
600
601static uint64_t extractStructSpecValue(Attribute attr, StructDLEntryPos pos) {
602 return llvm::cast<DenseIntElementsAttr>(attr)
603 .getValues<uint64_t>()[static_cast<size_t>(pos)];
604}
605
606bool LLVMStructType::areCompatible(
607 DataLayoutEntryListRef oldLayout, DataLayoutEntryListRef newLayout,
608 DataLayoutSpecInterface newSpec,
609 const DataLayoutIdentifiedEntryMap &map) const {
610 for (DataLayoutEntryInterface newEntry : newLayout) {
611 if (!newEntry.isTypeEntry())
612 continue;
613
614 const auto *previousEntry =
615 llvm::find_if(oldLayout, [](DataLayoutEntryInterface entry) {
616 return entry.isTypeEntry();
617 });
618 if (previousEntry == oldLayout.end())
619 continue;
620
621 uint64_t abi = extractStructSpecValue(previousEntry->getValue(),
622 StructDLEntryPos::Abi);
623 uint64_t newAbi =
624 extractStructSpecValue(newEntry.getValue(), StructDLEntryPos::Abi);
625 if (abi < newAbi || abi % newAbi != 0)
626 return false;
627 }
628 return true;
629}
630
631LogicalResult LLVMStructType::verifyEntries(DataLayoutEntryListRef entries,
632 Location loc) const {
633 for (DataLayoutEntryInterface entry : entries) {
634 if (!entry.isTypeEntry())
635 continue;
636
637 auto key = llvm::cast<LLVMStructType>(llvm::cast<Type>(entry.getKey()));
638 auto values = llvm::dyn_cast<DenseIntElementsAttr>(entry.getValue());
639 if (!values || (values.size() != 2 && values.size() != 1)) {
640 return emitError(loc)
641 << "expected layout attribute for "
642 << llvm::cast<Type>(entry.getKey())
643 << " to be a dense integer elements attribute of 1 or 2 elements";
644 }
645 if (!values.getElementType().isInteger(64))
646 return emitError(loc) << "expected i64 entries for " << key;
647
648 if (key.isIdentified() || !key.getBody().empty()) {
649 return emitError(loc) << "unexpected layout attribute for struct " << key;
650 }
651
652 if (values.size() == 1)
653 continue;
654
655 if (extractStructSpecValue(values, StructDLEntryPos::Abi) >
656 extractStructSpecValue(values, StructDLEntryPos::Preferred)) {
657 return emitError(loc) << "preferred alignment is expected to be at least "
658 "as large as ABI alignment";
659 }
660 }
661 return mlir::success();
662}
663
664//===----------------------------------------------------------------------===//
665// LLVMTargetExtType.
666//===----------------------------------------------------------------------===//
667
668static constexpr llvm::StringRef kSpirvPrefix = "spirv.";
669static constexpr llvm::StringRef kArmSVCount = "aarch64.svcount";
670
671bool LLVM::LLVMTargetExtType::hasProperty(Property prop) const {
672 // See llvm/lib/IR/Type.cpp for reference.
673 uint64_t properties = 0;
674
675 if (getExtTypeName().starts_with(kSpirvPrefix))
676 properties |=
677 (LLVMTargetExtType::HasZeroInit | LLVM::LLVMTargetExtType::CanBeGlobal);
678
679 return (properties & prop) == prop;
680}
681
682bool LLVM::LLVMTargetExtType::supportsMemOps() const {
683 // See llvm/lib/IR/Type.cpp for reference.
684 if (getExtTypeName().starts_with(kSpirvPrefix))
685 return true;
686
687 if (getExtTypeName() == kArmSVCount)
688 return true;
689
690 return false;
691}
692
693//===----------------------------------------------------------------------===//
694// LLVMPPCFP128Type
695//===----------------------------------------------------------------------===//
696
697const llvm::fltSemantics &LLVMPPCFP128Type::getFloatSemantics() const {
698 return APFloat::PPCDoubleDouble();
699}
700
701//===----------------------------------------------------------------------===//
702// Utility functions.
703//===----------------------------------------------------------------------===//
704
705bool mlir::LLVM::isCompatibleOuterType(Type type) {
706 // clang-format off
707 if (llvm::isa<
708 BFloat16Type,
709 Float16Type,
710 Float32Type,
711 Float64Type,
712 Float80Type,
713 Float128Type,
714 LLVMArrayType,
715 LLVMFunctionType,
716 LLVMLabelType,
717 LLVMMetadataType,
718 LLVMPPCFP128Type,
719 LLVMPointerType,
720 LLVMStructType,
721 LLVMTokenType,
722 LLVMTargetExtType,
723 LLVMVoidType,
724 LLVMX86AMXType
725 >(type)) {
726 // clang-format on
727 return true;
728 }
729
730 // Only signless integers are compatible.
731 if (auto intType = llvm::dyn_cast<IntegerType>(type))
732 return intType.isSignless();
733
734 // 1D vector types are compatible.
735 if (auto vecType = llvm::dyn_cast<VectorType>(type))
736 return vecType.getRank() == 1;
737
738 return false;
739}
740
741static bool isCompatibleImpl(Type type, DenseSet<Type> &compatibleTypes) {
742 if (!compatibleTypes.insert(V: type).second)
743 return true;
744
745 auto isCompatible = [&](Type type) {
746 return isCompatibleImpl(type, compatibleTypes);
747 };
748
749 bool result =
750 llvm::TypeSwitch<Type, bool>(type)
751 .Case<LLVMStructType>([&](auto structType) {
752 return llvm::all_of(structType.getBody(), isCompatible);
753 })
754 .Case<LLVMFunctionType>([&](auto funcType) {
755 return isCompatible(funcType.getReturnType()) &&
756 llvm::all_of(funcType.getParams(), isCompatible);
757 })
758 .Case<IntegerType>([](auto intType) { return intType.isSignless(); })
759 .Case<VectorType>([&](auto vecType) {
760 return vecType.getRank() == 1 &&
761 isCompatible(vecType.getElementType());
762 })
763 .Case<LLVMPointerType>([&](auto pointerType) { return true; })
764 .Case<LLVMTargetExtType>([&](auto extType) {
765 return llvm::all_of(extType.getTypeParams(), isCompatible);
766 })
767 // clang-format off
768 .Case<
769 LLVMArrayType
770 >([&](auto containerType) {
771 return isCompatible(containerType.getElementType());
772 })
773 .Case<
774 BFloat16Type,
775 Float16Type,
776 Float32Type,
777 Float64Type,
778 Float80Type,
779 Float128Type,
780 LLVMLabelType,
781 LLVMMetadataType,
782 LLVMPPCFP128Type,
783 LLVMTokenType,
784 LLVMVoidType,
785 LLVMX86AMXType
786 >([](Type) { return true; })
787 // clang-format on
788 .Default([](Type) { return false; });
789
790 if (!result)
791 compatibleTypes.erase(V: type);
792
793 return result;
794}
795
796bool LLVMDialect::isCompatibleType(Type type) {
797 if (auto *llvmDialect =
798 type.getContext()->getLoadedDialect<LLVM::LLVMDialect>())
799 return isCompatibleImpl(type, llvmDialect->compatibleTypes.get());
800
801 DenseSet<Type> localCompatibleTypes;
802 return isCompatibleImpl(type, localCompatibleTypes);
803}
804
805bool mlir::LLVM::isCompatibleType(Type type) {
806 return LLVMDialect::isCompatibleType(type);
807}
808
809bool mlir::LLVM::isCompatibleFloatingPointType(Type type) {
810 return llvm::isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
811 Float80Type, Float128Type, LLVMPPCFP128Type>(type);
812}
813
814bool mlir::LLVM::isCompatibleVectorType(Type type) {
815 if (auto vecType = llvm::dyn_cast<VectorType>(type)) {
816 if (vecType.getRank() != 1)
817 return false;
818 Type elementType = vecType.getElementType();
819 if (auto intType = llvm::dyn_cast<IntegerType>(elementType))
820 return intType.isSignless();
821 return llvm::isa<BFloat16Type, Float16Type, Float32Type, Float64Type,
822 Float80Type, Float128Type, LLVMPointerType>(elementType);
823 }
824 return false;
825}
826
827llvm::ElementCount mlir::LLVM::getVectorNumElements(Type type) {
828 auto vecTy = dyn_cast<VectorType>(type);
829 assert(vecTy && "incompatible with LLVM vector type");
830 if (vecTy.isScalable())
831 return llvm::ElementCount::getScalable(MinVal: vecTy.getNumElements());
832 return llvm::ElementCount::getFixed(MinVal: vecTy.getNumElements());
833}
834
835bool mlir::LLVM::isScalableVectorType(Type vectorType) {
836 assert(llvm::isa<VectorType>(vectorType) &&
837 "expected LLVM-compatible vector type");
838 return llvm::cast<VectorType>(vectorType).isScalable();
839}
840
841Type mlir::LLVM::getVectorType(Type elementType, unsigned numElements,
842 bool isScalable) {
843 assert(VectorType::isValidElementType(elementType) &&
844 "incompatible element type");
845 return VectorType::get(numElements, elementType, {isScalable});
846}
847
848Type mlir::LLVM::getVectorType(Type elementType,
849 const llvm::ElementCount &numElements) {
850 if (numElements.isScalable())
851 return getVectorType(elementType, numElements: numElements.getKnownMinValue(),
852 /*isScalable=*/true);
853 return getVectorType(elementType, numElements: numElements.getFixedValue(),
854 /*isScalable=*/false);
855}
856
857llvm::TypeSize mlir::LLVM::getPrimitiveTypeSizeInBits(Type type) {
858 assert(isCompatibleType(type) &&
859 "expected a type compatible with the LLVM dialect");
860
861 return llvm::TypeSwitch<Type, llvm::TypeSize>(type)
862 .Case<BFloat16Type, Float16Type>(
863 [](Type) { return llvm::TypeSize::getFixed(16); })
864 .Case<Float32Type>([](Type) { return llvm::TypeSize::getFixed(32); })
865 .Case<Float64Type>([](Type) { return llvm::TypeSize::getFixed(64); })
866 .Case<Float80Type>([](Type) { return llvm::TypeSize::getFixed(80); })
867 .Case<Float128Type>([](Type) { return llvm::TypeSize::getFixed(128); })
868 .Case<IntegerType>([](IntegerType intTy) {
869 return llvm::TypeSize::getFixed(intTy.getWidth());
870 })
871 .Case<LLVMPPCFP128Type>(
872 [](Type) { return llvm::TypeSize::getFixed(128); })
873 .Case<VectorType>([](VectorType t) {
874 assert(isCompatibleVectorType(t) &&
875 "unexpected incompatible with LLVM vector type");
876 llvm::TypeSize elementSize =
877 getPrimitiveTypeSizeInBits(t.getElementType());
878 return llvm::TypeSize(elementSize.getFixedValue() * t.getNumElements(),
879 elementSize.isScalable());
880 })
881 .Default([](Type ty) {
882 assert((llvm::isa<LLVMVoidType, LLVMLabelType, LLVMMetadataType,
883 LLVMTokenType, LLVMStructType, LLVMArrayType,
884 LLVMPointerType, LLVMFunctionType, LLVMTargetExtType>(
885 ty)) &&
886 "unexpected missing support for primitive type");
887 return llvm::TypeSize::getFixed(0);
888 });
889}
890
891//===----------------------------------------------------------------------===//
892// LLVMDialect
893//===----------------------------------------------------------------------===//
894
895void LLVMDialect::registerTypes() {
896 addTypes<
897#define GET_TYPEDEF_LIST
898#include "mlir/Dialect/LLVMIR/LLVMTypes.cpp.inc"
899 >();
900}
901
902Type LLVMDialect::parseType(DialectAsmParser &parser) const {
903 return detail::parseType(parser);
904}
905
906void LLVMDialect::printType(Type type, DialectAsmPrinter &os) const {
907 return detail::printType(type, os);
908}
909

source code of mlir/lib/Dialect/LLVMIR/IR/LLVMTypes.cpp