[CIR] Support converting fns in CIRGenTypes::ConvertType

This patch adds a few functions to support converting AST types to MLIR
types for functions

Author: lanza

clang/lib/CIR/CIRGenTypes.cpp

@@ -106,6 +106,78 @@ mlir::MLIRContext &CIRGenTypes::getMLIRContext() const {
   return *Builder.getContext();
 }
 
+mlir::Type CIRGenTypes::ConvertFunctionTypeInternal(QualType QFT) {
+  assert(QFT.isCanonical());
+  const Type *Ty = QFT.getTypePtr();
+  const FunctionType *FT = cast<FunctionType>(QFT.getTypePtr());
+  // First, check whether we can build the full fucntion type. If the function
+  // type depends on an incomplete type (e.g. a struct or enum), we cannot lower
+  // the function type.
+  assert(isFuncTypeConvertible(FT) && "NYI");
+
+  // While we're converting the parameter types for a function, we don't want to
+  // recursively convert any pointed-to structs. Converting directly-used
+  // structs is ok though.
+  assert(RecordsBeingLaidOut.insert(Ty).second && "NYI");
+
+  // The function type can be built; call the appropriate routines to build it
+  const CIRGenFunctionInfo *FI;
+  const auto *FPT = dyn_cast<FunctionProtoType>(FT);
+  assert(FPT && "FunctionNonPrototype NIY");
+  FI = &arrangeFreeFunctionType(
+      CanQual<FunctionProtoType>::CreateUnsafe(QualType(FPT, 0)));
+
+  mlir::Type ResultType = nullptr;
+  // If there is something higher level prodding our CIRGenFunctionInfo, then
+  // don't recurse into it again.
+  assert(!FunctionsBeingProcessed.count(FI) && "NYI");
+
+  // Otherwise, we're good to go, go ahead and convert it.
+  ResultType = GetFunctionType(*FI);
+
+  RecordsBeingLaidOut.erase(Ty);
+
+  assert(!SkippedLayout && "Shouldn't have skipped anything yet");
+
+  assert(RecordsBeingLaidOut.empty() && "Deferral NYI");
+  assert(DeferredRecords.empty() && "Deferral NYI");
+
+  return ResultType;
+}
+
+/// isFuncParamTypeConvertible - Return true if the specified type in a function
+/// parameter or result position can be converted to a CIR type at this point.
+/// This boils down to being whether it is complete, as well as whether we've
+/// temporarily deferred expanding the type because we're in a recursive
+/// context.
+bool CIRGenTypes::isFuncParamTypeConvertible(clang::QualType Ty) {
+  // Some ABIs cannot have their member pointers represented in LLVM IR unless
+  // certain circumstances have been reached.
+  assert(!Ty->getAs<MemberPointerType>() && "NYI");
+
+  // If this isn't a tagged type, we can convert it!
+  auto *TT = Ty->getAs<TagType>();
+  assert(!TT && "Only non-TagTypes implemented atm.");
+  return true;
+}
+
+/// Code to verify a given function type is complete, i.e. the return type and
+/// all of the parameter types are complete. Also check to see if we are in a
+/// RS_StructPointer context, and if so whether any struct types have been
+/// pended. If so, we don't want to ask the ABI lowering code to handle a type
+/// that cannot be converted to a CIR type.
+bool CIRGenTypes::isFuncTypeConvertible(const FunctionType *FT) {
+  if (!isFuncParamTypeConvertible(FT->getReturnType()))
+    return false;
+
+  if (const auto *FPT = dyn_cast<FunctionProtoType>(FT))
+    for (unsigned i = 0, e = FPT->getNumParams(); i != e; i++)
+      if (!isFuncParamTypeConvertible(FPT->getParamType(i)))
+        return false;
+
+  return true;
+}
+
 /// ConvertType - Convert the specified type to its MLIR form.
 mlir::Type CIRGenTypes::ConvertType(QualType T) {
   T = Context.getCanonicalType(T);
@@ -376,7 +448,7 @@ mlir::Type CIRGenTypes::ConvertType(QualType T) {
   }
   case Type::FunctionNoProto:
   case Type::FunctionProto:
-    assert(0 && "not implemented");
+    ResultType = ConvertFunctionTypeInternal(T);
     break;
   case Type::ObjCObject:
     assert(0 && "not implemented");

clang/lib/CIR/CIRGenTypes.h

@@ -89,12 +89,32 @@ class CIRGenTypes {
   /// Hold memoized CIRGenFunctionInfo results
   llvm::FoldingSet<CIRGenFunctionInfo> FunctionInfos;
 
+  /// This set keeps track of records that we're currently converting to a CIR
+  /// type. For example, when converting:
+  /// struct A { struct B { int x; } } when processing 'x', the 'A' and 'B'
+  /// types will be in this set.
+  llvm::SmallPtrSet<const clang::Type *, 4> RecordsBeingLaidOut;
+
   llvm::SmallPtrSet<const CIRGenFunctionInfo *, 4> FunctionsBeingProcessed;
 
+  /// True if we didn't layout a function due to being inside a recursive struct
+  /// conversion, set this to true.
+  bool SkippedLayout;
+
+  llvm::SmallVector<const clang::RecordDecl *, 8> DeferredRecords;
+
+  /// Heper for ConvertType.
+  mlir::Type ConvertFunctionTypeInternal(clang::QualType FT);
+
 public:
   CIRGenTypes(CIRGenModule &cgm);
   ~CIRGenTypes();
 
+  /// isFuncTypeConvertible - Utility to check whether a function type can be
+  /// converted to a CIR type (i.e. doesn't depend on an incomplete tag type).
+  bool isFuncTypeConvertible(const clang::FunctionType *FT);
+  bool isFuncParamTypeConvertible(clang::QualType Ty);
+
   /// Convert clang calling convention to LLVM calling convention.
   unsigned ClangCallConvToCIRCallConv(clang::CallingConv CC);