From 2052bc810726672c19b3f59b91479efd61f9e67f Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Sat, 16 Jun 2007 00:12:05 +0000
Subject: Split type analysis out to its own file, now the integer constant
 expr evaluation is ready.

llvm-svn: 39660
---
 clang/CodeGen/CodeGenFunction.cpp | 113 +-------------------------------------
 1 file changed, 2 insertions(+), 111 deletions(-)

(limited to 'clang/CodeGen/CodeGenFunction.cpp')

diff --git a/clang/CodeGen/CodeGenFunction.cpp b/clang/CodeGen/CodeGenFunction.cpp
index 87900096df4..4dece886bec 100644
--- a/clang/CodeGen/CodeGenFunction.cpp
+++ b/clang/CodeGen/CodeGenFunction.cpp
@@ -23,7 +23,7 @@ using namespace clang;
 using namespace CodeGen;
 
 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm) 
-  : CGM(cgm), Target(CGM.getContext().Target) {}
+  : CGM(cgm), Target(CGM.getContext().Target), Types(Target) {}
 
 ASTContext &CodeGenFunction::getContext() const {
   return CGM.getContext();
@@ -39,117 +39,8 @@ llvm::BasicBlock *CodeGenFunction::getBasicBlockForLabel(const LabelStmt *S) {
 }
 
 
-/// 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_S:
-    case BuiltinType::Char_U:
-    case BuiltinType::SChar:
-    case BuiltinType::UChar:
-      return llvm::IntegerType::get(Target.getCharWidth(Loc));
-
-    case BuiltinType::Bool:
-      // FIXME: This is very strange.  We want scalars to be i1, but in memory
-      // they can be i1 or i32.  Should the codegen handle this issue?
-      return llvm::Type::Int1Ty;
-      
-    case BuiltinType::Short:
-    case BuiltinType::UShort:
-      return llvm::IntegerType::get(Target.getShortWidth(Loc));
-      
-    case BuiltinType::Int:
-    case BuiltinType::UInt:
-      return llvm::IntegerType::get(Target.getIntWidth(Loc));
-
-    case BuiltinType::Long:
-    case BuiltinType::ULong:
-      return llvm::IntegerType::get(Target.getLongWidth(Loc));
-
-    case BuiltinType::LongLong:
-    case BuiltinType::ULongLong:
-      return llvm::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: {
-    const PointerType &P = cast<PointerType>(Ty);
-    return llvm::PointerType::get(ConvertType(P.getPointeeType(), Loc));
-  }
-  case Type::Reference: {
-    const ReferenceType &R = cast<ReferenceType>(Ty);
-    return llvm::PointerType::get(ConvertType(R.getReferenceeType(), Loc));
-  }
-    
-  case Type::Array: {
-    const ArrayType &A = cast<ArrayType>(Ty);
-    assert(A.getSizeModifier() == ArrayType::Normal &&
-           A.getIndexTypeQualifier() == 0 &&
-           "FIXME: We only handle trivial array types so far!");
-    // FIXME: are there any promotions etc here?
-    RValue Size = EmitExpr(A.getSize());
-    assert(Size.isScalar() && isa<llvm::ConstantInt>(Size.getVal()) &&
-           "FIXME: Only handle fixed-size arrays so far");
-    const llvm::Type *EltTy = ConvertType(A.getElementType(), Loc);
-    return llvm::ArrayType::get(EltTy, 
-                      cast<llvm::ConstantInt>(Size.getVal())->getZExtValue());
-  }
-  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.
-    bool isVarArg;
-    std::vector<const llvm::Type*> ArgTys;
-    if (const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(&FP)) {
-      DecodeArgumentTypes(*FTP, ArgTys, Loc);
-      isVarArg = FTP->isVariadic();
-    } else {
-      isVarArg = true;
-    }
-    
-    return llvm::FunctionType::get(ResultType, ArgTys, isVarArg, 0);
-  }
-  case Type::TypeName:
-  case Type::Tagged:
-    break;
-  }
-  
-  // FIXME: implement.
-  return llvm::OpaqueType::get();
-}
-
-void CodeGenFunction::DecodeArgumentTypes(const FunctionTypeProto &FTP, 
-                                          std::vector<const llvm::Type*> &
-                                          ArgTys, SourceLocation Loc) {
-  for (unsigned i = 0, e = FTP.getNumArgs(); i != e; ++i) {
-    const llvm::Type *Ty = ConvertType(FTP.getArgType(i), Loc);
-    if (Ty->isFirstClassType())
-      ArgTys.push_back(Ty);
-    else
-      ArgTys.push_back(llvm::PointerType::get(Ty));
-  }
+  return Types.ConvertType(T, Loc);
 }
 
 void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
-- 
cgit v1.2.3