CIRTypes.cpp

Go to the documentation of this file.

//===- CIRTypes.cpp - MLIR CIR 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
//
//===----------------------------------------------------------------------===//
//
// This file defines the types in the CIR dialect.
//
//===----------------------------------------------------------------------===//
 
#include "clang/CIR/Dialect/IR/CIRTypes.h"
 
#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h"
#include "mlir/IR/BuiltinAttributes.h"
#include "mlir/IR/DialectImplementation.h"
#include "mlir/IR/MLIRContext.h"
#include "mlir/Support/LLVM.h"
#include "clang/Basic/AddressSpaces.h"
#include "clang/CIR/Dialect/IR/CIRAttrs.h"
#include "clang/CIR/Dialect/IR/CIRDialect.h"
#include "clang/CIR/Dialect/IR/CIROpsEnums.h"
#include "clang/CIR/Dialect/IR/CIRTypesDetails.h"
#include "clang/CIR/MissingFeatures.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/TypeSwitch.h"
#include "llvm/Support/MathExtras.h"
 
//===----------------------------------------------------------------------===//
// CIR Helpers
//===----------------------------------------------------------------------===//
bool cir::isSized(mlir::Type ty) {
  if (auto sizedTy = mlir::dyn_cast<cir::SizedTypeInterface>(ty))
    return sizedTy.isSized();
  assert(!cir::MissingFeatures::unsizedTypes());
  return false;
}
 
cir::FPTypeInterface cir::getFloatingPointType(const llvm::fltSemantics &sem,
                                               mlir::MLIRContext *ctx) {
  switch (llvm::APFloat::SemanticsToEnum(sem)) {
  case llvm::APFloat::S_IEEEhalf:
    return cir::FP16Type::get(ctx);
  case llvm::APFloat::S_BFloat:
    return cir::BF16Type::get(ctx);
  case llvm::APFloat::S_IEEEsingle:
    return cir::SingleType::get(ctx);
  case llvm::APFloat::S_IEEEdouble:
    return cir::DoubleType::get(ctx);
  case llvm::APFloat::S_x87DoubleExtended:
    return cir::FP80Type::get(ctx);
  case llvm::APFloat::S_IEEEquad:
    return cir::FP128Type::get(ctx);
  default:
    // CIR has no type for the remaining semantics (PPCDoubleDouble, the
    // Float8 formats).  Return null and let the caller report it.
    return {};
  }
}
 
//===----------------------------------------------------------------------===//
// CIR Custom Parser/Printer Signatures
//===----------------------------------------------------------------------===//
 
static mlir::ParseResult
parseFuncTypeParams(mlir::AsmParser &p, llvm::SmallVector<mlir::Type> &params,
                    bool &isVarArg);
static void printFuncTypeParams(mlir::AsmPrinter &p,
                                mlir::ArrayRef<mlir::Type> params,
                                bool isVarArg);
//===----------------------------------------------------------------------===//
// CIR Custom Parser/Printer Signatures
//===----------------------------------------------------------------------===//
 
static mlir::ParseResult
parseFuncTypeParams(mlir::AsmParser &p, llvm::SmallVector<mlir::Type> &params,
                    bool &isVarArg);
 
static void printFuncTypeParams(mlir::AsmPrinter &p,
                                mlir::ArrayRef<mlir::Type> params,
                                bool isVarArg);
 
//===----------------------------------------------------------------------===//
// AddressSpace
//===----------------------------------------------------------------------===//
 
// Spells the address space of `!cir.ptr` and `cir.global` as either
// `lang_address_space(x)` or `target_address_space(n)`.
mlir::ParseResult parseMemorySpace(mlir::AsmParser &p,
                                   mlir::ptr::MemorySpaceAttrInterface &attr);
 
void printMemorySpace(mlir::AsmPrinter &printer,
                      mlir::ptr::MemorySpaceAttrInterface attr);
 
//===----------------------------------------------------------------------===//
// Get autogenerated stuff
//===----------------------------------------------------------------------===//
 
namespace cir {
 
#include "clang/CIR/Dialect/IR/CIRTypeConstraints.cpp.inc"
 
} // namespace cir
 
#define GET_TYPEDEF_CLASSES
#include "clang/CIR/Dialect/IR/CIROpsTypes.cpp.inc"
 
using namespace mlir;
using namespace cir;
 
//===----------------------------------------------------------------------===//
// General CIR parsing / printing
//===----------------------------------------------------------------------===//
 
Type CIRDialect::parseType(DialectAsmParser &parser) const {
  llvm::SMLoc typeLoc = parser.getCurrentLocation();
  llvm::StringRef mnemonic;
  Type genType;
 
  // Try to parse as a tablegen'd type.
  OptionalParseResult parseResult =
      generatedTypeParser(parser, &mnemonic, genType);
  if (parseResult.has_value())
    return genType;
 
  // All CIR types are now tablegen'd; nothing left to dispatch here.
  parser.emitError(typeLoc) << "unknown CIR type: " << mnemonic;
  return Type();
}
 
void CIRDialect::printType(Type type, DialectAsmPrinter &os) const {
  // Try to print as a tablegen'd type.
  if (generatedTypePrinter(type, os).succeeded())
    return;
 
  // TODO(CIR) Attempt to print as a raw C++ type.
  llvm::report_fatal_error("printer is missing a handler for this type");
}
 
//===----------------------------------------------------------------------===//
// StructType
//===----------------------------------------------------------------------===//
 
// Shared helpers for StructType and UnionType parse/print.
 
llvm::SmallVector<RecordMemberKind>
RecordType::getAllDataKinds(llvm::ArrayRef<mlir::Type> members) {
  return llvm::SmallVector<RecordMemberKind>(members.size(),
                                             RecordMemberKind::Data);
}
 
/// An incomplete record has no members, so a kind for one is caught by the
/// same check.
static mlir::LogicalResult
verifyRecordMemberKinds(function_ref<mlir::InFlightDiagnostic()> emitError,
                        size_t numMembers,
                        llvm::ArrayRef<RecordMemberKind> memberKinds) {
  if (memberKinds.size() != numMembers)
    return emitError() << "expected " << numMembers << " member kinds, got "
                       << memberKinds.size();
  return mlir::success();
}
 
/// Members must be CIR types other than void, which has no layout.
static mlir::LogicalResult
verifyRecordMemberTypes(function_ref<mlir::InFlightDiagnostic()> emitError,
                        llvm::ArrayRef<mlir::Type> members) {
  for (auto [idx, memberTy] : llvm::enumerate(members)) {
    if (!cir::isCIRType(memberTy))
      return emitError() << "record member at index " << idx
                         << " must be a CIR type, got " << memberTy;
    if (mlir::isa<cir::VoidType>(memberTy))
      return emitError() << "record member at index " << idx
                         << " cannot be void";
  }
  return mlir::success();
}
 
/// The keywords that spell a member kind.  A union's tail-padding slot probes
/// for one of these to reject it, since that slot is not a member.
static const llvm::StringRef memberKindMarks[] = {"data", "pad", "empty",
                                                  "bitfield"};
 
static std::optional<RecordMemberKind>
parseMemberKind(mlir::AsmParser &parser) {
  llvm::StringRef keyword;
  const llvm::SMLoc loc = parser.getCurrentLocation();
  if (parser.parseKeyword(&keyword).failed())
    return std::nullopt;
  std::optional<RecordMemberKind> kind = symbolizeRecordMemberKind(keyword);
  if (!kind)
    parser.emitError(loc, "expected a record member kind");
  return kind;
}
 
/// Parse "incomplete" or "{mark type, mark type, ...}", writing results into
/// \p incomplete, \p members and \p memberKinds.  Returns failure if member
/// parsing fails.
static mlir::ParseResult
parseRecordBody(mlir::AsmParser &parser, bool &incomplete,
                llvm::SmallVector<mlir::Type> &members,
                llvm::SmallVectorImpl<RecordMemberKind> &memberKinds) {
  assert(incomplete && "caller must pre-initialize incomplete to true");
  if (parser.parseOptionalKeyword("incomplete").succeeded())
    return mlir::success();
  incomplete = false;
  return parser.parseCommaSeparatedList(
      AsmParser::Delimiter::Braces,
      [&parser, &members, &memberKinds]() -> mlir::ParseResult {
        std::optional<RecordMemberKind> kind = parseMemberKind(parser);
        if (!kind)
          return mlir::failure();
        memberKinds.push_back(*kind);
        return parser.parseType(members.emplace_back());
      });
}
 
