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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
//===--- CodeGenTypes.h - Type translation for LLVM CodeGen -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file 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 "llvm/ADT/DenseMap.h"
#include <vector>
namespace llvm {
class Module;
class Type;
class PATypeHolder;
class TargetData;
}
namespace clang {
class ASTContext;
class TagDecl;
class TargetInfo;
class QualType;
class Type;
class FunctionTypeProto;
class FieldDecl;
class RecordDecl;
namespace CodeGen {
class CodeGenTypes;
/// CGRecordLayout - This class handles struct and union layout info while
/// lowering AST types to LLVM types.
class CGRecordLayout {
CGRecordLayout(); // DO NOT IMPLEMENT
public:
CGRecordLayout(llvm::Type *T) : STy(T) {
// FIXME : Collect info about fields that requires adjustments
// (i.e. fields that do not directly map to llvm struct fields.)
}
/// getLLVMType - Return llvm type associated with this record.
llvm::Type *getLLVMType() const {
return STy;
}
private:
llvm::Type *STy;
};
/// CodeGenTypes - This class organizes the cross-module state that is used
/// while lowering AST types to LLVM types.
class CodeGenTypes {
ASTContext &Context;
TargetInfo &Target;
llvm::Module& TheModule;
const llvm::TargetData& TheTargetData;
llvm::DenseMap<const TagDecl*, llvm::Type*> TagDeclTypes;
/// CGRecordLayouts - This maps llvm struct type with corresponding
/// record layout info.
/// FIXME : If CGRecordLayout is less than 16 bytes then use
/// inline it in the map.
llvm::DenseMap<const llvm::Type*, CGRecordLayout *> CGRecordLayouts;
/// FieldInfo - This maps struct field with corresponding llvm struct type
/// field no. This info is populated by record organizer.
llvm::DenseMap<const FieldDecl *, unsigned> FieldInfo;
class BitFieldInfo {
public:
explicit BitFieldInfo(unsigned N, unsigned B, unsigned E)
: No(N), Begin(B), End(E) {}
private:
// No - llvm struct field number that is used to
// access this field. It may be not same as struct field number.
// For example,
// struct S { char a; short b:2; }
// Here field 'b' is second field however it is accessed as
// 9th and 10th bitfield of first field whose type is short.
unsigned No;
unsigned Begin;
unsigned End;
};
llvm::DenseMap<const FieldDecl *, BitFieldInfo> BitFields;
/// RecordTypesToResolve - This keeps track of record types that are not
/// yet incomplete. One llvm::OpaqueType is associated with each incomplete
/// record.
llvm::DenseMap<const RecordDecl *, llvm::Type *> RecordTypesToResolve;
/// TypeHolderMap - This map keeps cache of llvm::Types (through PATypeHolder)
/// and maps llvm::Types to corresponding clang::Type. llvm::PATypeHolder is
/// used instead of llvm::Type because it allows us to bypass potential
/// dangling type pointers due to type refinement on llvm side.
llvm::DenseMap<Type *, llvm::PATypeHolder> TypeHolderMap;
/// ConvertNewType - Convert type T into a llvm::Type. Do not use this
/// method directly because it does not do any type caching. This method
/// is available only for ConvertType(). CovertType() is preferred
/// interface to convert type T into a llvm::Type.
const llvm::Type *ConvertNewType(QualType T);
public:
CodeGenTypes(ASTContext &Ctx, llvm::Module &M, const llvm::TargetData &TD);
~CodeGenTypes();
const llvm::TargetData &getTargetData() const { return TheTargetData; }
TargetInfo &getTarget() const { return Target; }
ASTContext &getContext() const { return Context; }
/// ConvertType - Convert type T into a llvm::Type. Maintain and use
/// type cache through TypeHOlderMap.
const llvm::Type *ConvertType(QualType T);
void DecodeArgumentTypes(const FunctionTypeProto &FTP,
std::vector<const llvm::Type*> &ArgTys);
const CGRecordLayout *getCGRecordLayout(const llvm::Type*) const;
/// getLLVMFieldNo - Return llvm::StructType element number
/// that corresponds to the field FD.
unsigned getLLVMFieldNo(const FieldDecl *FD);
/// addFieldInfo - Assign field number to field FD.
void addFieldInfo(const FieldDecl *FD, unsigned No, unsigned Begin,
unsigned End);
};
} // end namespace CodeGen
} // end namespace clang
#endif
|
