blob: cfe5d9d95217b5ec1a2328932465c3746c5d0ab4 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
|
//===--- CodeGenFunction.cpp - Emit LLVM Code from ASTs for a Function ----===//
//
// 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 coordinates the per-function state used while generating code.
//
//===----------------------------------------------------------------------===//
#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();
}
|