/// Print a complete CIR record body:
///   '<' ['class '] [name] ['packed '] body '>'
/// where body is "incomplete" or "{[mark] members}[, padding = {type}]".
/// RecordTy must be a mutable MLIR type (StructType or UnionType).
template <typename RecordTy>
static void
printRecordBody(mlir::AsmPrinter &printer, RecordTy self, mlir::StringAttr name,
                bool hasClassPrefix, bool isPacked, bool isIncomplete,
                llvm::ArrayRef<mlir::Type> members, mlir::Type padding,
                llvm::ArrayRef<RecordMemberKind> memberKinds) {
  printer << '<';
  if (hasClassPrefix)
    printer << "class ";
  if (name)
    printer << name;
 
  FailureOr<AsmPrinter::CyclicPrintReset> cyclicPrintGuard =
      printer.tryStartCyclicPrint(self);
  if (failed(cyclicPrintGuard)) {
    printer << '>';
    return;
  }
 
  if (hasClassPrefix || name)
    printer << ' ';
  if (isPacked)
    printer << "packed ";
  if (isIncomplete) {
    printer << "incomplete";
  } else {
    printer << "{";
    for (auto [idx, member] : llvm::enumerate(members)) {
      if (idx)
        printer << ", ";
      printer << stringifyRecordMemberKind(memberKinds[idx]) << ' ';
      printer.printType(member);
    }
    printer << "}";
    if (padding) {
      printer << ", padding = {";
      printer.printType(padding);
      printer << '}';
    }
  }
  printer << '>';
}
 
/// Parse the body of a !cir.struct<...> type.
Type StructType::parse(mlir::AsmParser &parser) {
  FailureOr<AsmParser::CyclicParseReset> cyclicParseGuard;
  const llvm::SMLoc loc = parser.getCurrentLocation();
  const mlir::Location eLoc = parser.getEncodedSourceLoc(loc);
  bool packed = false;
  mlir::MLIRContext *context = parser.getContext();
 
  if (parser.parseLess())
    return {};
 
  // An optional "class" keyword distinguishes class from struct.
  bool is_class = parser.parseOptionalKeyword("class").succeeded();
 
  mlir::StringAttr name;
  parser.parseOptionalAttribute(name);
 
  // Self-reference: ensure the referenced type was already parsed.
  if (name && parser.parseOptionalGreater().succeeded()) {
    StructType type = StructType::getChecked(eLoc, context, name, is_class);
    if (succeeded(parser.tryStartCyclicParse(type))) {
      parser.emitError(loc, "invalid self-reference within record");
      return {};
    }
    return type;
  }
 
  // Named definition: ensure name has not been parsed yet.
  if (name) {
    StructType type = StructType::getChecked(eLoc, context, name, is_class);
    cyclicParseGuard = parser.tryStartCyclicParse(type);
    if (failed(cyclicParseGuard)) {
      parser.emitError(loc, "record already defined");
      return {};
    }
  }
 
  if (parser.parseOptionalKeyword("packed").succeeded())
    packed = true;
 
  bool incomplete = true;
  llvm::SmallVector<mlir::Type> members;
  llvm::SmallVector<RecordMemberKind> memberKinds;
  if (parseRecordBody(parser, incomplete, members, memberKinds).failed())
    return {};
 
  if (parser.parseGreater())
    return {};
 
  ArrayRef<mlir::Type> membersRef(members);
  ArrayRef<RecordMemberKind> kindsRef(memberKinds);
  mlir::Type type = {};
  if (name && incomplete) {
    type = StructType::getChecked(eLoc, context, name, is_class);
  } else if (!name && !incomplete) {
    type = StructType::getChecked(eLoc, context, membersRef, packed, is_class,
                                  kindsRef);
    if (!type)
      return {};
  } else if (!incomplete) {
    type = StructType::getChecked(eLoc, context, membersRef, name, packed,
                                  is_class, kindsRef);
    if (!type)
      return {};
    if (auto structTy = mlir::dyn_cast<StructType>(type)) {
      if (failed(structTy.mutate(membersRef, packed, kindsRef))) {
        parser.emitError(loc, "record '")
            << name.getValue() << "' redefined with a different body";
        return {};
      }
    }
    assert(!cir::MissingFeatures::astRecordDeclAttr());
  } else {
    parser.emitError(loc, "anonymous records must be complete");
    return {};
  }
 
  return type;
}
 
void StructType::print(mlir::AsmPrinter &printer) const {
  printRecordBody(printer, *this, getName(), isClass(), getPacked(),
                  isIncomplete(), getMembers(), /*padding=*/{},
                  getMemberKinds());
}
 
mlir::LogicalResult StructType::verify(
    function_ref<mlir::InFlightDiagnostic()> emitError,
    llvm::ArrayRef<mlir::Type> members, mlir::StringAttr name, bool incomplete,
    bool packed, llvm::ArrayRef<RecordMemberKind> member_kinds, bool is_class) {
  if (name && name.getValue().empty())
    return emitError() << "identified records cannot have an empty name";
  if (failed(verifyRecordMemberTypes(emitError, members)))
    return mlir::failure();
  return verifyRecordMemberKinds(emitError, members.size(), member_kinds);
}
 
// Accessors are hand-written because genStorageClass = 0 suppresses generated
// implementations.
llvm::ArrayRef<mlir::Type> StructType::getMembers() const {
  return getImpl()->members;
}
mlir::StringAttr StructType::getName() const { return getImpl()->name; }
bool StructType::isIncomplete() const { return getImpl()->incomplete; }
bool StructType::getIncomplete() const { return getImpl()->incomplete; }
bool StructType::getPacked() const { return getImpl()->packed; }
llvm::ArrayRef<RecordMemberKind> StructType::getMemberKinds() const {
  return getImpl()->member_kinds;
}
bool StructType::getIsClass() const { return getImpl()->is_class; }
 
bool StructType::getPadded() const {
  return llvm::is_contained(getMemberKinds(), RecordMemberKind::Pad);
}
 
bool StructType::isABIConvertedRecord() const {
  return getName() && getName().getValue().starts_with(abi_conversion_prefix);
}
 
mlir::StringAttr StructType::getABIConvertedName() const {
  assert(!isABIConvertedRecord());
  return StringAttr::get(getContext(),
                         abi_conversion_prefix + getName().getValue());
}
 
void StructType::removeABIConversionNamePrefix() {
  mlir::StringAttr recordName = getName();
  if (recordName && recordName.getValue().starts_with(abi_conversion_prefix))
    getImpl()->name = mlir::StringAttr::get(
        recordName.getValue().drop_front(sizeof(abi_conversion_prefix) - 1),
        recordName.getType());
}
 
void StructType::complete(ArrayRef<Type> members, bool packed,
                          ArrayRef<RecordMemberKind> memberKinds) {
  assert(!cir::MissingFeatures::astRecordDeclAttr());
  // mutate() bypasses the verifier, so check what get() would have checked.
  assert(
      succeeded(verifyInvariants(
          mlir::detail::getDefaultDiagnosticEmitFn(getContext()), members,
          getName(), /*incomplete=*/false, packed, memberKinds, isClass())) &&
      "invalid struct completion");
  if (mutate(members, packed, memberKinds).failed())
    llvm_unreachable("failed to complete struct");
}
 
bool StructType::isLayoutIdentical(const StructType &other) {
  if (getImpl() == other.getImpl())
    return true;
  if (getPacked() != other.getPacked())
    return false;
  return getMembers() == other.getMembers();
}
 
//===----------------------------------------------------------------------===//
// UnionType
//===----------------------------------------------------------------------===//
 
