Mercurial > projects > ldc

comparison gen/structs.cpp @ 88:058d3925950e trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r92] Fixed support for statically initialized unions. lots of bugfixes as cleanups too.
author lindquist
date Tue, 06 Nov 2007 10:03:14 +0100
parents
children ce7ed8f59b99
comparison
equal deleted inserted replaced
87:25d4fcce53f4 88:058d3925950e
1 #include <algorithm>
2
3 #include "gen/llvm.h"
4
5 #include "mtype.h"
6 #include "aggregate.h"
7 #include "init.h"
8 #include "declaration.h"
9
10 #include "gen/irstate.h"
11 #include "gen/tollvm.h"
12 #include "gen/arrays.h"
13 #include "gen/logger.h"
14 #include "gen/structs.h"
15
16 //////////////////////////////////////////////////////////////////////////////////////////
17
18 const llvm::Type* DtoStructType(Type* t)
19 {
20 assert(0);
21 std::vector<const llvm::Type*> types;
22 return llvm::StructType::get(types);
23 }
24
25 //////////////////////////////////////////////////////////////////////////////////////////
26
27 llvm::Value* DtoStructZeroInit(llvm::Value* v)
28 {
29 assert(gIR);
30 uint64_t n = gTargetData->getTypeSize(v->getType()->getContainedType(0));
31 //llvm::Type* sarrty = llvm::PointerType::get(llvm::ArrayType::get(llvm::Type::Int8Ty, n));
32 llvm::Type* sarrty = llvm::PointerType::get(llvm::Type::Int8Ty);
33
34 llvm::Value* sarr = new llvm::BitCastInst(v,sarrty,"tmp",gIR->scopebb());
35
36 llvm::Function* fn = LLVM_DeclareMemSet32();
37 std::vector<llvm::Value*> llargs;
38 llargs.resize(4);
39 llargs[0] = sarr;
40 llargs[1] = llvm::ConstantInt::get(llvm::Type::Int8Ty, 0, false);
41 llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
42 llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
43
44 llvm::Value* ret = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
45
46 return ret;
47 }
48
49 //////////////////////////////////////////////////////////////////////////////////////////
50
51 llvm::Value* DtoStructCopy(llvm::Value* dst, llvm::Value* src)
52 {
53 Logger::cout() << "dst = " << *dst << " src = " << *src << '\n';
54 assert(dst->getType() == src->getType());
55 assert(gIR);
56
57 uint64_t n = gTargetData->getTypeSize(dst->getType()->getContainedType(0));
58 //llvm::Type* sarrty = llvm::PointerType::get(llvm::ArrayType::get(llvm::Type::Int8Ty, n));
59 llvm::Type* arrty = llvm::PointerType::get(llvm::Type::Int8Ty);
60
61 llvm::Value* dstarr = new llvm::BitCastInst(dst,arrty,"tmp",gIR->scopebb());
62 llvm::Value* srcarr = new llvm::BitCastInst(src,arrty,"tmp",gIR->scopebb());
63
64 llvm::Function* fn = LLVM_DeclareMemCpy32();
65 std::vector<llvm::Value*> llargs;
66 llargs.resize(4);
67 llargs[0] = dstarr;
68 llargs[1] = srcarr;
69 llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false);
70 llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
71
72 return new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb());
73 }
74
75 //////////////////////////////////////////////////////////////////////////////////////////
76 llvm::Constant* DtoConstStructInitializer(StructInitializer* si)
77 {
78 Logger::println("DtoConstStructInitializer: %s", si->toChars());
79 LOG_SCOPE;
80
81 const llvm::StructType* structtype = llvm::cast<llvm::StructType>(si->ad->llvmType);
82 Logger::cout() << "llvm struct type: " << *structtype << '\n';
83
84 assert(si->value.dim == si->vars.dim);
85
86 std::vector<DUnionIdx> inits;
87 for (int i = 0; i < si->value.dim; ++i)
88 {
89 Initializer* ini = (Initializer*)si->value.data[i];
90 assert(ini);
91 VarDeclaration* vd = (VarDeclaration*)si->vars.data[i];
92 assert(vd);
93 llvm::Constant* v = DtoConstInitializer(vd->type, ini);
94 inits.push_back(DUnionIdx(vd->llvmFieldIndex, vd->llvmFieldIndexOffset, v));
95 }
96
97 return si->ad->llvmUnion->getConst(inits);
98 }
99
100 //////////////////////////////////////////////////////////////////////////////////////////
101
102 llvm::Value* DtoIndexStruct(llvm::Value* ptr, StructDeclaration* sd, Type* t, unsigned os, std::vector<unsigned>& idxs)
103 {
104 Logger::println("checking for offset %u type %s:", os, t->toChars());
105 LOG_SCOPE;
106
107 if (idxs.empty())
108 idxs.push_back(0);
109
110 const llvm::Type* llt = llvm::PointerType::get(DtoType(t));
111 const llvm::Type* st = llvm::PointerType::get(DtoType(sd->type));
112 if (ptr->getType() != st) {
113 assert(sd->llvmHasUnions);
114 ptr = gIR->ir->CreateBitCast(ptr, st, "tmp");
115 }
116
117 for (unsigned i=0; i<sd->fields.dim; ++i) {
118 VarDeclaration* vd = (VarDeclaration*)sd->fields.data[i];
119 Type* vdtype = DtoDType(vd->type);
120 Logger::println("found %u type %s", vd->offset, vdtype->toChars());
121 assert(vd->llvmFieldIndex >= 0);
122 if (os == vd->offset && vdtype == t) {
123 idxs.push_back(vd->llvmFieldIndex);
124 ptr = DtoGEP(ptr, idxs, "tmp");
125 if (ptr->getType() != llt)
126 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
127 if (vd->llvmFieldIndexOffset)
128 ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->llvmFieldIndexOffset), "tmp", gIR->scopebb());
129 return ptr;
130 }
131 else if (vdtype->ty == Tstruct && (vd->offset + vdtype->size()) > os) {
132 TypeStruct* ts = (TypeStruct*)vdtype;
133 StructDeclaration* ssd = ts->sym;
134 idxs.push_back(vd->llvmFieldIndex);
135 if (vd->llvmFieldIndexOffset) {
136 Logger::println("has union field offset");
137 ptr = DtoGEP(ptr, idxs, "tmp");
138 if (ptr->getType() != llt)
139 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
140 ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->llvmFieldIndexOffset), "tmp", gIR->scopebb());
141 std::vector<unsigned> tmp;
142 return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp);
143 }
144 else {
145 const llvm::Type* sty = llvm::PointerType::get(DtoType(vd->type));
146 if (ptr->getType() != sty) {
147 ptr = gIR->ir->CreateBitCast(ptr, sty, "tmp");
148 std::vector<unsigned> tmp;
149 return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp);
150 }
151 else {
152 return DtoIndexStruct(ptr, ssd, t, os-vd->offset, idxs);
153 }
154 }
155 }
156 }
157
158 size_t llt_sz = gTargetData->getTypeSize(llt->getContainedType(0));
159 assert(os % llt_sz == 0);
160 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
161 return new llvm::GetElementPtrInst(ptr, DtoConstUint(os / llt_sz), "tmp", gIR->scopebb());
162 }
163 //////////////////////////////////////////////////////////////////////////////////////////
164 //////////////////////////// D UNION HELPER CLASS ////////////////////////////////////
165 //////////////////////////////////////////////////////////////////////////////////////////
166
167 DUnion::DUnion()
168 {
169 DUnionField* f = NULL;
170 IRStruct& topstruct = gIR->topstruct();
171 bool unions = false;
172 for (IRStruct::OffsetMap::iterator i=topstruct.offsets.begin(); i!=topstruct.offsets.end(); ++i)
173 {
174 unsigned o = i->first;
175 IRStruct::Offset* so = &i->second;
176 const llvm::Type* ft = so->init->getType();
177 size_t sz = gTargetData->getTypeSize(ft);
178 if (f == NULL) { // new field
179 fields.push_back(DUnionField());
180 f = &fields.back();
181 f->size = sz;
182 f->offset = o;
183 f->init = so->init;
184 f->initsize = sz;
185 f->types.push_back(ft);
186 }
187 else if (o == f->offset) { // same offset
188 if (sz > f->size)
189 f->size = sz;
190 f->types.push_back(ft);
191 unions = true;
192 }
193 else if (o < f->offset+f->size) {
194 assert((o+sz) <= (f->offset+f->size));
195 unions = true;
196 }
197 else {
198 fields.push_back(DUnionField());
199 f = &fields.back();
200 f->size = sz;
201 f->offset = o;
202 f->init = so->init;
203 f->initsize = sz;
204 f->types.push_back(ft);
205 }
206 }
207
208 {
209 LOG_SCOPE;
210 Logger::println("******** DUnion BEGIN");
211 size_t n = fields.size();
212 for (size_t i=0; i<n; ++i) {
213 Logger::cout()<<"field #"<<i<<" offset: "<<fields[i].offset<<" size: "<<fields[i].size<<'('<<fields[i].initsize<<")\n";
214 LOG_SCOPE;
215 size_t nt = fields[i].types.size();
216 for (size_t j=0; j<nt; ++j) {
217 Logger::cout()<<*fields[i].types[j]<<'\n';
218 }
219 }
220 Logger::println("******** DUnion END");
221 }
222 }
223
224 static void push_nulls(size_t nbytes, std::vector<llvm::Constant*>& out)
225 {
226 assert(nbytes > 0);
227 std::vector<llvm::Constant*> i(nbytes, llvm::ConstantInt::get(llvm::Type::Int8Ty, 0, false));
228 out.push_back(llvm::ConstantArray::get(llvm::ArrayType::get(llvm::Type::Int8Ty, nbytes), i));
229 }
230
231 llvm::Constant* DUnion::getConst(std::vector<DUnionIdx>& in)
232 {
233 std::sort(in.begin(), in.end());
234 std::vector<llvm::Constant*> out;
235
236 size_t nin = in.size();
237 size_t nfields = fields.size();
238
239 size_t fi = 0;
240 size_t last = 0;
241 size_t ii = 0;
242 size_t os = 0;
243
244 for(;;)
245 {
246 if (fi == nfields) break;
247
248 bool nextSame = (ii+1 < nin) && (in[ii+1].idx == fi);
249
250 if (ii < nin && fi == in[ii].idx)
251 {
252 size_t s = gTargetData->getTypeSize(in[ii].c->getType());
253 if (in[ii].idx == last)
254 {
255 size_t nos = in[ii].idxos * s;
256 if (nos && nos-os) {
257 assert(nos >= os);
258 push_nulls(nos-os, out);
259 }
260 os = nos + s;
261 }
262 else
263 {
264 os = s;
265 }
266 out.push_back(in[ii].c);
267 ii++;
268 if (!nextSame)
269 {
270 if (os < fields[fi].size)
271 push_nulls(fields[fi].size - os, out);
272 os = 0;
273 last = fi++;
274 }
275 continue;
276 }
277
278 // default initialize if necessary
279 if (ii == nin || fi < in[ii].idx)
280 {
281 DUnionField& f = fields[fi];
282 out.push_back(f.init);
283 if (f.initsize < f.size)
284 push_nulls(f.size - f.initsize, out);
285 last = fi++;
286 os = 0;
287 continue;
288 }
289 }
290
291 std::vector<const llvm::Type*> tys;
292 size_t nout = out.size();
293 for (size_t i=0; i<nout; ++i)
294 tys.push_back(out[i]->getType());
295
296 const llvm::StructType* st = llvm::StructType::get(tys);
297 return llvm::ConstantStruct::get(st, out);
298 }
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319