maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Split type analysis out to its own file, now the integer constant expr evaluation 

is ready.

llvm-svn: 39660
This commit is contained in:
Chris Lattner 2007-06-16 00:12:05 +00:00
parent 23b7eb677d
commit 2052bc8107
5 changed files with 194 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
clang/CodeGen/CodeGenFunction.cpp
View File

@ -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) {

13
clang/CodeGen/CodeGenFunction.h
View File

@ -16,20 +16,16 @@
#include "llvm/ADT/DenseMap.h"
#include "llvm/Support/LLVMBuilder.h"
#include <vector>
#include "CodeGenTypes.h"
namespace llvm {
class Module;
}
namespace clang {
class SourceLocation;
class TargetInfo;
class ASTContext;
class Decl;
class FunctionDecl;
class QualType;
class FunctionTypeProto;
class Stmt;
class CompoundStmt;
@ -125,6 +121,7 @@ class CodeGenFunction {
CodeGenModule &CGM; // Per-module state.
TargetInfo &Target;
llvm::LLVMBuilder Builder;
CodeGenTypes Types;
const FunctionDecl *CurFuncDecl;
llvm::Function *CurFn;
@ -147,13 +144,9 @@ public:
ASTContext &getContext() const;
const llvm::Type *ConvertType(QualType T, SourceLocation Loc);
void DecodeArgumentTypes(const FunctionTypeProto &FTP,
std::vector<const llvm::Type*> &ArgTys,
SourceLocation Loc);
void GenerateCode(const FunctionDecl *FD);
const llvm::Type *ConvertType(QualType T, SourceLocation Loc);
/// getBasicBlockForLabel - Return the LLVM basicblock that the specified
/// label maps to.

4
clang/CodeGen/CodeGenModule.h
View File

@ -16,11 +16,13 @@
namespace llvm {
class Module;
class Constant;
}
namespace clang {
class ASTContext;
class FunctionDecl;
class Decl;
namespace CodeGen {
@ -29,6 +31,8 @@ namespace CodeGen {
class CodeGenModule {
ASTContext &Context;
llvm::Module &TheModule;
//llvm::DenseMap<const Decl*, llvm::Constant*> GlobalDeclMap;
public:
CodeGenModule(ASTContext &C, llvm::Module &M) : Context(C), TheModule(M) {}

136
clang/CodeGen/CodeGenTypes.cpp Normal file
View File

@ -0,0 +1,136 @@
//===--- CodeGenTypes.cpp - Type translation for LLVM CodeGen -------------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Chris Lattner and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This is the code that handles AST -> LLVM type lowering.
//
//===----------------------------------------------------------------------===//
#include "CodeGenTypes.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/AST/AST.h"
#include "llvm/DerivedTypes.h"
using namespace clang;
using namespace CodeGen;
/// ConvertType - Convert the specified type to its LLVM form.
const llvm::Type *CodeGenTypes::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!");
llvm::APSInt Size(32);
if (A.getSize()->isIntegerConstantExpr(Size)) {
const llvm::Type *EltTy = ConvertType(A.getElementType(), Loc);
return llvm::ArrayType::get(EltTy, Size.getZExtValue());
} else {
assert(0 && "FIXME: VLAs not implemented yet!");
}
}
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 CodeGenTypes::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));
}
}

49
clang/CodeGen/CodeGenTypes.h Normal file
View File

@ -0,0 +1,49 @@
//===--- CodeGenTypes.h - Type translation for LLVM CodeGen -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Chris Lattner and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This is the code that handles AST -> LLVM type lowering.
//
//===----------------------------------------------------------------------===//
#ifndef CODEGEN_CODEGENTYPES_H
#define CODEGEN_CODEGENTYPES_H
#include <vector>
namespace llvm {
class Type;
}
namespace clang {
class TargetInfo;
class QualType;
class SourceLocation;
class FunctionTypeProto;
namespace CodeGen {
/// CodeGenTypes - This class organizes the cross-module state that is used
/// while lowering AST types to LLVM types.
class CodeGenTypes {
TargetInfo &Target;
public:
CodeGenTypes(TargetInfo &target) : Target(target) {}
TargetInfo &getTarget() const { return Target; }
const llvm::Type *ConvertType(QualType T, SourceLocation Loc);
void DecodeArgumentTypes(const FunctionTypeProto &FTP,
std::vector<const llvm::Type*> &ArgTys,
SourceLocation Loc);
};
} // end namespace CodeGen
} // end namespace clang
#endif