Type UnionType::parse(mlir::AsmParser &parser) {
  FailureOr<AsmParser::CyclicParseReset> cyclicParseGuard;
  const llvm::SMLoc loc = parser.getCurrentLocation();
  const mlir::Location eLoc = parser.getEncodedSourceLoc(loc);
  bool packed = false;
  mlir::Type padding;
  mlir::MLIRContext *context = parser.getContext();
 
  if (parser.parseLess())
    return {};
 
  mlir::StringAttr name;
  parser.parseOptionalAttribute(name);
 
  // Self-reference.
  if (name && parser.parseOptionalGreater().succeeded()) {
    UnionType type = UnionType::getChecked(eLoc, context, name);
    if (succeeded(parser.tryStartCyclicParse(type))) {
      parser.emitError(loc, "invalid self-reference within record");
      return {};
    }
    return type;
  }
 
  // Named definition.
  if (name) {
    UnionType type = UnionType::getChecked(eLoc, context, name);
    cyclicParseGuard = parser.tryStartCyclicParse(type);
    if (failed(cyclicParseGuard)) {
      parser.emitError(loc, "record already defined");
      return {};
    }
  }
 
  if (parser.parseOptionalKeyword("packed").succeeded())
    packed = true;
 
  bool incomplete = true;
  llvm::SmallVector<mlir::Type> members;
  llvm::SmallVector<RecordMemberKind> memberKinds;
  if (parseRecordBody(parser, incomplete, members, memberKinds).failed())
    return {};
 
  // Optional tail-padding slot: ", padding = { <type> }".  It is not a variant
  // and so takes no mark.
  if (!incomplete && parser.parseOptionalComma().succeeded()) {
    if (parser.parseKeyword("padding").failed())
      return {};
    if (parser.parseEqual().failed())
      return {};
    if (parser.parseLBrace().failed())
      return {};
    const llvm::SMLoc paddingLoc = parser.getCurrentLocation();
    llvm::StringRef paddingKeyword;
    if (parser.parseOptionalKeyword(&paddingKeyword, memberKindMarks)
            .succeeded()) {
      parser.emitError(paddingLoc, "a union's tail padding takes no kind mark");
      return {};
    }
    if (parser.parseType(padding).failed())
      return {};
    if (parser.parseRBrace().failed())
      return {};
  }
 
  if (parser.parseGreater())
    return {};
 
  ArrayRef<mlir::Type> membersRef(members);
  ArrayRef<RecordMemberKind> kindsRef(memberKinds);
  mlir::Type type = {};
  if (name && incomplete) {
    type = UnionType::getChecked(eLoc, context, name);
  } else if (!name && !incomplete) {
    type = UnionType::getChecked(eLoc, context, membersRef, packed, padding,
                                 kindsRef);
    if (!type)
      return {};
  } else if (!incomplete) {
    type = UnionType::getChecked(eLoc, context, membersRef, name, packed,
                                 padding, kindsRef);
    if (!type)
      return {};
    if (auto unionTy = mlir::dyn_cast<UnionType>(type)) {
      if (failed(unionTy.mutate(membersRef, packed, padding, kindsRef))) {
        parser.emitError(loc, "record '")
            << name.getValue() << "' redefined with a different body";
        return {};
      }
    }
    assert(!cir::MissingFeatures::astRecordDeclAttr());
  } else {
    parser.emitError(loc, "anonymous records must be complete");
    return {};
  }
 
  return type;
}
 
void UnionType::print(mlir::AsmPrinter &printer) const {
  printRecordBody(printer, *this, getName(), /*hasClassPrefix=*/false,
                  getPacked(), isIncomplete(), getMembers(), getPadding(),
                  getMemberKinds());
}
 
mlir::LogicalResult
UnionType::verify(function_ref<mlir::InFlightDiagnostic()> emitError,
                  llvm::ArrayRef<mlir::Type> members, mlir::StringAttr name,
                  bool incomplete, bool packed, mlir::Type padding,
                  llvm::ArrayRef<RecordMemberKind> member_kinds) {
  if (name && name.getValue().empty())
    return emitError() << "identified records cannot have an empty name";
  // A union's variants all start at offset zero, so there is no inter-member
  // padding for a pad mark to describe.  Its tail padding lives in the separate
  // padding slot.
  if (llvm::is_contained(member_kinds, RecordMemberKind::Pad))
    return emitError() << "a union member cannot be marked pad";
  if (failed(verifyRecordMemberTypes(emitError, members)))
    return mlir::failure();
  // CIRGen pads a union's tail with a char or an array of chars.
  if (padding) {
    mlir::Type charTy = padding;
    if (auto arrTy = mlir::dyn_cast<cir::ArrayType>(padding))
      charTy = arrTy.getElementType();
    auto intTy = mlir::dyn_cast<cir::IntType>(charTy);
    if (!intTy || intTy.getWidth() != 8 || intTy.isSigned() || intTy.isBitInt())
      return emitError()
             << "union padding must be !u8i or an array of !u8i, got "
             << padding;
  }
  // Every variant starts at offset zero, so a bit-field variant is an access
  // unit of its own.  There is no run for a zero-width bit-field to end, so a
  // variant always has storage.
  for (auto [idx, memberTy] : llvm::enumerate(members))
    if (auto bfTy = mlir::dyn_cast<cir::BitFieldType>(memberTy);
        bfTy && !bfTy.ownsBytes())
      return emitError() << "union bit-field member at index " << idx
                         << " must own its access unit storage";
  return verifyRecordMemberKinds(emitError, members.size(), member_kinds);
}
 
// Accessors.
llvm::ArrayRef<mlir::Type> UnionType::getMembers() const {
  return getImpl()->members;
}
mlir::StringAttr UnionType::getName() const { return getImpl()->name; }
bool UnionType::isIncomplete() const { return getImpl()->incomplete; }
bool UnionType::getIncomplete() const { return getImpl()->incomplete; }
bool UnionType::getPacked() const { return getImpl()->packed; }
bool UnionType::getPadded() const { return getPadding() ? true : false; }
mlir::Type UnionType::getPadding() const { return getImpl()->padding; }
llvm::ArrayRef<RecordMemberKind> UnionType::getMemberKinds() const {
  return getImpl()->member_kinds;
}
 
bool UnionType::isABIConvertedRecord() const {
  return getName() && getName().getValue().starts_with(abi_conversion_prefix);
}
 
mlir::StringAttr UnionType::getABIConvertedName() const {
  assert(!isABIConvertedRecord());
  return StringAttr::get(getContext(),
                         abi_conversion_prefix + getName().getValue());
}
 
void UnionType::removeABIConversionNamePrefix() {
  mlir::StringAttr recordName = getName();
  if (recordName && recordName.getValue().starts_with(abi_conversion_prefix))
    getImpl()->name = mlir::StringAttr::get(
        recordName.getValue().drop_front(sizeof(abi_conversion_prefix) - 1),
        recordName.getType());
}
 
void UnionType::complete(ArrayRef<Type> members, bool packed,
                         mlir::Type padding,
                         ArrayRef<RecordMemberKind> memberKinds) {
  assert(!cir::MissingFeatures::astRecordDeclAttr());
  // mutate() bypasses the verifier, so check what get() would have checked.
  assert(succeeded(verifyInvariants(
             mlir::detail::getDefaultDiagnosticEmitFn(getContext()), members,
             getName(), /*incomplete=*/false, packed, padding, memberKinds)) &&
         "invalid union completion");
  if (mutate(members, packed, padding, memberKinds).failed())
    llvm_unreachable("failed to complete union");
}
 
mlir::Type
UnionType::getUnionStorageType(const mlir::DataLayout &dataLayout) const {
  return getUnionStorageType(dataLayout, getMembers());
}
 
mlir::Type UnionType::getUnionStorageType(const mlir::DataLayout &dataLayout,
                                          llvm::ArrayRef<mlir::Type> members) {
  if (members.empty())
    return {};
  mlir::Type largest = *std::max_element(
      members.begin(), members.end(), [&](mlir::Type lhs, mlir::Type rhs) {
        return dataLayout.getTypeABIAlignment(lhs) <
                   dataLayout.getTypeABIAlignment(rhs) ||
               (dataLayout.getTypeABIAlignment(lhs) ==
                    dataLayout.getTypeABIAlignment(rhs) &&
                dataLayout.getTypeAllocSize(lhs) <
                    dataLayout.getTypeAllocSize(rhs));
      });
  // A union's storage is bytes, and stands in for every variant rather than
  // for the one bit-field that happened to be widest, so a bit-field variant
  // contributes its access unit rather than itself.
  return memberStorageType(largest);
}
 
bool UnionType::isLayoutIdentical(const UnionType &other) {
  if (getImpl() == other.getImpl())
    return true;
  return getMembers() == other.getMembers() &&
         getPadding() == other.getPadding();
}
 
//===----------------------------------------------------------------------===//
// RecordType view-class method implementations
//===----------------------------------------------------------------------===//
 
