1//===---- IRTypeMapper.cpp - Maps LLVM ABI Types to LLVM IR Types -------===//
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#include "llvm/ABI/IRTypeMapper.h"
10#include "llvm/ABI/Types.h"
11#include "llvm/ADT/APFloat.h"
12#include "llvm/ADT/SmallVector.h"
13#include "llvm/IR/DataLayout.h"
14#include "llvm/IR/DerivedTypes.h"
15#include "llvm/IR/Type.h"
16#include "llvm/Support/MathExtras.h"
17
18using namespace llvm::abi;
19
20llvm::Type *IRTypeMapper::convertType(const abi::Type *ABIType) {
21 assert(ABIType && "convertType requires a non-null ABI type");
22
23 auto It = TypeCache.find(Val: ABIType);
24 if (It != TypeCache.end())
25 return It->second;
26
27 llvm::Type *Result = nullptr;
28
29 switch (ABIType->getKind()) {
30 case abi::TypeKind::Void:
31 Result = llvm::Type::getVoidTy(C&: Context);
32 break;
33 case abi::TypeKind::Atomic:
34 Result = convertAtomicType(AT: cast<abi::AtomicType>(Val: ABIType));
35 break;
36 case abi::TypeKind::Integer: {
37 const auto *IT = cast<abi::IntegerType>(Val: ABIType);
38 Result =
39 llvm::IntegerType::get(C&: Context, NumBits: IT->getSizeInBits().getFixedValue());
40 break;
41 }
42 case abi::TypeKind::Float: {
43 const llvm::fltSemantics *Semantics =
44 cast<abi::FloatType>(Val: ABIType)->getSemantics();
45 Result = llvm::Type::getFloatingPointTy(C&: Context, S: *Semantics);
46 break;
47 }
48 case abi::TypeKind::OpaqueFloat8:
49 // LLVM represents this format as a one-element i8 vector. The ABI
50 // type stays distinct so classification does not treat it as an
51 // integer or a short vector.
52 Result = llvm::FixedVectorType::get(ElementType: llvm::Type::getInt8Ty(C&: Context), NumElts: 1);
53 break;
54 case abi::TypeKind::Pointer:
55 Result = llvm::PointerType::get(
56 C&: Context, AddressSpace: cast<abi::PointerType>(Val: ABIType)->getAddrSpace());
57 break;
58 case abi::TypeKind::Array:
59 Result = convertArrayType(AT: cast<abi::ArrayType>(Val: ABIType));
60 break;
61 case abi::TypeKind::Vector:
62 Result = convertVectorType(VT: cast<abi::VectorType>(Val: ABIType));
63 break;
64 case abi::TypeKind::Tuple:
65 Result = convertTupleType(TT: cast<abi::TupleType>(Val: ABIType));
66 break;
67 case abi::TypeKind::Record:
68 Result = convertRecordType(RT: cast<abi::RecordType>(Val: ABIType));
69 break;
70 case abi::TypeKind::Complex:
71 Result = convertComplexType(CT: cast<abi::ComplexType>(Val: ABIType));
72 break;
73 case abi::TypeKind::MemberPointer:
74 Result = convertMemberPointerType(MPT: cast<abi::MemberPointerType>(Val: ABIType));
75 break;
76 }
77
78 TypeCache[ABIType] = Result;
79 return Result;
80}
81
82llvm::Type *IRTypeMapper::convertAtomicType(const abi::AtomicType *AT) {
83 llvm::Type *ValueType = convertType(ABIType: AT->getValueType());
84 uint64_t ValueSize = AT->getValueType()->getSizeInBits().getFixedValue();
85 uint64_t AtomicSize = AT->getSizeInBits().getFixedValue();
86 if (ValueSize == AtomicSize)
87 return ValueType;
88
89 assert(ValueSize < AtomicSize && "atomic type cannot shrink its value type");
90 llvm::Type *Fields[] = {ValueType,
91 llvm::ArrayType::get(ElementType: llvm::Type::getInt8Ty(C&: Context),
92 NumElements: (AtomicSize - ValueSize) / 8)};
93 return llvm::StructType::get(Context, Elements: Fields, /*isPacked=*/false);
94}
95
96llvm::Type *IRTypeMapper::convertArrayType(const abi::ArrayType *AT) {
97 llvm::Type *ElementType = convertType(ABIType: AT->getElementType());
98 uint64_t NumElements = AT->getNumElements();
99 if (AT->isMatrixType())
100 return llvm::VectorType::get(ElementType,
101 EC: ElementCount::getFixed(MinVal: NumElements));
102 return llvm::ArrayType::get(ElementType, NumElements);
103}
104
105llvm::Type *IRTypeMapper::convertVectorType(const abi::VectorType *VT) {
106 if (VT->isSVECount())
107 return llvm::TargetExtType::get(Context, Name: "aarch64.svcount");
108
109 llvm::Type *ElementType = convertType(ABIType: VT->getElementType());
110 return llvm::VectorType::get(ElementType, EC: VT->getNumElements());
111}
112
113llvm::Type *IRTypeMapper::convertTupleType(const abi::TupleType *TT) {
114 llvm::Type *VecTy = convertType(ABIType: TT->getVectorType());
115 SmallVector<llvm::Type *, 4> Elements(TT->getNumVectors(), VecTy);
116 return llvm::StructType::get(Context, Elements);
117}
118
119llvm::Type *IRTypeMapper::convertRecordType(const abi::RecordType *RT) {
120 // A packed record is a sequence of fields with no alignment padding. Pure
121 // scalable aggregates use one as the unpadded coerce-and-expand type, and
122 // its fields may be scalable vectors.
123 if (RT->getPacking() == StructPacking::Packed) {
124 SmallVector<llvm::Type *, 8> FieldTypes;
125 for (const FieldInfo &Field : RT->getFields())
126 FieldTypes.push_back(Elt: convertType(ABIType: Field.FieldType));
127 return llvm::StructType::get(Context, Elements: FieldTypes, /*isPacked=*/true);
128 }
129 return createStructFromFields(Fields: RT->getFields(), Size: RT->getSizeInBits(),
130 Alignment: RT->getAlignment(), IsUnion: RT->isUnion());
131}
132
133llvm::Type *IRTypeMapper::convertComplexType(const abi::ComplexType *CT) {
134 llvm::Type *ElementType = convertType(ABIType: CT->getElementType());
135 llvm::Type *Fields[] = {ElementType, ElementType};
136 return llvm::StructType::get(Context, Elements: Fields, /*isPacked=*/false);
137}
138
139llvm::Type *
140IRTypeMapper::convertMemberPointerType(const abi::MemberPointerType *MPT) {
141 llvm::Type *IntPtrTy = DL.getIntPtrType(C&: Context);
142 if (MPT->isFunctionPointer()) {
143 llvm::Type *Fields[] = {IntPtrTy, IntPtrTy};
144 return llvm::StructType::get(Context, Elements: Fields, /*isPacked=*/false);
145 }
146 return IntPtrTy;
147}
148
149llvm::Type *IRTypeMapper::createPaddingType(uint64_t PaddingBits) {
150 if (PaddingBits == 0)
151 return nullptr;
152 assert(PaddingBits % 8 == 0 &&
153 "sub-byte padding cannot be expressed as an llvm::Type");
154 return llvm::ArrayType::get(ElementType: llvm::IntegerType::get(C&: Context, NumBits: 8),
155 NumElements: PaddingBits / 8);
156}
157
158llvm::StructType *
159IRTypeMapper::createStructFromFields(ArrayRef<abi::FieldInfo> Fields,
160 TypeSize Size, Align Alignment,
161 bool IsUnion) {
162 SmallVector<llvm::Type *, 16> FieldTypes;
163
164 if (IsUnion) {
165 llvm::Type *LargestFieldType = nullptr;
166 uint64_t LargestFieldSize = 0;
167 for (const auto &Field : Fields) {
168 llvm::Type *FieldType = convertType(ABIType: Field.FieldType);
169 uint64_t FieldSize = Field.FieldType->getSizeInBits().getFixedValue();
170 if (FieldSize > LargestFieldSize) {
171 LargestFieldSize = FieldSize;
172 LargestFieldType = FieldType;
173 }
174 }
175 if (LargestFieldType) {
176 FieldTypes.push_back(Elt: LargestFieldType);
177 uint64_t UnionSizeBits = Size.getFixedValue();
178 if (LargestFieldSize < UnionSizeBits) {
179 if (llvm::Type *PaddingType =
180 createPaddingType(PaddingBits: UnionSizeBits - LargestFieldSize))
181 FieldTypes.push_back(Elt: PaddingType);
182 }
183 }
184 } else {
185 uint64_t CurrentOffset = 0;
186 for (const auto &Field : Fields) {
187 assert(!Field.IsBitField && "bitfields should not reach IR type mapping");
188 llvm::Type *FieldType = convertType(ABIType: Field.FieldType);
189 if (Field.OffsetInBits > CurrentOffset) {
190 uint64_t AlignBits = DL.getABITypeAlign(Ty: FieldType).value() * 8;
191 uint64_t NaturalNextOffset =
192 AlignBits ? alignTo(Value: CurrentOffset, Align: AlignBits) : CurrentOffset;
193 if (NaturalNextOffset != Field.OffsetInBits) {
194 if (llvm::Type *PaddingType =
195 createPaddingType(PaddingBits: Field.OffsetInBits - CurrentOffset))
196 FieldTypes.push_back(Elt: PaddingType);
197 }
198 CurrentOffset = Field.OffsetInBits;
199 }
200 FieldTypes.push_back(Elt: FieldType);
201 CurrentOffset += Field.FieldType->getSizeInBits().getFixedValue();
202 }
203 uint64_t TotalSizeBits = Size.getFixedValue();
204 if (CurrentOffset < TotalSizeBits) {
205 if (llvm::Type *PaddingType =
206 createPaddingType(PaddingBits: TotalSizeBits - CurrentOffset))
207 FieldTypes.push_back(Elt: PaddingType);
208 }
209 }
210
211 return StructType::get(Context, Elements: FieldTypes, /*isPacked=*/false);
212}
213