Implement conversion of clang ast types to LLVM types, at least for some trivial

cases.

llvm-svn: 39519

clang/CodeGen/CodeGenFunction.cpp

@@ -13,8 +13,97 @@
 
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/AST/AST.h"
+#include "llvm/DerivedTypes.h"
 #include "llvm/Support/LLVMBuilder.h"
 using namespace llvm;
 using namespace clang;
 using namespace CodeGen;
 
+CodeGenFunction::CodeGenFunction(CodeGenModule &cgm) 
+  : CGM(cgm), Target(CGM.getContext().Target) {}
+
+
+/// ConvertType - Convert the specified type to its LLVM form.
+const llvm::Type *CodeGenFunction::ConvertType(QualType T, SourceLocation Loc) {
+  // FIXME: Cache these, move the CodeGenModule, expand, etc.
+  const clang::Type &Ty = *T.getCanonicalType();
+  
+  switch (Ty.getTypeClass()) {
+  case Type::Builtin: {
+    switch (cast<BuiltinType>(Ty).getKind()) {
+    case BuiltinType::Void:
+      // LLVM void type can only be used as the result of a function call.  Just
+      // map to the same as char.
+    case BuiltinType::Char:
+    case BuiltinType::SChar:
+    case BuiltinType::UChar:
+      return IntegerType::get(Target.getCharWidth(Loc));
+
+    case BuiltinType::Bool:
+      return IntegerType::get(Target.getBoolWidth(Loc));
+      
+    case BuiltinType::Short:
+    case BuiltinType::UShort:
+      return IntegerType::get(Target.getShortWidth(Loc));
+      
+    case BuiltinType::Int:
+    case BuiltinType::UInt:
+      return IntegerType::get(Target.getIntWidth(Loc));
+
+    case BuiltinType::Long:
+    case BuiltinType::ULong:
+      return IntegerType::get(Target.getLongWidth(Loc));
+
+    case BuiltinType::LongLong:
+    case BuiltinType::ULongLong:
+      return IntegerType::get(Target.getLongLongWidth(Loc));
+      
+    case BuiltinType::Float:      return llvm::Type::FloatTy;
+    case BuiltinType::Double:     return llvm::Type::DoubleTy;
+    case BuiltinType::LongDouble:
+    case BuiltinType::FloatComplex:
+    case BuiltinType::DoubleComplex:
+    case BuiltinType::LongDoubleComplex:
+      ;
+    }
+    break;
+  }
+  case Type::Pointer:
+  case Type::Reference:
+  case Type::Array:
+    break;
+  case Type::FunctionNoProto:
+  case Type::FunctionProto: {
+    const FunctionType &FP = cast<FunctionType>(Ty);
+    const llvm::Type *ResultType;
+    
+    if (FP.getResultType()->isVoidType())
+      ResultType = llvm::Type::VoidTy;    // Result of function uses llvm void.
+    else
+      ResultType = ConvertType(FP.getResultType(), Loc);
+    
+    // FIXME: Convert argument types.
+    
+    return llvm::FunctionType::get(ResultType,
+                                   std::vector<const llvm::Type*>(),
+                                   false,
+                                   0);
+  }
+  case Type::TypeName:
+  case Type::Tagged:
+    break;
+  }
+  
+  // FIXME: implement.
+  return OpaqueType::get();
+}
+
+
+void CodeGenFunction::GenerateCode(FunctionDecl *FD) {
+  const llvm::Type *Ty = ConvertType(FD->getType(), FD->getLocation());
+  
+  Ty->dump();
+  
+}

clang/CodeGen/CodeGenFunction.h

@@ -16,9 +16,13 @@
 
 namespace llvm {
   class Module;
+  class Type;
 namespace clang {
   class ASTContext;
   class FunctionDecl;
+  class QualType;
+  class SourceLocation;
+  class TargetInfo;
   
 namespace CodeGen {
   class CodeGenModule;
@@ -27,9 +31,13 @@ namespace CodeGen {
 /// while generating LLVM code.
 class CodeGenFunction {
   CodeGenModule &CGM;  // Per-module state.
+  TargetInfo &Target;
 public:
-  CodeGenFunction(CodeGenModule &cgm) : CGM(cgm) {}
+  CodeGenFunction(CodeGenModule &cgm);
   
+  const llvm::Type *ConvertType(QualType T, SourceLocation Loc);
+  
+  void GenerateCode(FunctionDecl *FD);
 };
 }  // end namespace CodeGen
 }  // end namespace clang

clang/CodeGen/CodeGenModule.cpp

@@ -19,6 +19,5 @@ using namespace CodeGen;
 
 
 void CodeGenModule::EmitFunction(FunctionDecl *FD) {
-  CodeGenFunction CGF(*this);
-  
+  CodeGenFunction(*this).GenerateCode(FD);
 }

clang/CodeGen/CodeGenModule.h

@@ -30,6 +30,8 @@ class CodeGenModule {
 public:
   CodeGenModule(ASTContext &C, Module &M) : Context(C), TheModule(M) {}
   
+  ASTContext &getContext() const { return Context; }
+  
   void EmitFunction(FunctionDecl *FD);
   
   void PrintStats() {}

clang/clang.xcodeproj/project.pbxproj

@@ -103,23 +103,6 @@
 		DED7D9E50A5257F6003AD0FB /* ScratchBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = DED7D9E40A5257F6003AD0FB /* ScratchBuffer.cpp */; };
 /* End PBXBuildFile section */
 
-/* Begin PBXBuildStyle section */
-		84FADE170C0B37FF00330902 /* Development */ = {
-			isa = PBXBuildStyle;
-			buildSettings = {
-				COPY_PHASE_STRIP = NO;
-			};
-			name = Development;
-		};
-		84FADE180C0B37FF00330902 /* Deployment */ = {
-			isa = PBXBuildStyle;
-			buildSettings = {
-				COPY_PHASE_STRIP = YES;
-			};
-			name = Deployment;
-		};
-/* End PBXBuildStyle section */
-
 /* Begin PBXCopyFilesBuildPhase section */
 		8DD76F690486A84900D96B5E /* CopyFiles */ = {
 			isa = PBXCopyFilesBuildPhase;
@@ -555,12 +538,6 @@
 		08FB7793FE84155DC02AAC07 /* Project object */ = {
 			isa = PBXProject;
 			buildConfigurationList = 1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "clang" */;
-			buildSettings = {
-			};
-			buildStyles = (
-				84FADE170C0B37FF00330902 /* Development */,
-				84FADE180C0B37FF00330902 /* Deployment */,
-			);
 			hasScannedForEncodings = 1;
 			mainGroup = 08FB7794FE84155DC02AAC07 /* clang */;
 			projectDirPath = "";