llvm::ArrayRef<mlir::Type> RecordType::getMembers() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.getMembers();
  return mlir::cast<UnionType>(*this).getMembers();
}
mlir::StringAttr RecordType::getName() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.getName();
  return mlir::cast<UnionType>(*this).getName();
}
bool RecordType::isIncomplete() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.isIncomplete();
  return mlir::cast<UnionType>(*this).isIncomplete();
}
bool RecordType::getPacked() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.getPacked();
  return mlir::cast<UnionType>(*this).getPacked();
}
bool RecordType::getPadded() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.getPadded();
  return mlir::cast<UnionType>(*this).getPadded();
}
llvm::ArrayRef<RecordMemberKind> RecordType::getMemberKinds() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.getMemberKinds();
  return mlir::cast<UnionType>(*this).getMemberKinds();
}
bool RecordType::isClass() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.isClass();
  return false;
}
bool RecordType::isStruct() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.isStruct();
  return false;
}
std::string RecordType::getKindAsStr() const {
  if (mlir::isa<UnionType>(*this))
    return "union";
  return mlir::cast<StructType>(*this).getKindAsStr();
}
std::string RecordType::getPrefixedName() const {
  return getKindAsStr() + "." + getName().getValue().str();
}
void RecordType::complete(ArrayRef<Type> members, bool packed,
                          mlir::Type padding,
                          ArrayRef<RecordMemberKind> memberKinds) {
  if (auto s = mlir::dyn_cast<StructType>(*this)) {
    assert(!padding && "only a union takes a separate padding slot");
    return s.complete(members, packed, memberKinds);
  }
  return mlir::cast<UnionType>(*this).complete(members, packed, padding,
                                               memberKinds);
}
uint64_t RecordType::getElementOffset(const mlir::DataLayout &dataLayout,
                                      unsigned idx) const {
  if (mlir::isa<UnionType>(*this))
    return 0;
  return mlir::cast<StructType>(*this).getElementOffset(dataLayout, idx);
}
bool RecordType::isLayoutIdentical(const RecordType &other) {
  if (auto s = mlir::dyn_cast<StructType>(*this)) {
    if (auto so = mlir::dyn_cast<StructType>(other))
      return s.isLayoutIdentical(so);
    return false;
  }
  if (auto u = mlir::dyn_cast<UnionType>(*this)) {
    if (auto uo = mlir::dyn_cast<UnionType>(other))
      return u.isLayoutIdentical(uo);
    return false;
  }
  return false;
}
bool RecordType::isABIConvertedRecord() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.isABIConvertedRecord();
  return mlir::cast<UnionType>(*this).isABIConvertedRecord();
}
mlir::StringAttr RecordType::getABIConvertedName() const {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.getABIConvertedName();
  return mlir::cast<UnionType>(*this).getABIConvertedName();
}
void RecordType::removeABIConversionNamePrefix() {
  if (auto s = mlir::dyn_cast<StructType>(*this))
    return s.removeABIConversionNamePrefix();
  return mlir::cast<UnionType>(*this).removeABIConversionNamePrefix();
}
 
bool RecordType::isEmptyForABI() const {
  // An incomplete record has no members yet, which must not read as vacuously
  // holding no data.
  if (isIncomplete())
    return false;
  if (anyMemberHoldsDataForABI(getMemberKinds()))
    return false;
  // An access unit of nothing but unnamed bit-fields is marked `empty`, since
  // no field of the source reads it, but it is still storage that holds data
  // for the ABI.  This has to answer the way CIRGen's isEmptyFieldForABI does,
  // which is where that rule lives.
  return llvm::none_of(getMembers(), [](mlir::Type memberTy) {
    auto bfTy = mlir::dyn_cast<cir::BitFieldType>(memberTy);
    return bfTy && bfTy.ownsBytes();
  });
}
 
//===----------------------------------------------------------------------===//
// Data Layout information for types
//===----------------------------------------------------------------------===//
 
// The cir.ptr data-layout entry holds a #cir.ptr_spec attribute (see
// cir::setMLIRDataLayout).
namespace {
constexpr static uint64_t kBitsInByte = 8;
 
// Defaults used when the module carries no cir.ptr data-layout entry.
constexpr static uint64_t kDefaultPointerSizeBits = 64;
constexpr static uint64_t kDefaultPointerAlignment = 8;
 
/// Returns the default-address-space #cir.ptr_spec entry, or a synthesized
/// 64-bit default when there is none. Per-AS entries are not modeled yet.
cir::PtrSpecAttr getPointerSpec(mlir::DataLayoutEntryListRef params,
                                cir::PointerType type) {
  // FIXME: improve this in face of address spaces
  assert(!cir::MissingFeatures::dataLayoutPtrHandlingBasedOnLangAS());
  for (mlir::DataLayoutEntryInterface entry : params) {
    if (!entry.isTypeEntry())
      continue;
    auto key =
        mlir::cast<cir::PointerType>(mlir::cast<mlir::Type>(entry.getKey()));
    if (key.getAddrSpace())
      continue;
    if (auto spec = mlir::dyn_cast<cir::PtrSpecAttr>(entry.getValue()))
      return spec;
  }
  return cir::PtrSpecAttr::get(type.getContext(), kDefaultPointerSizeBits,
                               kDefaultPointerAlignment * kBitsInByte,
                               kDefaultPointerAlignment * kBitsInByte,
                               kDefaultPointerSizeBits);
}
} // namespace
 
llvm::TypeSize
PointerType::getTypeSizeInBits(const ::mlir::DataLayout &dataLayout,
                               ::mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(getPointerSpec(params, *this).getSize());
}
 
uint64_t
PointerType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                             ::mlir::DataLayoutEntryListRef params) const {
  return getPointerSpec(params, *this).getAbi() / kBitsInByte;
}
 
uint64_t PointerType::getPreferredAlignment(
    const ::mlir::DataLayout &dataLayout,
    ::mlir::DataLayoutEntryListRef params) const {
  return getPointerSpec(params, *this).getPreferred() / kBitsInByte;
}
 
std::optional<uint64_t>
PointerType::getIndexBitwidth(const ::mlir::DataLayout &dataLayout,
                              ::mlir::DataLayoutEntryListRef params) const {
  cir::PtrSpecAttr spec = getPointerSpec(params, *this);
  if (spec.getIndex() == cir::PtrSpecAttr::kOptionalSpecValue)
    return spec.getSize();
  return spec.getIndex();
}
 
llvm::LogicalResult
PointerType::verifyEntries(mlir::DataLayoutEntryListRef entries,
                           mlir::Location loc) const {
  for (mlir::DataLayoutEntryInterface entry : entries) {
    if (!entry.isTypeEntry())
      continue;
    auto key = mlir::cast<PointerType>(mlir::cast<mlir::Type>(entry.getKey()));
    if (!mlir::isa<cir::PtrSpecAttr>(entry.getValue()))
      return mlir::emitError(loc) << "expected layout attribute for " << key
                                  << " to be a #cir.ptr_spec attribute";
    if (!mlir::isa<cir::VoidType>(key.getPointee()))
      return mlir::emitError(loc) << "expected !cir.ptr data layout entry for "
                                  << key << " to use !cir.void as pointee";
    // Per-address-space pointer layouts are not supported yet.
    if (key.getAddrSpace())
      return mlir::emitError(loc)
             << "!cir.ptr data layout entries are currently limited to the "
                "default address space";
  }
  return mlir::success();
}
 
bool PointerType::areCompatible(
    mlir::DataLayoutEntryListRef oldLayout,
    mlir::DataLayoutEntryListRef newLayout, mlir::DataLayoutSpecInterface,
    const mlir::DataLayoutIdentifiedEntryMap &) const {
  // A nested spec may only override with the same size and a compatible ABI
  // alignment. TODO(cir): match by address space once per-AS specs exist.
  cir::PtrSpecAttr oldSpec = getPointerSpec(oldLayout, *this);
  uint64_t size = oldSpec.getSize();
  uint64_t abi = oldSpec.getAbi();
  for (mlir::DataLayoutEntryInterface newEntry : newLayout) {
    if (!newEntry.isTypeEntry())
      continue;
    auto newSpec = mlir::cast<cir::PtrSpecAttr>(newEntry.getValue());
    if (size != newSpec.getSize() || abi < newSpec.getAbi() ||
        abi % newSpec.getAbi() != 0)
      return false;
  }
  return true;
}
 
llvm::TypeSize
StructType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                              mlir::DataLayoutEntryListRef params) const {
  auto recordSize = static_cast<uint64_t>(computeStructSize(dataLayout));
  return llvm::TypeSize::getFixed(recordSize * 8);
}
 
uint64_t
StructType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                            ::mlir::DataLayoutEntryListRef params) const {
  // Packed structures always have an ABI alignment of 1.
  if (getPacked())
    return 1;
  return computeStructAlignment(dataLayout);
}
 
// Sums the storage member's alloc size (if present) with the padding field's
// size (if present).
// A union whose member list came out empty has no storage type, so its whole
// size lives in the padding, which lowerUnion sizes from the ASTRecordLayout.
llvm::TypeSize
UnionType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                             mlir::DataLayoutEntryListRef params) const {
  llvm::TypeSize size = llvm::TypeSize::getFixed(0);
  if (mlir::Type storage = getUnionStorageType(dataLayout))
    size += dataLayout.getTypeAllocSize(storage) * 8;
  if (mlir::Type pad = getPadding())
    size += dataLayout.getTypeSizeInBits(pad);
  return size;
}
 
uint64_t
UnionType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                           ::mlir::DataLayoutEntryListRef params) const {
  if (getPacked())
    return 1;
  mlir::Type storage = getUnionStorageType(dataLayout);
  if (!storage)
    return 1;
  return dataLayout.getTypeABIAlignment(storage);
}
 
