[clang] [llvm] [WIP] ABI Lowering Library (PR #140112)

[Nikita Popov via llvm-commits]

================
@@ -0,0 +1,556 @@
+//==---- QualTypeMapper.cpp - Maps Clang QualType to LLVMABI Types ---------==//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Maps Clang QualType instances to corresponding LLVM ABI type
+/// representations. This mapper translates high-level type information from the
+/// AST into low-level ABI-specific types that encode size, alignment, and
+/// layout details required for code generation and cross-language
+/// interoperability.
+///
+//===----------------------------------------------------------------------===//
+#include "clang/CodeGen/QualTypeMapper.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/ASTFwd.h"
+#include "clang/AST/Attr.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/RecordLayout.h"
+#include "clang/AST/Type.h"
+#include "clang/Basic/AddressSpaces.h"
+#include "clang/Basic/LLVM.h"
+#include "clang/Basic/TargetInfo.h"
+#include "llvm/ABI/Types.h"
+#include "llvm/Support/Alignment.h"
+#include "llvm/Support/TypeSize.h"
+
+namespace clang {
+namespace CodeGen {
+
+/// Main entry point for converting Clang QualType to LLVM ABI Type.
+/// This method performs type canonicalization, caching, and dispatches
+/// to specialized conversion methods based on the type kind.
+///
+/// \param QT The Clang QualType to convert
+/// \return Corresponding LLVM ABI Type representation, or nullptr on error
+const llvm::abi::Type *QualTypeMapper::convertType(QualType QT) {
+  // Canonicalize type and strip qualifiers
+  // This ensures consistent type representation across different contexts
+  QT = QT.getCanonicalType().getUnqualifiedType();
+
+  // Results are cached since type conversion may be expensive
+  auto It = TypeCache.find(QT);
+  if (It != TypeCache.end())
+    return It->second;
+
+  const llvm::abi::Type *Result = nullptr;
+  if (const auto *BT = dyn_cast<BuiltinType>(QT.getTypePtr()))
+    Result = convertBuiltinType(BT);
+  else if (const auto *PT = dyn_cast<PointerType>(QT.getTypePtr()))
+    Result = convertPointerType(PT);
+  else if (const auto *RT = dyn_cast<ReferenceType>(QT.getTypePtr()))
+    Result = convertReferenceType(RT);
+  else if (const auto *AT = dyn_cast<ArrayType>(QT.getTypePtr()))
+    Result = convertArrayType(AT);
+  else if (const auto *VT = dyn_cast<VectorType>(QT.getTypePtr()))
+    Result = convertVectorType(VT);
+  else if (const auto *RT = dyn_cast<RecordType>(QT.getTypePtr()))
+    Result = convertRecordType(RT);
+  else if (const auto *ET = dyn_cast<EnumType>(QT.getTypePtr()))
+    Result = convertEnumType(ET);
+  else if (const auto *CT = dyn_cast<ComplexType>(QT.getTypePtr()))
+    Result = convertComplexType(CT);
+  else if (const auto *AT = dyn_cast<AtomicType>(QT.getTypePtr()))
+    return convertType(AT->getValueType());
+  else if (isa<BlockPointerType>(QT.getTypePtr()))
+    return createPointerTypeForPointee(ASTCtx.VoidPtrTy);
+  else if (isa<PipeType>(QT.getTypePtr()))
+    Result = createPointerTypeForPointee(ASTCtx.VoidPtrTy);
+  else if (const auto *MT = dyn_cast<ConstantMatrixType>(QT.getTypePtr())) {
+    const llvm::abi::Type *ElementType = convertType(MT->getElementType());
+    uint64_t NumElements = MT->getNumRows() * MT->getNumColumns();
+    return Builder.getArrayType(ElementType, NumElements, true);
+  } else if (const auto *MPT = dyn_cast<MemberPointerType>(QT.getTypePtr()))
+    Result = convertMemberPointerType(MPT);
+  else if (const auto *BIT = dyn_cast<BitIntType>(QT.getTypePtr())) {
+    unsigned RawNumBits = BIT->getNumBits();
+    bool IsPromotableInt = BIT->getNumBits() < ASTCtx.getTypeSize(ASTCtx.IntTy);
+    bool IsSigned = BIT->isSigned();
+    llvm::Align TypeAlign = getTypeAlign(QT);
+    return Builder.getIntegerType(RawNumBits, TypeAlign, IsSigned, false, true,
+                                  IsPromotableInt);
+  } else if (isa<ObjCObjectType>(QT.getTypePtr()) ||
+             isa<ObjCObjectPointerType>(QT.getTypePtr())) {
+    // Objective-C objects are represented as pointers in the ABI
+    auto PointerSize =
+        ASTCtx.getTargetInfo().getPointerWidth(QT.getAddressSpace());
+    llvm::Align PointerAlign =
+        llvm::Align(ASTCtx.getTargetInfo().getPointerAlign(LangAS::Default));
+    return Builder.getPointerType(
+        PointerSize, llvm::Align(PointerAlign.value() / 8),
+        ASTCtx.getTargetInfo().getTargetAddressSpace(QT.getAddressSpace()));
+  } else
+    QT.dump();
----------------
nikic wrote:

Should also emit an error here (e.g. with llvm_unreachable).

https://github.com/llvm/llvm-project/pull/140112