Expose the Clang::QualType to llvm::Type conversion functions

[Praetonus]

Summary

This change exposes the various CodeGenTypes::ConvertType functions in the public Clang API. This allows external tools using the Clang API to rely on it to generate LLVM types from C types. The precise use case that motivated this change is explained in an email to the Clang mailing list.

[rjmccall]

Exposing these operations seems fine, but I'm not thrilled about the APIs. Of course, the APIs are exactly derived from IRGen's internal APIs, but we'd like to eventually clean those APIs up, and we certainly don't need to emulate them.

include/clang/CodeGen/CodeGenABITypes.h

74

Is this one actually important to expose? What sorts of future APIs are you expecting where clients will interact with IRGen other than in memory?

If we do need this, we should name it something clear so that people don't accidentally reach for it by default. (This has actually been a pain point within IRGen for years.) How about:

llvm;:Type *convertTypeForRValue(CodeGenModule &CGM, QualType type);

78

Let's make this a specific API for getting the type of a function declaration.

llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM, const FunctionDecl *FD);

80

llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType type);

[Praetonus]

Patch updated based on @rjmccall's comments. I removed the wrapper for the ConvertType function, after giving it some thoughts I don't see any use case for it, I guess I added it by default. I left the convertFreeFunction function as returning an llvm::Type instead of an llvm::FunctionType as ConvertFunctionType represents incomplete function types as empty aggregate types.

[rjmccall]

Hmm. Maybe it would make more sense to allow it to return null, and then add a comment explaining that it will do so if it can't lower the function type yet.

[Praetonus]

Patch updated. I've made the convertFreeFunctionType return null on failure.

[rjmccall]

Looks great, thanks!

[majnemer]

lib/CodeGen/CodeGenABITypes.cpp

71

Pointers lean right.

73

need a space between the if and the parenthesis.

[Praetonus]

Patch updated to adhere to the coding style based on @majnemer's comments.

[rjmccall]

Still looks good to me. Do you need help committing?

[Praetonus]

I forgot to mention that I don't have commit access. If you or somebody else could commit this it would be great.

[rjmccall]

Committed.

include/clang/CodeGen/CodeGenABITypes.h

 
 #include "clang/AST/CanonicalType.h"
 #include "clang/AST/Type.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 
 namespace llvm {
   class DataLayout;
   class Module;
+  class Type;
 }
 
 namespace clang {
 class ASTContext;
 class CXXRecordDecl;
 class CXXMethodDecl;
 class CodeGenOptions;
 class CoverageSourceInfo;
const CGFunctionInfo &arrangeCXXMethodType(CodeGenModule &CGM,
                                            const CXXMethodDecl *MD);
 
 const CGFunctionInfo &arrangeFreeFunctionCall(CodeGenModule &CGM,
                                               CanQualType returnType,
                                               ArrayRef<CanQualType> argTypes,
                                               FunctionType::ExtInfo info,
                                               RequiredArgs args);
 
+// Returns null if the function type is incomplete and can't be lowered.
+llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM,
+                                            const FunctionDecl *FD);
+
+llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T);
+
 }  // end namespace CodeGen
 }  // end namespace clang
 
 #endif

lib/CodeGen/CodeGenABITypes.cpp

CodeGen::arrangeFreeFunctionCall(CodeGenModule &CGM,
                                  CanQualType returnType,
                                  ArrayRef<CanQualType> argTypes,
                                  FunctionType::ExtInfo info,
                                  RequiredArgs args) {
   return CGM.getTypes().arrangeLLVMFunctionInfo(
       returnType, /*IsInstanceMethod=*/false, /*IsChainCall=*/false, argTypes,
       info, {}, args);
 }
+
+llvm::FunctionType *
+CodeGen::convertFreeFunctionType(CodeGenModule &CGM, const FunctionDecl *FD) {
+  assert(FD != nullptr && "Expected a non-null function declaration!");
+  llvm::Type *T = CGM.getTypes().ConvertFunctionType(FD->getType(), FD);
+
+  if (auto FT = dyn_cast<llvm::FunctionType>(T))
+    return FT;
+
+  return nullptr;
+}
+
+llvm::Type *
+CodeGen::convertTypeForMemory(CodeGenModule &CGM, QualType T) {
+  return CGM.getTypes().ConvertTypeForMem(T);
+}