unsigned
StructType::computeStructSize(const mlir::DataLayout &dataLayout) const {
  assert(isComplete() && "Cannot get layout of incomplete records");
 
  // This is a similar algorithm to LLVM's StructLayout.  A member that owns no
  // bytes needs no special case: it reports size 0 and alignment 1, so the
  // running size passes over it unchanged.
  unsigned recordSize = 0;
  uint64_t recordAlignment = 1;
 
  for (mlir::Type ty : getMembers()) {
    // This assumes that we're calculating size based on the ABI alignment, not
    // the preferred alignment for each type.
    const uint64_t tyAlign =
        (getPacked() ? 1 : dataLayout.getTypeABIAlignment(ty));
 
    // Add padding to the struct size to align it to the abi alignment of the
    // element type before adding the element's alloc size.
    recordSize = llvm::alignTo(recordSize, tyAlign);
    recordSize += dataLayout.getTypeAllocSize(ty);
 
    // The alignment requirement of a struct is equal to the strictest
    // alignment requirement of its elements.
    recordAlignment = std::max(tyAlign, recordAlignment);
  }
 
  // At the end, add padding to the struct to satisfy its own alignment
  // requirement. Otherwise structs inside of arrays would be misaligned.
  recordSize = llvm::alignTo(recordSize, recordAlignment);
  return recordSize;
}
 
unsigned
StructType::computeStructDataSize(const mlir::DataLayout &dataLayout) const {
  assert(isComplete() && "Cannot get layout of incomplete records");
 
  // Tail padding is the trailing run of pad members, which is what a derived
  // class may reuse.  A member that owns no bytes holds no storage, so it does
  // not end that run.  A member of any other kind stays inside the data size.
  llvm::ArrayRef<mlir::Type> members = getMembers();
  llvm::ArrayRef<RecordMemberKind> kinds = getMemberKinds();
  assert(kinds.size() == members.size() &&
         "the two drop_back calls below must stay in step");
  while (!kinds.empty() && (kinds.back() == RecordMemberKind::Pad ||
                            !memberOwnsBytes(members.back()))) {
    kinds = kinds.drop_back();
    members = members.drop_back();
  }
 
  unsigned recordSize = 0;
  for (mlir::Type ty : members) {
    const uint64_t tyAlign =
        (getPacked() ? 1 : dataLayout.getTypeABIAlignment(ty));
    recordSize = llvm::alignTo(recordSize, tyAlign);
    recordSize += dataLayout.getTypeAllocSize(ty);
  }
  return recordSize;
}
 
// We also compute the alignment as part of computeStructSize, but this is more
// efficient. Ideally, we'd like to compute both at once and cache the result,
// but that's not implemented yet.
// TODO(CIR): Implement a way to cache the result.
uint64_t
StructType::computeStructAlignment(const mlir::DataLayout &dataLayout) const {
  assert(isComplete() && "Cannot get layout of incomplete records");
 
  uint64_t recordAlignment = 1;
  for (mlir::Type ty : getMembers())
    recordAlignment =
        std::max(dataLayout.getTypeABIAlignment(ty), recordAlignment);
  return recordAlignment;
}
 
unsigned StructType::getLLVMFieldIndex(unsigned idx) const {
  llvm::ArrayRef<mlir::Type> members = getMembers();
  assert(idx < members.size() && "access not valid");
  assert(memberOwnsBytes(members[idx]) &&
         "a member that owns no bytes has no LLVM field");
 
  unsigned llvmIdx = 0;
  for (unsigned i = 0; i != idx; ++i)
    if (memberOwnsBytes(members[i]))
      ++llvmIdx;
  return llvmIdx;
}
 
uint64_t StructType::getElementOffset(const ::mlir::DataLayout &dataLayout,
                                      unsigned idx) const {
  assert(idx < getMembers().size() && "access not valid");
  if (idx == 0)
    return 0;
 
  assert(isComplete() && "Cannot get layout of incomplete records");
  llvm::ArrayRef<mlir::Type> members = getMembers();
 
  // A zero-width bit-field reports alignment 1 and size 0, so the running
  // offset passes over it unchanged and lands on where the storage ahead of it
  // ends, which is the offset it was declared at.
  unsigned offset = 0;
  for (unsigned i = 0; i != idx; ++i) {
    const llvm::Align tyAlign = llvm::Align(
        getPacked() ? 1 : dataLayout.getTypeABIAlignment(members[i]));
    offset = llvm::alignTo(offset, tyAlign);
    offset += dataLayout.getTypeAllocSize(members[i]);
  }
 
  const llvm::Align tyAlign = llvm::Align(
      getPacked() ? 1 : dataLayout.getTypeABIAlignment(members[idx]));
  return llvm::alignTo(offset, tyAlign);
}
 
//===----------------------------------------------------------------------===//
// IntType Definitions
//===----------------------------------------------------------------------===//
 
Type IntType::parse(mlir::AsmParser &parser) {
  mlir::MLIRContext *context = parser.getBuilder().getContext();
  llvm::SMLoc loc = parser.getCurrentLocation();
  bool isSigned;
  unsigned width;
 
  if (parser.parseLess())
    return {};
 
  // Fetch integer sign.
  llvm::StringRef sign;
  if (parser.parseKeyword(&sign))
    return {};
  if (sign == "s")
    isSigned = true;
  else if (sign == "u")
    isSigned = false;
  else {
    parser.emitError(loc, "expected 's' or 'u'");
    return {};
  }
 
  if (parser.parseComma())
    return {};
 
  // Fetch integer size.
  if (parser.parseInteger(width))
    return {};
  if (width < IntType::minBitwidth() || width > IntType::maxBitwidth()) {
    parser.emitError(loc, "expected integer width to be from ")
        << IntType::minBitwidth() << " up to " << IntType::maxBitwidth();
    return {};
  }
 
  bool isBitInt = false;
  if (succeeded(parser.parseOptionalComma())) {
    llvm::StringRef kw;
    if (parser.parseKeyword(&kw) || kw != "bitint") {
      parser.emitError(loc, "expected 'bitint'");
      return {};
    }
    isBitInt = true;
  }
 
  if (parser.parseGreater())
    return {};
 
  return IntType::get(context, width, isSigned, isBitInt);
}
 
void IntType::print(mlir::AsmPrinter &printer) const {
  char sign = isSigned() ? 's' : 'u';
  printer << '<' << sign << ", " << getWidth();
  if (isBitInt())
    printer << ", bitint";
  printer << '>';
}
 
llvm::TypeSize
IntType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                           mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(getStorageTypeWidth(dataLayout));
}
 
unsigned
IntType::getStorageTypeWidth(const mlir::DataLayout &dataLayout) const {
  if (!isBitInt())
    return getWidth();
  uint64_t alignBits = getABIAlignment(dataLayout, {}) * 8;
  return static_cast<unsigned>(llvm::alignTo(getWidth(), alignBits));
}
 
uint64_t
IntType::getStorageTypeAlignment(const mlir::DataLayout &dataLayout) const {
  if (!isBitInt())
    return getABIAlignment(dataLayout, {});
  auto storageTy =
      mlir::IntegerType::get(getContext(), getStorageTypeWidth(dataLayout));
  return dataLayout.getTypeABIAlignment(storageTy);
}
 
uint64_t IntType::getABIAlignment(const mlir::DataLayout &dataLayout,
                                  mlir::DataLayoutEntryListRef params) const {
  unsigned width = getWidth();
  if (isBitInt()) {
    // _BitInt alignment: min(PowerOf2Ceil(width), 64 bits) in bytes.
    // Matches Clang's TargetInfo::getBitIntAlign with default max = 64.
    uint64_t alignBits =
        std::min(llvm::PowerOf2Ceil(width), static_cast<uint64_t>(64));
    return std::max(alignBits / 8, static_cast<uint64_t>(1));
  }
  // Round up to a power-of-two byte alignment.  DataLayout consumers such as
  // llvm::Align require power-of-two alignments, and width / 8 is not a power
  // of two for non-fundamental widths (e.g. i24 -> 3).  This leaves the
  // fundamental widths unchanged (i8 -> 1, i16 -> 2, i32 -> 4, i64 -> 8) and
  // keeps __int128 at 16.
  uint64_t alignBits = llvm::PowerOf2Ceil(width);
  return std::max(alignBits / 8, static_cast<uint64_t>(1));
}
 
mlir::LogicalResult
IntType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
                unsigned width, bool isSigned, bool isBitInt) {
  if (width < IntType::minBitwidth() || width > IntType::maxBitwidth())
    return emitError() << "IntType only supports widths from "
                       << IntType::minBitwidth() << " up to "
                       << IntType::maxBitwidth();
  return mlir::success();
}
 
bool cir::isValidFundamentalIntWidth(unsigned width) {
  return width == 8 || width == 16 || width == 32 || width == 64;
}
 
//===----------------------------------------------------------------------===//
// Floating-point type definitions
//===----------------------------------------------------------------------===//
 
const llvm::fltSemantics &SingleType::getFloatSemantics() const {
  return llvm::APFloat::IEEEsingle();
}
 
llvm::TypeSize
SingleType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                              mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(getWidth());
}
 
uint64_t
SingleType::getABIAlignment(const mlir::DataLayout &dataLayout,
                            mlir::DataLayoutEntryListRef params) const {
  return (uint64_t)(getWidth() / 8);
}
 
const llvm::fltSemantics &DoubleType::getFloatSemantics() const {
  return llvm::APFloat::IEEEdouble();
}
 
llvm::TypeSize
DoubleType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                              mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(getWidth());
}
 
uint64_t
DoubleType::getABIAlignment(const mlir::DataLayout &dataLayout,
                            mlir::DataLayoutEntryListRef params) const {
  return (uint64_t)(getWidth() / 8);
}
 
const llvm::fltSemantics &FP16Type::getFloatSemantics() const {
  return llvm::APFloat::IEEEhalf();
}
 
llvm::TypeSize
FP16Type::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                            mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(getWidth());
}
 
uint64_t FP16Type::getABIAlignment(const mlir::DataLayout &dataLayout,
                                   mlir::DataLayoutEntryListRef params) const {
  return (uint64_t)(getWidth() / 8);
}
 
const llvm::fltSemantics &BF16Type::getFloatSemantics() const {
  return llvm::APFloat::BFloat();
}
 
llvm::TypeSize
BF16Type::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                            mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(getWidth());
}
 
uint64_t BF16Type::getABIAlignment(const mlir::DataLayout &dataLayout,
                                   mlir::DataLayoutEntryListRef params) const {
  return (uint64_t)(getWidth() / 8);
}
 
const llvm::fltSemantics &FP80Type::getFloatSemantics() const {
  return llvm::APFloat::x87DoubleExtended();
}
 
llvm::TypeSize
FP80Type::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                            mlir::DataLayoutEntryListRef params) const {
  // Though only 80 bits are used for the value, the type is 128 bits in size.
  return llvm::TypeSize::getFixed(128);
}
 
uint64_t FP80Type::getABIAlignment(const mlir::DataLayout &dataLayout,
                                   mlir::DataLayoutEntryListRef params) const {
  return 16;
}
 
const llvm::fltSemantics &FP128Type::getFloatSemantics() const {
  return llvm::APFloat::IEEEquad();
}
 
llvm::TypeSize
FP128Type::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                             mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(getWidth());
}
 
uint64_t FP128Type::getABIAlignment(const mlir::DataLayout &dataLayout,
                                    mlir::DataLayoutEntryListRef params) const {
  return 16;
}
 
const llvm::fltSemantics &LongDoubleType::getFloatSemantics() const {
  return mlir::cast<cir::FPTypeInterface>(getUnderlying()).getFloatSemantics();
}
 
llvm::TypeSize
LongDoubleType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                                  mlir::DataLayoutEntryListRef params) const {
  return mlir::cast<mlir::DataLayoutTypeInterface>(getUnderlying())
      .getTypeSizeInBits(dataLayout, params);
}
 
uint64_t
LongDoubleType::getABIAlignment(const mlir::DataLayout &dataLayout,
                                mlir::DataLayoutEntryListRef params) const {
  return mlir::cast<mlir::DataLayoutTypeInterface>(getUnderlying())
      .getABIAlignment(dataLayout, params);
}
 
//===----------------------------------------------------------------------===//
// ComplexType Definitions
//===----------------------------------------------------------------------===//
 
llvm::TypeSize
cir::ComplexType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                                    mlir::DataLayoutEntryListRef params) const {
  // C17 6.2.5p13:
  //   Each complex type has the same representation and alignment requirements
  //   as an array type containing exactly two elements of the corresponding
  //   real type.
 
  return dataLayout.getTypeSizeInBits(getElementType()) * 2;
}
 
uint64_t
cir::ComplexType::getABIAlignment(const mlir::DataLayout &dataLayout,
                                  mlir::DataLayoutEntryListRef params) const {
  // C17 6.2.5p13:
  //   Each complex type has the same representation and alignment requirements
  //   as an array type containing exactly two elements of the corresponding
  //   real type.
 
  return dataLayout.getTypeABIAlignment(getElementType());
}
 
FuncType FuncType::clone(TypeRange inputs, TypeRange results) const {
  assert(results.size() == 1 && "expected exactly one result type");
  return get(llvm::to_vector(inputs), results[0], isVarArg());
}
 
// Custom parser that parses function parameters of form `(<type>*, ...)`.
static mlir::ParseResult
parseFuncTypeParams(mlir::AsmParser &p, llvm::SmallVector<mlir::Type> &params,
                    bool &isVarArg) {
  isVarArg = false;
  return p.parseCommaSeparatedList(
      AsmParser::Delimiter::Paren, [&]() -> mlir::ParseResult {
        if (isVarArg)
          return p.emitError(p.getCurrentLocation(),
                             "variadic `...` must be the last parameter");
        if (succeeded(p.parseOptionalEllipsis())) {
          isVarArg = true;
          return success();
        }
        mlir::Type type;
        if (failed(p.parseType(type)))
          return failure();
        params.push_back(type);
        return success();
      });
}
 
static void printFuncTypeParams(mlir::AsmPrinter &p,
                                mlir::ArrayRef<mlir::Type> params,
                                bool isVarArg) {
  p << '(';
  llvm::interleaveComma(params, p,
                        [&p](mlir::Type type) { p.printType(type); });
  if (isVarArg) {
    if (!params.empty())
      p << ", ";
    p << "...";
  }
  p << ')';
}
 
/// Get the C-style return type of the function, which is !cir.void if the
/// function returns nothing and the actual return type otherwise.
mlir::Type FuncType::getReturnType() const {
  if (hasVoidReturn())
    return cir::VoidType::get(getContext());
  return getOptionalReturnType();
}
 
/// Get the MLIR-style return type of the function, which is an empty
/// ArrayRef if the function returns nothing and a single-element ArrayRef
/// with the actual return type otherwise.
llvm::ArrayRef<mlir::Type> FuncType::getReturnTypes() const {
  if (hasVoidReturn())
    return {};
  // Can't use getOptionalReturnType() here because llvm::ArrayRef hold a
  // pointer to its elements and doesn't do lifetime extension.  That would
  // result in returning a pointer to a temporary that has gone out of scope.
  return getImpl()->optionalReturnType;
}
 
// Does the fuction type return nothing?
bool FuncType::hasVoidReturn() const { return !getOptionalReturnType(); }
 
mlir::LogicalResult
FuncType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
                 llvm::ArrayRef<mlir::Type> argTypes, mlir::Type returnType,
                 bool isVarArg) {
  if (mlir::isa_and_nonnull<cir::VoidType>(returnType))
    return emitError()
           << "!cir.func cannot have an explicit 'void' return type";
 
  // The calling convention lowering pass expects all types in a function
  // signature to be CIR types. CIR types only nest CIR types, so checking the
  // signature's own types covers everything reachable from them.
  if (!llvm::all_of(argTypes, cir::isCIRType) ||
      (returnType && !cir::isCIRType(returnType)))
    return emitError()
           << "expected all types in the function signature to be CIR types";
 
  return mlir::success();
}
 
//===----------------------------------------------------------------------===//
// MethodType Definitions
//===----------------------------------------------------------------------===//
 
static mlir::Type getMethodLayoutType(mlir::MLIRContext *ctx) {
  // With Itanium ABI, member function pointers have the same layout as the
  // following struct: struct { fnptr_t, ptrdiff_t }, where fnptr_t is a
  // function pointer type.
  // TODO: consider member function pointer layout in other ABIs
  auto voidPtrTy = cir::PointerType::get(cir::VoidType::get(ctx));
  mlir::Type fields[2]{voidPtrTy, voidPtrTy};
  return cir::StructType::get(ctx, fields, /*packed=*/false,
                              /*is_class=*/false,
                              cir::RecordType::getAllDataKinds(fields));
}
 
llvm::TypeSize
MethodType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                              mlir::DataLayoutEntryListRef params) const {
  return dataLayout.getTypeSizeInBits(getMethodLayoutType(getContext()));
}
 
uint64_t
MethodType::getABIAlignment(const mlir::DataLayout &dataLayout,
                            mlir::DataLayoutEntryListRef params) const {
  return cast<cir::StructType>(getMethodLayoutType(getContext()))
      .getABIAlignment(dataLayout, params);
}
 
//===----------------------------------------------------------------------===//
// BoolType
//===----------------------------------------------------------------------===//
 
llvm::TypeSize
BoolType::getTypeSizeInBits(const ::mlir::DataLayout &dataLayout,
                            ::mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(8);
}
 
uint64_t
BoolType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                          ::mlir::DataLayoutEntryListRef params) const {
  return 1;
}
 
//===----------------------------------------------------------------------===//
//  DataMemberType Definitions
//===----------------------------------------------------------------------===//
 
static mlir::Type getDataMemberLayoutType(const mlir::DataLayout &dataLayout,
                                          mlir::MLIRContext *ctx) {
  // Itanium ABI: a data member pointer is a ptrdiff_t, an integer of the
  // pointer index width.
  // TODO: consider data member pointer layout in other ABIs
  auto voidPtrTy = cir::PointerType::get(cir::VoidType::get(ctx));
  uint64_t width = dataLayout.getTypeIndexBitwidth(voidPtrTy).value_or(
      dataLayout.getTypeSizeInBits(voidPtrTy).getFixedValue());
  return cir::IntType::get(ctx, width, /*is_signed=*/true);
}
 
llvm::TypeSize
DataMemberType::getTypeSizeInBits(const ::mlir::DataLayout &dataLayout,
                                  ::mlir::DataLayoutEntryListRef params) const {
  assert(!MissingFeatures::cxxABI());
  return dataLayout.getTypeSizeInBits(
      getDataMemberLayoutType(dataLayout, getContext()));
}
 
uint64_t
DataMemberType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                                ::mlir::DataLayoutEntryListRef params) const {
  assert(!MissingFeatures::cxxABI());
  return dataLayout.getTypeABIAlignment(
      getDataMemberLayoutType(dataLayout, getContext()));
}
 
//===----------------------------------------------------------------------===//
//  VPtrType Definitions
//===----------------------------------------------------------------------===//
 
llvm::TypeSize
VPtrType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                            mlir::DataLayoutEntryListRef params) const {
  // A vtable pointer is an ordinary data pointer; size it as a cir.ptr.
  return dataLayout.getTypeSizeInBits(
      cir::PointerType::get(cir::VoidType::get(getContext())));
}
 
uint64_t VPtrType::getABIAlignment(const mlir::DataLayout &dataLayout,
                                   mlir::DataLayoutEntryListRef params) const {
  return dataLayout.getTypeABIAlignment(
      cir::PointerType::get(cir::VoidType::get(getContext())));
}
 
//===----------------------------------------------------------------------===//
//  ArrayType Definitions
//===----------------------------------------------------------------------===//
 
llvm::TypeSize
ArrayType::getTypeSizeInBits(const ::mlir::DataLayout &dataLayout,
                             ::mlir::DataLayoutEntryListRef params) const {
  return getSize() * dataLayout.getTypeAllocSize(getElementType()) * 8;
}
 
uint64_t
ArrayType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                           ::mlir::DataLayoutEntryListRef params) const {
  return dataLayout.getTypeABIAlignment(getElementType());
}
 
//===----------------------------------------------------------------------===//
//  BitFieldType Definitions
//===----------------------------------------------------------------------===//
 
mlir::LogicalResult
BitFieldType::verify(llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
                     mlir::Type storageType,
                     llvm::ArrayRef<cir::BitFieldDeclAttr> fields) {
  if (fields.empty())
    return emitError() << "bit-field member must hold at least one bit-field";
 
  if (!storageType) {
    // Absent storage is the zero-width bit-field, which belongs to no access
    // unit and so keeps company with nothing.
    if (fields.size() != 1 || fields.front().getWidth() != 0)
      return emitError() << "a bit-field member without storage must hold a "
                            "single zero-width bit-field";
    return mlir::success();
  }
 
  if (!cir::isCIRType(storageType))
    return emitError() << "bit-field access unit storage must be a CIR type, "
                          "got "
                       << storageType;
 
  if (mlir::isa<cir::BitFieldType>(storageType))
    return emitError() << "bit-field access unit storage cannot itself be a "
                          "bit-field type";
 
  if (!cir::isSized(storageType))
    return emitError() << "bit-field access unit storage must be sized, got "
                       << storageType;
 
  // A zero-width bit-field ends the run before it rather than joining a unit,
  // so it never appears alongside the fields that occupy one.
  if (llvm::any_of(fields, [](cir::BitFieldDeclAttr decl) {
        return decl.getWidth() == 0;
      }))
    return emitError() << "a zero-width bit-field cannot occupy an access unit";
 
  return mlir::success();
}
 
llvm::TypeSize
BitFieldType::getTypeSizeInBits(const mlir::DataLayout &dataLayout,
                                mlir::DataLayoutEntryListRef params) const {
  // A unit is stored as its storage type.  A zero-width bit-field has none,
  // and holds no bits of its own.
  if (mlir::Type storage = getStorageType())
    return dataLayout.getTypeSizeInBits(storage);
  return llvm::TypeSize::getFixed(0);
}
 
uint64_t
BitFieldType::getABIAlignment(const mlir::DataLayout &dataLayout,
                              mlir::DataLayoutEntryListRef params) const {
  // A member that occupies no bytes imposes no alignment, which is what lets
  // the record layout walk a zero-width bit-field without skipping it.
  if (mlir::Type storage = getStorageType())
    return dataLayout.getTypeABIAlignment(storage);
  return 1;
}
 
//===----------------------------------------------------------------------===//
// VectorType Definitions
//===----------------------------------------------------------------------===//
 
llvm::TypeSize cir::VectorType::getTypeSizeInBits(
    const ::mlir::DataLayout &dataLayout,
    ::mlir::DataLayoutEntryListRef params) const {
  // Clang packs a fixed-length bool vector one bit per element and rounds the
  // vector's size up to a power of two of at least a byte.
  if (mlir::isa<cir::BoolType>(getElementType()) && getSize().isFixed()) {
    assert(!cir::MissingFeatures::hlsl());
    return llvm::TypeSize::getFixed(llvm::PowerOf2Ceil(getBoolStorageWidth()));
  }
 
  llvm::TypeSize elementSize = dataLayout.getTypeSizeInBits(getElementType());
  return llvm::TypeSize::get(
      getSize().getKnownMinValue() * elementSize.getFixedValue(), isScalable());
}
 
uint64_t cir::VectorType::getBoolStorageWidth() const {
  assert(mlir::isa<cir::BoolType>(getElementType()) &&
         "only a bool vector is stored as an integer");
  return std::max<uint64_t>(getFixedSize(), 8);
}
 
uint64_t
cir::VectorType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                                 ::mlir::DataLayoutEntryListRef params) const {
  // This hook answers in bytes, not bits.
  return llvm::PowerOf2Ceil(llvm::divideCeil(
      dataLayout.getTypeSizeInBits(*this).getKnownMinValue(), uint64_t{8}));
}
 
mlir::LogicalResult cir::VectorType::verify(
    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
    mlir::Type elementType, llvm::ElementCount size) {
  if (size.isZero())
    return emitError() << "the number of vector elements must be non-zero";
  return success();
}
 
mlir::Type cir::VectorType::parse(::mlir::AsmParser &odsParser) {
 
  llvm::SMLoc odsLoc = odsParser.getCurrentLocation();
  mlir::Builder odsBuilder(odsParser.getContext());
  mlir::FailureOr<::mlir::Type> elementType;
  mlir::FailureOr<uint64_t> size;
  bool isScalable = false;
 
  // Parse literal '<'
  if (odsParser.parseLess())
    return {};
 
  // Parse literal '[', if present, and set the scalability flag accordingly
  if (odsParser.parseOptionalLSquare().succeeded())
    isScalable = true;
 
  // Parse variable 'size'
  size = mlir::FieldParser<uint64_t>::parse(odsParser);
  if (mlir::failed(size)) {
    odsParser.emitError(odsParser.getCurrentLocation(),
                        "failed to parse CIR_VectorType parameter 'size' which "
                        "is to be a `uint64_t`");
    return {};
  }
 
  // Parse literal ']', which is expected when dealing with scalable
  // dim sizes
  if (isScalable && odsParser.parseRSquare().failed()) {
    odsParser.emitError(odsParser.getCurrentLocation(),
                        "missing closing `]` for scalable dim size");
    return {};
  }
 
  // Parse literal 'x'
  if (odsParser.parseKeyword("x"))
    return {};
 
  // Parse variable 'elementType'
  elementType = mlir::FieldParser<::mlir::Type>::parse(odsParser);
  if (mlir::failed(elementType)) {
    odsParser.emitError(odsParser.getCurrentLocation(),
                        "failed to parse CIR_VectorType parameter "
                        "'elementType' which is to be a `mlir::Type`");
    return {};
  }
 
  // Parse literal '>'
  if (odsParser.parseGreater())
    return {};
  return odsParser.getChecked<VectorType>(
      odsLoc, odsParser.getContext(), mlir::Type((*elementType)),
      llvm::ElementCount::get(*size, isScalable));
}
 
void cir::VectorType::print(mlir::AsmPrinter &odsPrinter) const {
  mlir::Builder odsBuilder(getContext());
  odsPrinter << "<";
  if (isScalable())
    odsPrinter << "[";
 
  odsPrinter.printStrippedAttrOrType(getSize().getKnownMinValue());
  if (isScalable())
    odsPrinter << "]";
  odsPrinter << ' ' << "x";
  odsPrinter << ' ';
  odsPrinter.printStrippedAttrOrType(getElementType());
  odsPrinter << ">";
}
 
//===----------------------------------------------------------------------===//
// MatrixType Definitions
//===----------------------------------------------------------------------===//
 
llvm::TypeSize cir::MatrixType::getTypeSizeInBits(
    const ::mlir::DataLayout &dataLayout,
    ::mlir::DataLayoutEntryListRef params) const {
  return llvm::TypeSize::getFixed(
      getNumRows() * getNumColumns() *
      dataLayout.getTypeSizeInBits(getElementType()));
}
 
uint64_t
cir::MatrixType::getABIAlignment(const ::mlir::DataLayout &dataLayout,
                                 ::mlir::DataLayoutEntryListRef params) const {
  return dataLayout.getTypeABIAlignment(getElementType());
}
 
mlir::LogicalResult cir::MatrixType::verify(
    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
    mlir::Type elementType, uint64_t row, uint64_t column) {
  if (row == 0)
    return emitError() << "the number of matrix rows must be non-zero";
  if (column == 0)
    return emitError() << "the number of matrix columns must be non-zero";
  return success();
}
 
//===----------------------------------------------------------------------===//
// AddressSpace definitions
//===----------------------------------------------------------------------===//
 
bool cir::isSupportedCIRMemorySpaceAttr(
    mlir::ptr::MemorySpaceAttrInterface memorySpace) {
  return mlir::isa<cir::LangAddressSpaceAttr, cir::TargetAddressSpaceAttr>(
      memorySpace);
}
 
cir::LangAddressSpace cir::toCIRLangAddressSpace(clang::LangAS langAS) {
  using clang::LangAS;
  switch (langAS) {
  case LangAS::Default:
    return LangAddressSpace::Default;
  case LangAS::opencl_global:
  case LangAS::sycl_global:
    return LangAddressSpace::OffloadGlobal;
  case LangAS::opencl_local:
  case LangAS::cuda_shared:
  case LangAS::sycl_local:
    // Local means local among the work-group (OpenCL, SYCL) or block (CUDA).
    // All threads inside the kernel can access local memory.
    return LangAddressSpace::OffloadLocal;
  case LangAS::cuda_device:
    return LangAddressSpace::OffloadGlobal;
  case LangAS::opencl_constant:
  case LangAS::cuda_constant:
  case LangAS::sycl_constant:
    return LangAddressSpace::OffloadConstant;
  case LangAS::opencl_private:
  case LangAS::sycl_private:
    return LangAddressSpace::OffloadPrivate;
  case LangAS::opencl_generic:
  case LangAS::sycl_generic:
    return LangAddressSpace::OffloadGeneric;
  case LangAS::opencl_global_device:
  case LangAS::sycl_global_device:
    return LangAddressSpace::OffloadGlobalDevice;
  case LangAS::opencl_global_host:
  case LangAS::sycl_global_host:
    return LangAddressSpace::OffloadGlobalHost;
  case LangAS::ptr32_sptr:
  case LangAS::ptr32_uptr:
  case LangAS::ptr64:
  case LangAS::hlsl_groupshared:
  case LangAS::wasm_funcref:
    llvm_unreachable("NYI");
  default:
    llvm_unreachable("unknown/unsupported clang language address space");
  }
}
 
mlir::ParseResult parseMemorySpace(mlir::AsmParser &p,
                                   mlir::ptr::MemorySpaceAttrInterface &attr) {
 
  llvm::SMLoc loc = p.getCurrentLocation();
 
  // Try to parse target address space first.
  attr = nullptr;
  if (p.parseOptionalKeyword("target_address_space").succeeded()) {
    unsigned val;
    if (p.parseLParen())
      return p.emitError(loc, "expected '(' after 'target_address_space'");
 
    if (p.parseInteger(val))
      return p.emitError(loc, "expected target address space value");
 
    if (p.parseRParen())
      return p.emitError(loc, "expected ')'");
 
    attr = cir::TargetAddressSpaceAttr::get(p.getContext(), val);
    return mlir::success();
  }
 
  // Try to parse language specific address space.
  if (p.parseOptionalKeyword("lang_address_space").succeeded()) {
    if (p.parseLParen())
      return p.emitError(loc, "expected '(' after 'lang_address_space'");
 
    mlir::FailureOr<cir::LangAddressSpace> result =
        mlir::FieldParser<cir::LangAddressSpace>::parse(p);
    if (mlir::failed(result))
      return mlir::failure();
 
    if (p.parseRParen())
      return p.emitError(loc, "expected ')'");
 
    attr = cir::LangAddressSpaceAttr::get(p.getContext(), result.value());
    return mlir::success();
  }
 
  llvm::StringRef keyword;
  if (p.parseOptionalKeyword(&keyword).succeeded())
    return p.emitError(loc, "unknown address space specifier '")
           << keyword << "'; expected 'target_address_space' or "
           << "'lang_address_space'";
 
  return mlir::success();
}
 
void printMemorySpace(mlir::AsmPrinter &p,
                      mlir::ptr::MemorySpaceAttrInterface attr) {
  if (!attr)
    return;
 
  if (auto language = dyn_cast<cir::LangAddressSpaceAttr>(attr)) {
    p << "lang_address_space("
      << cir::stringifyLangAddressSpace(language.getValue()) << ')';
    return;
  }
 
  if (auto target = dyn_cast<cir::TargetAddressSpaceAttr>(attr)) {
    p << "target_address_space(" << target.getValue() << ')';
    return;
  }
 
  llvm_unreachable("unexpected address-space attribute kind");
}
 
mlir::OptionalParseResult
parseGlobalMemorySpace(mlir::AsmParser &p,
                       mlir::ptr::MemorySpaceAttrInterface &attr) {
 
  mlir::SMLoc loc = p.getCurrentLocation();
  if (parseMemorySpace(p, attr).failed())
    return p.emitError(loc, "failed to parse Address Space Value for GlobalOp");
  return mlir::success();
}
 
void printGlobalMemorySpace(mlir::AsmPrinter &printer, cir::GlobalOp,
                            mlir::ptr::MemorySpaceAttrInterface attr) {
  printMemorySpace(printer, attr);
}
 
mlir::ptr::MemorySpaceAttrInterface cir::normalizeDefaultAddressSpace(
    mlir::ptr::MemorySpaceAttrInterface addrSpace) {
  if (auto langAS =
          mlir::dyn_cast_if_present<cir::LangAddressSpaceAttr>(addrSpace))
    if (langAS.getValue() == cir::LangAddressSpace::Default)
      return {};
  return addrSpace;
}
 
mlir::ptr::MemorySpaceAttrInterface
cir::toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS) {
  using clang::LangAS;
 
  if (langAS == LangAS::Default)
    return cir::LangAddressSpaceAttr::get(&ctx, cir::LangAddressSpace::Default);
 
  if (clang::isTargetAddressSpace(langAS)) {
    unsigned targetAS = clang::toTargetAddressSpace(langAS);
    return cir::TargetAddressSpaceAttr::get(&ctx, targetAS);
  }
 
  return cir::LangAddressSpaceAttr::get(&ctx, toCIRLangAddressSpace(langAS));
}
 
bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS,
                                 clang::LangAS as) {
  cirAS = normalizeDefaultAddressSpace(cirAS);
  if (!cirAS)
    return as == clang::LangAS::Default;
  mlir::ptr::MemorySpaceAttrInterface expected = normalizeDefaultAddressSpace(
      toCIRAddressSpaceAttr(*cirAS.getContext(), as));
  return expected == cirAS;
}
 
//===----------------------------------------------------------------------===//
// PointerType Definitions
//===----------------------------------------------------------------------===//
 
mlir::LogicalResult cir::PointerType::verify(
    llvm::function_ref<mlir::InFlightDiagnostic()> emitError,
    mlir::Type pointee, mlir::ptr::MemorySpaceAttrInterface addrSpace) {
  if (addrSpace) {
    if (!isSupportedCIRMemorySpaceAttr(addrSpace)) {
      return emitError() << "unsupported address space attribute; expected "
                            "'target_address_space' or 'lang_address_space'";
    }
  }
 
  return success();
}
 
//===----------------------------------------------------------------------===//
// CIR Dialect
//===----------------------------------------------------------------------===//
 
void CIRDialect::registerTypes() {
  // Register tablegen'd types.
  addTypes<
#define GET_TYPEDEF_LIST
#include "clang/CIR/Dialect/IR/CIROpsTypes.cpp.inc"
      >();
 
  // Register raw C++ types.
  // TODO(CIR) addTypes<RecordType>();
}