Mercurial > projects > ldc

comparison gen/classes.cpp @ 173:db9890b3fb64 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r189] moving IR data back into DMD frontend nodes
author ChristianK
date Tue, 06 May 2008 07:56:03 +0200
parents 2df270e1ba59
children cea8dcfa76df
comparison
equal deleted inserted replaced
172:68a7dd38c03c 173:db9890b3fb64
33 33
34 // resolve interfaces while we're at it 34 // resolve interfaces while we're at it
35 if (bc->base->isInterfaceDeclaration()) 35 if (bc->base->isInterfaceDeclaration())
36 { 36 {
37 // don't add twice 37 // don't add twice
38 if (gIR->irDsymbol[target].irStruct->interfaceMap.find(bc->base) == gIR->irDsymbol[target].irStruct->interfaceMap.end()) 38 if (target->ir.irStruct->interfaceMap.find(bc->base) == target->ir.irStruct->interfaceMap.end())
39 { 39 {
40 Logger::println("adding interface '%s'", bc->base->toPrettyChars()); 40 Logger::println("adding interface '%s'", bc->base->toPrettyChars());
41 IrInterface* iri = new IrInterface(bc, NULL); 41 IrInterface* iri = new IrInterface(bc, NULL);
42 42
43 // add to map 43 // add to map
44 gIR->irDsymbol[target].irStruct->interfaceMap.insert(std::make_pair(bc->base, iri)); 44 target->ir.irStruct->interfaceMap.insert(std::make_pair(bc->base, iri));
45 // add to ordered list 45 // add to ordered list
46 gIR->irDsymbol[target].irStruct->interfaceVec.push_back(iri); 46 target->ir.irStruct->interfaceVec.push_back(iri);
47 47
48 // Fill in vtbl[] 48 // Fill in vtbl[]
49 if (!target->isAbstract()) { 49 if (!target->isAbstract()) {
50 bc->fillVtbl(target, &bc->vtbl, 0); 50 bc->fillVtbl(target, &bc->vtbl, 0);
51 } 51 }
86 86
87 ////////////////////////////////////////////////////////////////////////////////////////// 87 //////////////////////////////////////////////////////////////////////////////////////////
88 88
89 void DtoResolveClass(ClassDeclaration* cd) 89 void DtoResolveClass(ClassDeclaration* cd)
90 { 90 {
91 if (gIR->irDsymbol[cd].resolved) return; 91 if (cd->ir.resolved) return;
92 gIR->irDsymbol[cd].resolved = true; 92 cd->ir.resolved = true;
93 93
94 Logger::println("DtoResolveClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars()); 94 Logger::println("DtoResolveClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
95 LOG_SCOPE; 95 LOG_SCOPE;
96 96
97 // get the TypeClass 97 // get the TypeClass
98 assert(cd->type->ty == Tclass); 98 assert(cd->type->ty == Tclass);
99 TypeClass* ts = (TypeClass*)cd->type; 99 TypeClass* ts = (TypeClass*)cd->type;
100 100
101 // make sure the IrStruct is created 101 // make sure the IrStruct is created
102 IrStruct* irstruct = gIR->irDsymbol[cd].irStruct; 102 IrStruct* irstruct = cd->ir.irStruct;
103 if (!irstruct) { 103 if (!irstruct) {
104 irstruct = new IrStruct(ts); 104 irstruct = new IrStruct(ts);
105 gIR->irDsymbol[cd].irStruct = irstruct; 105 cd->ir.irStruct = irstruct;
106 } 106 }
107 107
108 // resolve the base class 108 // resolve the base class
109 if (cd->baseClass) { 109 if (cd->baseClass) {
110 DtoResolveClass(cd->baseClass); 110 DtoResolveClass(cd->baseClass);
126 126
127 gIR->structs.push_back(irstruct); 127 gIR->structs.push_back(irstruct);
128 gIR->classes.push_back(cd); 128 gIR->classes.push_back(cd);
129 129
130 // add vtable 130 // add vtable
131 gIR->irType[ts].vtblType = new llvm::PATypeHolder(llvm::OpaqueType::get()); 131 ts->ir.vtblType = new llvm::PATypeHolder(llvm::OpaqueType::get());
132 const llvm::Type* vtabty = getPtrToType(gIR->irType[ts].vtblType->get()); 132 const llvm::Type* vtabty = getPtrToType(ts->ir.vtblType->get());
133 133
134 std::vector<const llvm::Type*> fieldtypes; 134 std::vector<const llvm::Type*> fieldtypes;
135 fieldtypes.push_back(vtabty); 135 fieldtypes.push_back(vtabty);
136 136
137 // add monitor 137 // add monitor
167 if (lastoffset == (unsigned)-1) { 167 if (lastoffset == (unsigned)-1) {
168 lastoffset = i->first; 168 lastoffset = i->first;
169 fieldtype = i->second.type; 169 fieldtype = i->second.type;
170 fieldinit = i->second.var; 170 fieldinit = i->second.var;
171 prevsize = getABITypeSize(fieldtype); 171 prevsize = getABITypeSize(fieldtype);
172 gIR->irDsymbol[i->second.var].irField->index = idx; 172 i->second.var->ir.irField->index = idx;
173 } 173 }
174 // colliding offset? 174 // colliding offset?
175 else if (lastoffset == i->first) { 175 else if (lastoffset == i->first) {
176 size_t s = getABITypeSize(i->second.type); 176 size_t s = getABITypeSize(i->second.type);
177 if (s > prevsize) { 177 if (s > prevsize) {
178 fieldpad += s - prevsize; 178 fieldpad += s - prevsize;
179 prevsize = s; 179 prevsize = s;
180 } 180 }
181 gIR->irDsymbol[cd].irStruct->hasUnions = true; 181 cd->ir.irStruct->hasUnions = true;
182 gIR->irDsymbol[i->second.var].irField->index = idx; 182 i->second.var->ir.irField->index = idx;
183 } 183 }
184 // intersecting offset? 184 // intersecting offset?
185 else if (i->first < (lastoffset + prevsize)) { 185 else if (i->first < (lastoffset + prevsize)) {
186 size_t s = getABITypeSize(i->second.type); 186 size_t s = getABITypeSize(i->second.type);
187 assert((i->first + s) <= (lastoffset + prevsize)); // this holds because all types are aligned to their size 187 assert((i->first + s) <= (lastoffset + prevsize)); // this holds because all types are aligned to their size
188 gIR->irDsymbol[cd].irStruct->hasUnions = true; 188 cd->ir.irStruct->hasUnions = true;
189 gIR->irDsymbol[i->second.var].irField->index = idx; 189 i->second.var->ir.irField->index = idx;
190 gIR->irDsymbol[i->second.var].irField->indexOffset = (i->first - lastoffset) / s; 190 i->second.var->ir.irField->indexOffset = (i->first - lastoffset) / s;
191 } 191 }
192 // fresh offset 192 // fresh offset
193 else { 193 else {
194 // commit the field 194 // commit the field
195 fieldtypes.push_back(fieldtype); 195 fieldtypes.push_back(fieldtype);
205 // start new 205 // start new
206 lastoffset = i->first; 206 lastoffset = i->first;
207 fieldtype = i->second.type; 207 fieldtype = i->second.type;
208 fieldinit = i->second.var; 208 fieldinit = i->second.var;
209 prevsize = getABITypeSize(fieldtype); 209 prevsize = getABITypeSize(fieldtype);
210 gIR->irDsymbol[i->second.var].irField->index = idx; 210 i->second.var->ir.irField->index = idx;
211 fieldpad = 0; 211 fieldpad = 0;
212 } 212 }
213 } 213 }
214 fieldtypes.push_back(fieldtype); 214 fieldtypes.push_back(fieldtype);
215 irstruct->defaultFields.push_back(fieldinit); 215 irstruct->defaultFields.push_back(fieldinit);
222 // populate interface map 222 // populate interface map
223 { 223 {
224 Logger::println("Adding interfaces to '%s'", cd->toPrettyChars()); 224 Logger::println("Adding interfaces to '%s'", cd->toPrettyChars());
225 LOG_SCOPE; 225 LOG_SCOPE;
226 LLVM_AddBaseClassInterfaces(cd, &cd->baseclasses); 226 LLVM_AddBaseClassInterfaces(cd, &cd->baseclasses);
227 Logger::println("%d interfaces added", gIR->irDsymbol[cd].irStruct->interfaceVec.size()); 227 Logger::println("%d interfaces added", cd->ir.irStruct->interfaceVec.size());
228 assert(gIR->irDsymbol[cd].irStruct->interfaceVec.size() == gIR->irDsymbol[cd].irStruct->interfaceMap.size()); 228 assert(cd->ir.irStruct->interfaceVec.size() == cd->ir.irStruct->interfaceMap.size());
229 } 229 }
230 230
231 // add interface vtables at the end 231 // add interface vtables at the end
232 int interIdx = (int)fieldtypes.size(); 232 int interIdx = (int)fieldtypes.size();
233 for (IrStruct::InterfaceVectorIter i=irstruct->interfaceVec.begin(); i!=irstruct->interfaceVec.end(); ++i) 233 for (IrStruct::InterfaceVectorIter i=irstruct->interfaceVec.begin(); i!=irstruct->interfaceVec.end(); ++i)
235 IrInterface* iri = *i; 235 IrInterface* iri = *i;
236 ClassDeclaration* id = iri->decl; 236 ClassDeclaration* id = iri->decl;
237 237
238 // set vtbl type 238 // set vtbl type
239 TypeClass* itc = (TypeClass*)id->type; 239 TypeClass* itc = (TypeClass*)id->type;
240 const llvm::Type* ivtblTy = getPtrToType(gIR->irType[itc].vtblType->get()); 240 const llvm::Type* ivtblTy = getPtrToType(itc->ir.vtblType->get());
241 fieldtypes.push_back(ivtblTy); 241 fieldtypes.push_back(ivtblTy);
242 242
243 // fix the interface vtable type 243 // fix the interface vtable type
244 iri->vtblTy = isaStruct(gIR->irType[itc].vtblType->get()); 244 iri->vtblTy = isaStruct(itc->ir.vtblType->get());
245 245
246 // set index 246 // set index
247 iri->index = interIdx++; 247 iri->index = interIdx++;
248 } 248 }
249 Logger::println("%d interface vtables added", gIR->irDsymbol[cd].irStruct->interfaceVec.size()); 249 Logger::println("%d interface vtables added", cd->ir.irStruct->interfaceVec.size());
250 assert(gIR->irDsymbol[cd].irStruct->interfaceVec.size() == gIR->irDsymbol[cd].irStruct->interfaceMap.size()); 250 assert(cd->ir.irStruct->interfaceVec.size() == cd->ir.irStruct->interfaceMap.size());
251 251
252 // create type 252 // create type
253 const llvm::StructType* structtype = llvm::StructType::get(fieldtypes); 253 const llvm::StructType* structtype = llvm::StructType::get(fieldtypes);
254 254
255 // refine abstract types for stuff like: class C {C next;} 255 // refine abstract types for stuff like: class C {C next;}
257 llvm::PATypeHolder& spa = irstruct->recty; 257 llvm::PATypeHolder& spa = irstruct->recty;
258 llvm::cast<llvm::OpaqueType>(spa.get())->refineAbstractTypeTo(structtype); 258 llvm::cast<llvm::OpaqueType>(spa.get())->refineAbstractTypeTo(structtype);
259 structtype = isaStruct(spa.get()); 259 structtype = isaStruct(spa.get());
260 260
261 // make it official 261 // make it official
262 if (!gIR->irType[ts].type) 262 if (!ts->ir.type)
263 gIR->irType[ts].type = new llvm::PATypeHolder(structtype); 263 ts->ir.type = new llvm::PATypeHolder(structtype);
264 else 264 else
265 *gIR->irType[ts].type = structtype; 265 *ts->ir.type = structtype;
266 spa = *gIR->irType[ts].type; 266 spa = *ts->ir.type;
267 267
268 // name the type 268 // name the type
269 gIR->module->addTypeName(cd->mangle(), gIR->irType[ts].type->get()); 269 gIR->module->addTypeName(cd->mangle(), ts->ir.type->get());
270 270
271 // get interface info type 271 // get interface info type
272 const llvm::StructType* infoTy = DtoInterfaceInfoType(); 272 const llvm::StructType* infoTy = DtoInterfaceInfoType();
273 273
274 // create vtable type 274 // create vtable type
283 283
284 if (FuncDeclaration* fd = dsym->isFuncDeclaration()) { 284 if (FuncDeclaration* fd = dsym->isFuncDeclaration()) {
285 DtoResolveFunction(fd); 285 DtoResolveFunction(fd);
286 //assert(fd->type->ty == Tfunction); 286 //assert(fd->type->ty == Tfunction);
287 //TypeFunction* tf = (TypeFunction*)fd->type; 287 //TypeFunction* tf = (TypeFunction*)fd->type;
288 //const llvm::Type* fpty = getPtrToType(gIR->irType[tf].type->get()); 288 //const llvm::Type* fpty = getPtrToType(tf->ir.type->get());
289 const llvm::FunctionType* vfty = DtoBaseFunctionType(fd); 289 const llvm::FunctionType* vfty = DtoBaseFunctionType(fd);
290 const llvm::Type* vfpty = getPtrToType(vfty); 290 const llvm::Type* vfpty = getPtrToType(vfty);
291 sinits_ty.push_back(vfpty); 291 sinits_ty.push_back(vfpty);
292 } 292 }
293 else if (ClassDeclaration* cd2 = dsym->isClassDeclaration()) { 293 else if (ClassDeclaration* cd2 = dsym->isClassDeclaration()) {
295 const llvm::Type* cinfoty; 295 const llvm::Type* cinfoty;
296 if (cd->isInterfaceDeclaration()) { 296 if (cd->isInterfaceDeclaration()) {
297 cinfoty = infoTy; 297 cinfoty = infoTy;
298 } 298 }
299 else if (cd != ClassDeclaration::classinfo) { 299 else if (cd != ClassDeclaration::classinfo) {
300 cinfoty = gIR->irType[ClassDeclaration::classinfo->type].type->get(); 300 cinfoty = ClassDeclaration::classinfo->type->ir.type->get();
301 } 301 }
302 else { 302 else {
303 // this is the ClassInfo class, the type is this type 303 // this is the ClassInfo class, the type is this type
304 cinfoty = gIR->irType[ts].type->get(); 304 cinfoty = ts->ir.type->get();
305 } 305 }
306 const llvm::Type* cty = getPtrToType(cinfoty); 306 const llvm::Type* cty = getPtrToType(cinfoty);
307 sinits_ty.push_back(cty); 307 sinits_ty.push_back(cty);
308 } 308 }
309 else 309 else
316 std::string styname(cd->mangle()); 316 std::string styname(cd->mangle());
317 styname.append("__vtblType"); 317 styname.append("__vtblType");
318 gIR->module->addTypeName(styname, svtbl_ty); 318 gIR->module->addTypeName(styname, svtbl_ty);
319 319
320 // refine for final vtable type 320 // refine for final vtable type
321 llvm::cast<llvm::OpaqueType>(gIR->irType[ts].vtblType->get())->refineAbstractTypeTo(svtbl_ty); 321 llvm::cast<llvm::OpaqueType>(ts->ir.vtblType->get())->refineAbstractTypeTo(svtbl_ty);
322 322
323 gIR->classes.pop_back(); 323 gIR->classes.pop_back();
324 gIR->structs.pop_back(); 324 gIR->structs.pop_back();
325 325
326 gIR->declareList.push_back(cd); 326 gIR->declareList.push_back(cd);
328 328
329 ////////////////////////////////////////////////////////////////////////////////////////// 329 //////////////////////////////////////////////////////////////////////////////////////////
330 330
331 void DtoDeclareClass(ClassDeclaration* cd) 331 void DtoDeclareClass(ClassDeclaration* cd)
332 { 332 {
333 if (gIR->irDsymbol[cd].declared) return; 333 if (cd->ir.declared) return;
334 gIR->irDsymbol[cd].declared = true; 334 cd->ir.declared = true;
335 335
336 Logger::println("DtoDeclareClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars()); 336 Logger::println("DtoDeclareClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
337 LOG_SCOPE; 337 LOG_SCOPE;
338 338
339 assert(cd->type->ty == Tclass); 339 assert(cd->type->ty == Tclass);
340 TypeClass* ts = (TypeClass*)cd->type; 340 TypeClass* ts = (TypeClass*)cd->type;
341 341
342 assert(gIR->irDsymbol[cd].irStruct); 342 assert(cd->ir.irStruct);
343 IrStruct* irstruct = gIR->irDsymbol[cd].irStruct; 343 IrStruct* irstruct = cd->ir.irStruct;
344 344
345 gIR->structs.push_back(irstruct); 345 gIR->structs.push_back(irstruct);
346 gIR->classes.push_back(cd); 346 gIR->classes.push_back(cd);
347 347
348 bool needs_definition = false; 348 bool needs_definition = false;
358 // vtable 358 // vtable
359 std::string varname("_D"); 359 std::string varname("_D");
360 varname.append(cd->mangle()); 360 varname.append(cd->mangle());
361 varname.append("6__vtblZ"); 361 varname.append("6__vtblZ");
362 362
363 const llvm::StructType* svtbl_ty = isaStruct(gIR->irType[ts].vtblType->get()); 363 const llvm::StructType* svtbl_ty = isaStruct(ts->ir.vtblType->get());
364 gIR->irDsymbol[cd].irStruct->vtbl = new llvm::GlobalVariable(svtbl_ty, true, _linkage, 0, varname, gIR->module); 364 cd->ir.irStruct->vtbl = new llvm::GlobalVariable(svtbl_ty, true, _linkage, 0, varname, gIR->module);
365 } 365 }
366 366
367 // get interface info type 367 // get interface info type
368 const llvm::StructType* infoTy = DtoInterfaceInfoType(); 368 const llvm::StructType* infoTy = DtoInterfaceInfoType();
369 369
370 // interface info array 370 // interface info array
371 if (!gIR->irDsymbol[cd].irStruct->interfaceVec.empty()) { 371 if (!cd->ir.irStruct->interfaceVec.empty()) {
372 // symbol name 372 // symbol name
373 std::string nam = "_D"; 373 std::string nam = "_D";
374 nam.append(cd->mangle()); 374 nam.append(cd->mangle());
375 nam.append("16__interfaceInfosZ"); 375 nam.append("16__interfaceInfosZ");
376 // resolve array type 376 // resolve array type
377 const llvm::ArrayType* arrTy = llvm::ArrayType::get(infoTy, gIR->irDsymbol[cd].irStruct->interfaceVec.size()); 377 const llvm::ArrayType* arrTy = llvm::ArrayType::get(infoTy, cd->ir.irStruct->interfaceVec.size());
378 // declare global 378 // declare global
379 irstruct->interfaceInfosTy = arrTy; 379 irstruct->interfaceInfosTy = arrTy;
380 irstruct->interfaceInfos = new llvm::GlobalVariable(arrTy, true, _linkage, NULL, nam, gIR->module); 380 irstruct->interfaceInfos = new llvm::GlobalVariable(arrTy, true, _linkage, NULL, nam, gIR->module);
381 } 381 }
382 382
406 // init 406 // init
407 std::string initname("_D"); 407 std::string initname("_D");
408 initname.append(cd->mangle()); 408 initname.append(cd->mangle());
409 initname.append("6__initZ"); 409 initname.append("6__initZ");
410 410
411 llvm::GlobalVariable* initvar = new llvm::GlobalVariable(gIR->irType[ts].type->get(), true, _linkage, NULL, initname, gIR->module); 411 llvm::GlobalVariable* initvar = new llvm::GlobalVariable(ts->ir.type->get(), true, _linkage, NULL, initname, gIR->module);
412 gIR->irDsymbol[cd].irStruct->init = initvar; 412 cd->ir.irStruct->init = initvar;
413 } 413 }
414 414
415 gIR->classes.pop_back(); 415 gIR->classes.pop_back();
416 gIR->structs.pop_back(); 416 gIR->structs.pop_back();
417 417
429 429
430 ////////////////////////////////////////////////////////////////////////////////////////// 430 //////////////////////////////////////////////////////////////////////////////////////////
431 431
432 void DtoConstInitClass(ClassDeclaration* cd) 432 void DtoConstInitClass(ClassDeclaration* cd)
433 { 433 {
434 if (gIR->irDsymbol[cd].initialized) return; 434 if (cd->ir.initialized) return;
435 gIR->irDsymbol[cd].initialized = true; 435 cd->ir.initialized = true;
436 436
437 if (cd->isInterfaceDeclaration()) 437 if (cd->isInterfaceDeclaration())
438 return; // nothing to do 438 return; // nothing to do
439 439
440 Logger::println("DtoConstInitClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars()); 440 Logger::println("DtoConstInitClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
441 LOG_SCOPE; 441 LOG_SCOPE;
442 442
443 IrStruct* irstruct = gIR->irDsymbol[cd].irStruct; 443 IrStruct* irstruct = cd->ir.irStruct;
444 gIR->structs.push_back(irstruct); 444 gIR->structs.push_back(irstruct);
445 gIR->classes.push_back(cd); 445 gIR->classes.push_back(cd);
446 446
447 // get the struct (class) type 447 // get the struct (class) type
448 assert(cd->type->ty == Tclass); 448 assert(cd->type->ty == Tclass);
449 TypeClass* ts = (TypeClass*)cd->type; 449 TypeClass* ts = (TypeClass*)cd->type;
450 const llvm::StructType* structtype = isaStruct(gIR->irType[ts].type->get()); 450 const llvm::StructType* structtype = isaStruct(ts->ir.type->get());
451 const llvm::StructType* vtbltype = isaStruct(gIR->irType[ts].vtblType->get()); 451 const llvm::StructType* vtbltype = isaStruct(ts->ir.vtblType->get());
452 452
453 // make sure each offset knows its default initializer 453 // make sure each offset knows its default initializer
454 for (IrStruct::OffsetMap::iterator i=irstruct->offsets.begin(); i!=irstruct->offsets.end(); ++i) 454 for (IrStruct::OffsetMap::iterator i=irstruct->offsets.begin(); i!=irstruct->offsets.end(); ++i)
455 { 455 {
456 IrStruct::Offset* so = &i->second; 456 IrStruct::Offset* so = &i->second;
457 llvm::Constant* finit = DtoConstFieldInitializer(so->var->type, so->var->init); 457 llvm::Constant* finit = DtoConstFieldInitializer(so->var->type, so->var->init);
458 so->init = finit; 458 so->init = finit;
459 gIR->irDsymbol[so->var].irField->constInit = finit; 459 so->var->ir.irField->constInit = finit;
460 } 460 }
461 461
462 // fill out fieldtypes/inits 462 // fill out fieldtypes/inits
463 std::vector<llvm::Constant*> fieldinits; 463 std::vector<llvm::Constant*> fieldinits;
464 464
466 if (cd->isAbstract()) 466 if (cd->isAbstract())
467 { 467 {
468 fieldinits.push_back( 468 fieldinits.push_back(
469 llvm::ConstantPointerNull::get( 469 llvm::ConstantPointerNull::get(
470 getPtrToType( 470 getPtrToType(
471 gIR->irType[ts].vtblType->get() 471 ts->ir.vtblType->get()
472 ) 472 )
473 ) 473 )
474 ); 474 );
475 } 475 }
476 else 476 else
477 { 477 {
478 assert(gIR->irDsymbol[cd].irStruct->vtbl != 0); 478 assert(cd->ir.irStruct->vtbl != 0);
479 fieldinits.push_back(gIR->irDsymbol[cd].irStruct->vtbl); 479 fieldinits.push_back(cd->ir.irStruct->vtbl);
480 } 480 }
481 481
482 // then comes monitor 482 // then comes monitor
483 fieldinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(llvm::Type::Int8Ty))); 483 fieldinits.push_back(llvm::ConstantPointerNull::get(getPtrToType(llvm::Type::Int8Ty)));
484 484
485 // go through the field inits and build the default initializer 485 // go through the field inits and build the default initializer
486 size_t nfi = irstruct->defaultFields.size(); 486 size_t nfi = irstruct->defaultFields.size();
487 for (size_t i=0; i<nfi; ++i) { 487 for (size_t i=0; i<nfi; ++i) {
488 llvm::Constant* c; 488 llvm::Constant* c;
489 if (irstruct->defaultFields[i]) { 489 if (irstruct->defaultFields[i]) {
490 c = gIR->irDsymbol[irstruct->defaultFields[i]].irField->constInit; 490 c = irstruct->defaultFields[i]->ir.irField->constInit;
491 assert(c); 491 assert(c);
492 } 492 }
493 else { 493 else {
494 const llvm::ArrayType* arrty = isaArray(structtype->getElementType(i+2)); 494 const llvm::ArrayType* arrty = isaArray(structtype->getElementType(i+2));
495 assert(arrty); 495 assert(arrty);
534 } 534 }
535 #endif 535 #endif
536 536
537 llvm::Constant* _init = llvm::ConstantStruct::get(structtype, fieldinits); 537 llvm::Constant* _init = llvm::ConstantStruct::get(structtype, fieldinits);
538 assert(_init); 538 assert(_init);
539 gIR->irDsymbol[cd].irStruct->constInit = _init; 539 cd->ir.irStruct->constInit = _init;
540 540
541 // abstract classes have no static vtable 541 // abstract classes have no static vtable
542 // neither do interfaces (on their own, the implementing class supplies the vtable) 542 // neither do interfaces (on their own, the implementing class supplies the vtable)
543 if (!cd->isInterfaceDeclaration() && !cd->isAbstract()) 543 if (!cd->isInterfaceDeclaration() && !cd->isAbstract())
544 { 544 {
551 assert(dsym); 551 assert(dsym);
552 //Logger::cout() << "vtblsym: " << dsym->toChars() << '\n'; 552 //Logger::cout() << "vtblsym: " << dsym->toChars() << '\n';
553 553
554 if (FuncDeclaration* fd = dsym->isFuncDeclaration()) { 554 if (FuncDeclaration* fd = dsym->isFuncDeclaration()) {
555 DtoForceDeclareDsymbol(fd); 555 DtoForceDeclareDsymbol(fd);
556 assert(gIR->irDsymbol[fd].irFunc->func); 556 assert(fd->ir.irFunc->func);
557 llvm::Constant* c = llvm::cast<llvm::Constant>(gIR->irDsymbol[fd].irFunc->func); 557 llvm::Constant* c = llvm::cast<llvm::Constant>(fd->ir.irFunc->func);
558 // cast if necessary (overridden method) 558 // cast if necessary (overridden method)
559 if (c->getType() != vtbltype->getElementType(k)) 559 if (c->getType() != vtbltype->getElementType(k))
560 c = llvm::ConstantExpr::getBitCast(c, vtbltype->getElementType(k)); 560 c = llvm::ConstantExpr::getBitCast(c, vtbltype->getElementType(k));
561 sinits.push_back(c); 561 sinits.push_back(c);
562 } 562 }
563 else if (ClassDeclaration* cd2 = dsym->isClassDeclaration()) { 563 else if (ClassDeclaration* cd2 = dsym->isClassDeclaration()) {
564 assert(gIR->irDsymbol[cd].irStruct->classInfo); 564 assert(cd->ir.irStruct->classInfo);
565 llvm::Constant* c = gIR->irDsymbol[cd].irStruct->classInfo; 565 llvm::Constant* c = cd->ir.irStruct->classInfo;
566 sinits.push_back(c); 566 sinits.push_back(c);
567 } 567 }
568 else 568 else
569 assert(0); 569 assert(0);
570 } 570 }
571 571
572 const llvm::StructType* svtbl_ty = isaStruct(gIR->irType[ts].vtblType->get()); 572 const llvm::StructType* svtbl_ty = isaStruct(ts->ir.vtblType->get());
573 573
574 #if 0 574 #if 0
575 for (size_t i=0; i< sinits.size(); ++i) 575 for (size_t i=0; i< sinits.size(); ++i)
576 { 576 {
577 Logger::cout() << "field[" << i << "] = " << *svtbl_ty->getElementType(i) << '\n'; 577 Logger::cout() << "field[" << i << "] = " << *svtbl_ty->getElementType(i) << '\n';
579 assert(svtbl_ty->getElementType(i) == sinits[i]->getType()); 579 assert(svtbl_ty->getElementType(i) == sinits[i]->getType());
580 } 580 }
581 #endif 581 #endif
582 582
583 llvm::Constant* cvtblInit = llvm::ConstantStruct::get(svtbl_ty, sinits); 583 llvm::Constant* cvtblInit = llvm::ConstantStruct::get(svtbl_ty, sinits);
584 gIR->irDsymbol[cd].irStruct->constVtbl = llvm::cast<llvm::ConstantStruct>(cvtblInit); 584 cd->ir.irStruct->constVtbl = llvm::cast<llvm::ConstantStruct>(cvtblInit);
585 585
586 // create interface vtable const initalizers 586 // create interface vtable const initalizers
587 for (IrStruct::InterfaceVectorIter i=irstruct->interfaceVec.begin(); i!=irstruct->interfaceVec.end(); ++i) 587 for (IrStruct::InterfaceVectorIter i=irstruct->interfaceVec.begin(); i!=irstruct->interfaceVec.end(); ++i)
588 { 588 {
589 IrInterface* iri = *i; 589 IrInterface* iri = *i;
591 591
592 ClassDeclaration* id = iri->decl; 592 ClassDeclaration* id = iri->decl;
593 assert(id->type->ty == Tclass); 593 assert(id->type->ty == Tclass);
594 TypeClass* its = (TypeClass*)id->type; 594 TypeClass* its = (TypeClass*)id->type;
595 595
596 const llvm::StructType* ivtbl_ty = isaStruct(gIR->irType[its].vtblType->get()); 596 const llvm::StructType* ivtbl_ty = isaStruct(its->ir.vtblType->get());
597 597
598 // generate interface info initializer 598 // generate interface info initializer
599 std::vector<llvm::Constant*> infoInits; 599 std::vector<llvm::Constant*> infoInits;
600 600
601 // classinfo 601 // classinfo
602 assert(gIR->irDsymbol[id].irStruct->classInfo); 602 assert(id->ir.irStruct->classInfo);
603 llvm::Constant* c = gIR->irDsymbol[id].irStruct->classInfo; 603 llvm::Constant* c = id->ir.irStruct->classInfo;
604 infoInits.push_back(c); 604 infoInits.push_back(c);
605 605
606 // vtbl 606 // vtbl
607 const llvm::Type* byteptrptrty = getPtrToType(getPtrToType(llvm::Type::Int8Ty)); 607 const llvm::Type* byteptrptrty = getPtrToType(getPtrToType(llvm::Type::Int8Ty));
608 c = llvm::ConstantExpr::getBitCast(iri->vtbl, byteptrptrty); 608 c = llvm::ConstantExpr::getBitCast(iri->vtbl, byteptrptrty);
610 infoInits.push_back(c); 610 infoInits.push_back(c);
611 611
612 // offset 612 // offset
613 // generate target independent offset with constGEP 613 // generate target independent offset with constGEP
614 /*llvm::Value* cidx = DtoConstInt(iri->index); 614 /*llvm::Value* cidx = DtoConstInt(iri->index);
615 Logger::cout() << "offset to interface in class type: " << *gIR->irType[cd->type].type->get() << '\n'; 615 Logger::cout() << "offset to interface in class type: " << *cd->type->ir.type->get() << '\n';
616 size_t ioff = gTargetData->getIndexedOffset(gIR->irType[cd->type].type->get(), &cidx, 1); 616 size_t ioff = gTargetData->getIndexedOffset(cd->type->ir.type->get(), &cidx, 1);
617 infoInits.push_back(DtoConstUint(ioff));*/ 617 infoInits.push_back(DtoConstUint(ioff));*/
618 assert(iri->index >= 0); 618 assert(iri->index >= 0);
619 size_t ioff = gTargetData->getStructLayout(isaStruct(gIR->irType[cd->type].type->get()))->getElementOffset(iri->index); 619 size_t ioff = gTargetData->getStructLayout(isaStruct(cd->type->ir.type->get()))->getElementOffset(iri->index);
620 infoInits.push_back(DtoConstUint(ioff)); 620 infoInits.push_back(DtoConstUint(ioff));
621 621
622 // create interface info initializer constant 622 // create interface info initializer constant
623 iri->infoInit = llvm::cast<llvm::ConstantStruct>(llvm::ConstantStruct::get(iri->infoTy, infoInits)); 623 iri->infoInit = llvm::cast<llvm::ConstantStruct>(llvm::ConstantStruct::get(iri->infoTy, infoInits));
624 624
634 Dsymbol* dsym = (Dsymbol*)b->vtbl.data[k]; 634 Dsymbol* dsym = (Dsymbol*)b->vtbl.data[k];
635 assert(dsym); 635 assert(dsym);
636 FuncDeclaration* fd = dsym->isFuncDeclaration(); 636 FuncDeclaration* fd = dsym->isFuncDeclaration();
637 assert(fd); 637 assert(fd);
638 DtoForceDeclareDsymbol(fd); 638 DtoForceDeclareDsymbol(fd);
639 assert(gIR->irDsymbol[fd].irFunc->func); 639 assert(fd->ir.irFunc->func);
640 llvm::Constant* c = llvm::cast<llvm::Constant>(gIR->irDsymbol[fd].irFunc->func); 640 llvm::Constant* c = llvm::cast<llvm::Constant>(fd->ir.irFunc->func);
641 641
642 // we have to bitcast, as the type created in ResolveClass expects a different this type 642 // we have to bitcast, as the type created in ResolveClass expects a different this type
643 c = llvm::ConstantExpr::getBitCast(c, iri->vtblTy->getContainedType(k)); 643 c = llvm::ConstantExpr::getBitCast(c, iri->vtblTy->getContainedType(k));
644 iinits.push_back(c); 644 iinits.push_back(c);
645 } 645 }
671 671
672 // generate interface info initializer 672 // generate interface info initializer
673 std::vector<llvm::Constant*> infoInits; 673 std::vector<llvm::Constant*> infoInits;
674 674
675 // classinfo 675 // classinfo
676 assert(gIR->irDsymbol[id].irStruct->classInfo); 676 assert(id->ir.irStruct->classInfo);
677 llvm::Constant* c = gIR->irDsymbol[id].irStruct->classInfo; 677 llvm::Constant* c = id->ir.irStruct->classInfo;
678 infoInits.push_back(c); 678 infoInits.push_back(c);
679 679
680 // vtbl 680 // vtbl
681 const llvm::Type* byteptrptrty = getPtrToType(getPtrToType(llvm::Type::Int8Ty)); 681 const llvm::Type* byteptrptrty = getPtrToType(getPtrToType(llvm::Type::Int8Ty));
682 c = DtoConstSlice(DtoConstSize_t(0), getNullPtr(byteptrptrty)); 682 c = DtoConstSlice(DtoConstSize_t(0), getNullPtr(byteptrptrty));
696 696
697 ////////////////////////////////////////////////////////////////////////////////////////// 697 //////////////////////////////////////////////////////////////////////////////////////////
698 698
699 void DtoDefineClass(ClassDeclaration* cd) 699 void DtoDefineClass(ClassDeclaration* cd)
700 { 700 {
701 if (gIR->irDsymbol[cd].defined) return; 701 if (cd->ir.defined) return;
702 gIR->irDsymbol[cd].defined = true; 702 cd->ir.defined = true;
703 703
704 Logger::println("DtoDefineClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars()); 704 Logger::println("DtoDefineClass(%s): %s", cd->toPrettyChars(), cd->loc.toChars());
705 LOG_SCOPE; 705 LOG_SCOPE;
706 706
707 // get the struct (class) type 707 // get the struct (class) type
711 if (cd->getModule() == gIR->dmodule || DtoIsTemplateInstance(cd)) { 711 if (cd->getModule() == gIR->dmodule || DtoIsTemplateInstance(cd)) {
712 // interfaces don't have initializers 712 // interfaces don't have initializers
713 // neither do abstract classes 713 // neither do abstract classes
714 if (!cd->isInterfaceDeclaration() && !cd->isAbstract()) 714 if (!cd->isInterfaceDeclaration() && !cd->isAbstract())
715 { 715 {
716 gIR->irDsymbol[cd].irStruct->init->setInitializer(gIR->irDsymbol[cd].irStruct->constInit); 716 cd->ir.irStruct->init->setInitializer(cd->ir.irStruct->constInit);
717 gIR->irDsymbol[cd].irStruct->vtbl->setInitializer(gIR->irDsymbol[cd].irStruct->constVtbl); 717 cd->ir.irStruct->vtbl->setInitializer(cd->ir.irStruct->constVtbl);
718 718
719 // initialize interface vtables 719 // initialize interface vtables
720 IrStruct* irstruct = gIR->irDsymbol[cd].irStruct; 720 IrStruct* irstruct = cd->ir.irStruct;
721 std::vector<llvm::Constant*> infoInits; 721 std::vector<llvm::Constant*> infoInits;
722 for (IrStruct::InterfaceVectorIter i=irstruct->interfaceVec.begin(); i!=irstruct->interfaceVec.end(); ++i) 722 for (IrStruct::InterfaceVectorIter i=irstruct->interfaceVec.begin(); i!=irstruct->interfaceVec.end(); ++i)
723 { 723 {
724 IrInterface* iri = *i; 724 IrInterface* iri = *i;
725 iri->vtbl->setInitializer(iri->vtblInit); 725 iri->vtbl->setInitializer(iri->vtblInit);
753 } 753 }
754 else 754 else
755 { 755 {
756 llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_newclass"); 756 llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, "_d_newclass");
757 std::vector<llvm::Value*> args; 757 std::vector<llvm::Value*> args;
758 args.push_back(gIR->irDsymbol[tc->sym].irStruct->classInfo); 758 args.push_back(tc->sym->ir.irStruct->classInfo);
759 mem = gIR->ir->CreateCall(fn, args.begin(), args.end(), "newclass_gc_alloc"); 759 mem = gIR->ir->CreateCall(fn, args.begin(), args.end(), "newclass_gc_alloc");
760 mem = DtoBitCast(mem, DtoType(tc), "newclass_gc"); 760 mem = DtoBitCast(mem, DtoType(tc), "newclass_gc");
761 } 761 }
762 762
763 // init 763 // init
767 if (newexp->thisexp) 767 if (newexp->thisexp)
768 { 768 {
769 Logger::println("Resolving outer class"); 769 Logger::println("Resolving outer class");
770 LOG_SCOPE; 770 LOG_SCOPE;
771 DValue* thisval = newexp->thisexp->toElem(gIR); 771 DValue* thisval = newexp->thisexp->toElem(gIR);
772 size_t idx = 2 + gIR->irDsymbol[tc->sym->vthis].irField->index; 772 size_t idx = 2 + tc->sym->vthis->ir.irField->index;
773 llvm::Value* src = thisval->getRVal(); 773 llvm::Value* src = thisval->getRVal();
774 llvm::Value* dst = DtoGEPi(mem,0,idx,"tmp"); 774 llvm::Value* dst = DtoGEPi(mem,0,idx,"tmp");
775 Logger::cout() << "dst: " << *dst << "\nsrc: " << *src << '\n'; 775 Logger::cout() << "dst: " << *dst << "\nsrc: " << *src << '\n';
776 DtoStore(src, dst); 776 DtoStore(src, dst);
777 } 777 }
779 else if (tc->sym->isNested()) 779 else if (tc->sym->isNested())
780 { 780 {
781 Logger::println("Resolving nested context"); 781 Logger::println("Resolving nested context");
782 LOG_SCOPE; 782 LOG_SCOPE;
783 size_t idx = 2; 783 size_t idx = 2;
784 //idx += gIR->irDsymbol[tc->sym].irStruct->interfaces.size(); 784 //idx += tc->sym->ir.irStruct->interfaces.size();
785 llvm::Value* nest = gIR->irDsymbol[gIR->func()->decl].irFunc->nestedVar; 785 llvm::Value* nest = gIR->func()->decl->ir.irFunc->nestedVar;
786 if (!nest) 786 if (!nest)
787 nest = gIR->irDsymbol[gIR->func()->decl].irFunc->thisVar; 787 nest = gIR->func()->decl->ir.irFunc->thisVar;
788 assert(nest); 788 assert(nest);
789 llvm::Value* gep = DtoGEPi(mem,0,idx,"tmp"); 789 llvm::Value* gep = DtoGEPi(mem,0,idx,"tmp");
790 nest = DtoBitCast(nest, gep->getType()->getContainedType(0)); 790 nest = DtoBitCast(nest, gep->getType()->getContainedType(0));
791 DtoStore(nest, gep); 791 DtoStore(nest, gep);
792 } 792 }
805 ////////////////////////////////////////////////////////////////////////////////////////// 805 //////////////////////////////////////////////////////////////////////////////////////////
806 806
807 void DtoInitClass(TypeClass* tc, llvm::Value* dst) 807 void DtoInitClass(TypeClass* tc, llvm::Value* dst)
808 { 808 {
809 size_t presz = 2*getABITypeSize(DtoSize_t()); 809 size_t presz = 2*getABITypeSize(DtoSize_t());
810 uint64_t n = getABITypeSize(gIR->irType[tc].type->get()) - presz; 810 uint64_t n = getABITypeSize(tc->ir.type->get()) - presz;
811 811
812 // set vtable field seperately, this might give better optimization 812 // set vtable field seperately, this might give better optimization
813 assert(gIR->irDsymbol[tc->sym].irStruct->vtbl); 813 assert(tc->sym->ir.irStruct->vtbl);
814 DtoStore(gIR->irDsymbol[tc->sym].irStruct->vtbl, DtoGEPi(dst,0,0,"vtbl")); 814 DtoStore(tc->sym->ir.irStruct->vtbl, DtoGEPi(dst,0,0,"vtbl"));
815 815
816 // monitor always defaults to zero 816 // monitor always defaults to zero
817 llvm::Value* tmp = DtoGEPi(dst,0,1,"monitor"); 817 llvm::Value* tmp = DtoGEPi(dst,0,1,"monitor");
818 DtoStore(llvm::Constant::getNullValue(tmp->getType()->getContainedType(0)), tmp); 818 DtoStore(llvm::Constant::getNullValue(tmp->getType()->getContainedType(0)), tmp);
819 819
820 // done? 820 // done?
821 if (n == 0) 821 if (n == 0)
822 return; 822 return;
823 823
824 // copy the rest from the static initializer 824 // copy the rest from the static initializer
825 assert(gIR->irDsymbol[tc->sym].irStruct->init); 825 assert(tc->sym->ir.irStruct->init);
826 assert(dst->getType() == gIR->irDsymbol[tc->sym].irStruct->init->getType()); 826 assert(dst->getType() == tc->sym->ir.irStruct->init->getType());
827 827
828 const llvm::Type* arrty = getPtrToType(llvm::Type::Int8Ty); 828 const llvm::Type* arrty = getPtrToType(llvm::Type::Int8Ty);
829 829
830 llvm::Value* dstarr = DtoGEPi(dst,0,2,"tmp"); 830 llvm::Value* dstarr = DtoGEPi(dst,0,2,"tmp");
831 dstarr = DtoBitCast(dstarr, arrty); 831 dstarr = DtoBitCast(dstarr, arrty);
832 832
833 llvm::Value* srcarr = DtoGEPi(gIR->irDsymbol[tc->sym].irStruct->init,0,2,"tmp"); 833 llvm::Value* srcarr = DtoGEPi(tc->sym->ir.irStruct->init,0,2,"tmp");
834 srcarr = DtoBitCast(srcarr, arrty); 834 srcarr = DtoBitCast(srcarr, arrty);
835 835
836 llvm::Function* fn = LLVM_DeclareMemCpy32(); 836 llvm::Function* fn = LLVM_DeclareMemCpy32();
837 std::vector<llvm::Value*> llargs; 837 std::vector<llvm::Value*> llargs;
838 llargs.resize(4); 838 llargs.resize(4);
851 Logger::println("Calling constructor"); 851 Logger::println("Calling constructor");
852 LOG_SCOPE; 852 LOG_SCOPE;
853 853
854 assert(ctor); 854 assert(ctor);
855 DtoForceDeclareDsymbol(ctor); 855 DtoForceDeclareDsymbol(ctor);
856 llvm::Function* fn = gIR->irDsymbol[ctor].irFunc->func; 856 llvm::Function* fn = ctor->ir.irFunc->func;
857 TypeFunction* tf = (TypeFunction*)DtoDType(ctor->type); 857 TypeFunction* tf = (TypeFunction*)DtoDType(ctor->type);
858 858
859 std::vector<llvm::Value*> ctorargs; 859 std::vector<llvm::Value*> ctorargs;
860 ctorargs.push_back(mem); 860 ctorargs.push_back(mem);
861 for (size_t i=0; i<arguments->dim; ++i) 861 for (size_t i=0; i<arguments->dim; ++i)
881 { 881 {
882 Array* arr = &tc->sym->dtors; 882 Array* arr = &tc->sym->dtors;
883 for (size_t i=0; i<arr->dim; i++) 883 for (size_t i=0; i<arr->dim; i++)
884 { 884 {
885 FuncDeclaration* fd = (FuncDeclaration*)arr->data[i]; 885 FuncDeclaration* fd = (FuncDeclaration*)arr->data[i];
886 assert(gIR->irDsymbol[fd].irFunc->func); 886 assert(fd->ir.irFunc->func);
887 new llvm::CallInst(gIR->irDsymbol[fd].irFunc->func, instance, "", gIR->scopebb()); 887 new llvm::CallInst(fd->ir.irFunc->func, instance, "", gIR->scopebb());
888 } 888 }
889 } 889 }
890 890
891 ////////////////////////////////////////////////////////////////////////////////////////// 891 //////////////////////////////////////////////////////////////////////////////////////////
892 892
961 assert(funcTy->getParamType(0) == tmp->getType()); 961 assert(funcTy->getParamType(0) == tmp->getType());
962 962
963 // ClassInfo c 963 // ClassInfo c
964 TypeClass* to = (TypeClass*)DtoDType(_to); 964 TypeClass* to = (TypeClass*)DtoDType(_to);
965 DtoForceDeclareDsymbol(to->sym); 965 DtoForceDeclareDsymbol(to->sym);
966 assert(gIR->irDsymbol[to->sym].irStruct->classInfo); 966 assert(to->sym->ir.irStruct->classInfo);
967 tmp = gIR->irDsymbol[to->sym].irStruct->classInfo; 967 tmp = to->sym->ir.irStruct->classInfo;
968 // unfortunately this is needed as the implementation of object differs somehow from the declaration 968 // unfortunately this is needed as the implementation of object differs somehow from the declaration
969 // this could happen in user code as well :/ 969 // this could happen in user code as well :/
970 tmp = DtoBitCast(tmp, funcTy->getParamType(1)); 970 tmp = DtoBitCast(tmp, funcTy->getParamType(1));
971 args.push_back(tmp); 971 args.push_back(tmp);
972 assert(funcTy->getParamType(1) == tmp->getType()); 972 assert(funcTy->getParamType(1) == tmp->getType());
1027 args.push_back(tmp); 1027 args.push_back(tmp);
1028 1028
1029 // ClassInfo c 1029 // ClassInfo c
1030 TypeClass* to = (TypeClass*)DtoDType(_to); 1030 TypeClass* to = (TypeClass*)DtoDType(_to);
1031 DtoForceDeclareDsymbol(to->sym); 1031 DtoForceDeclareDsymbol(to->sym);
1032 assert(gIR->irDsymbol[to->sym].irStruct->classInfo); 1032 assert(to->sym->ir.irStruct->classInfo);
1033 tmp = gIR->irDsymbol[to->sym].irStruct->classInfo; 1033 tmp = to->sym->ir.irStruct->classInfo;
1034 // unfortunately this is needed as the implementation of object differs somehow from the declaration 1034 // unfortunately this is needed as the implementation of object differs somehow from the declaration
1035 // this could happen in user code as well :/ 1035 // this could happen in user code as well :/
1036 tmp = DtoBitCast(tmp, funcTy->getParamType(1)); 1036 tmp = DtoBitCast(tmp, funcTy->getParamType(1));
1037 args.push_back(tmp); 1037 args.push_back(tmp);
1038 1038
1093 if (idxs.empty()) 1093 if (idxs.empty())
1094 idxs.push_back(0); 1094 idxs.push_back(0);
1095 1095
1096 const llvm::Type* st = DtoType(cd->type); 1096 const llvm::Type* st = DtoType(cd->type);
1097 if (ptr->getType() != st) { 1097 if (ptr->getType() != st) {
1098 //assert(gIR->irDsymbol[cd].irStruct->hasUnions); 1098 //assert(cd->ir.irStruct->hasUnions);
1099 ptr = gIR->ir->CreateBitCast(ptr, st, "tmp"); 1099 ptr = gIR->ir->CreateBitCast(ptr, st, "tmp");
1100 } 1100 }
1101 1101
1102 const llvm::Type* llt = getPtrToType(DtoType(t)); 1102 const llvm::Type* llt = getPtrToType(DtoType(t));
1103 unsigned dataoffset = 2; 1103 unsigned dataoffset = 2;
1104 1104
1105 IrStruct* irstruct = gIR->irDsymbol[cd].irStruct; 1105 IrStruct* irstruct = cd->ir.irStruct;
1106 for (IrStruct::OffsetMap::iterator i=irstruct->offsets.begin(); i!=irstruct->offsets.end(); ++i) { 1106 for (IrStruct::OffsetMap::iterator i=irstruct->offsets.begin(); i!=irstruct->offsets.end(); ++i) {
1107 //for (unsigned i=0; i<cd->fields.dim; ++i) { 1107 //for (unsigned i=0; i<cd->fields.dim; ++i) {
1108 //VarDeclaration* vd = (VarDeclaration*)cd->fields.data[i]; 1108 //VarDeclaration* vd = (VarDeclaration*)cd->fields.data[i];
1109 VarDeclaration* vd = i->second.var; 1109 VarDeclaration* vd = i->second.var;
1110 assert(vd); 1110 assert(vd);
1111 Type* vdtype = DtoDType(vd->type); 1111 Type* vdtype = DtoDType(vd->type);
1112 //Logger::println("found %u type %s", vd->offset, vdtype->toChars()); 1112 //Logger::println("found %u type %s", vd->offset, vdtype->toChars());
1113 assert(gIR->irDsymbol[vd].irField->index >= 0); 1113 assert(vd->ir.irField->index >= 0);
1114 if (os == vd->offset && vdtype == t) { 1114 if (os == vd->offset && vdtype == t) {
1115 Logger::println("found %s %s", vdtype->toChars(), vd->toChars()); 1115 Logger::println("found %s %s", vdtype->toChars(), vd->toChars());
1116 idxs.push_back(gIR->irDsymbol[vd].irField->index + dataoffset); 1116 idxs.push_back(vd->ir.irField->index + dataoffset);
1117 //Logger::cout() << "indexing: " << *ptr << '\n'; 1117 //Logger::cout() << "indexing: " << *ptr << '\n';
1118 ptr = DtoGEP(ptr, idxs, "tmp"); 1118 ptr = DtoGEP(ptr, idxs, "tmp");
1119 if (ptr->getType() != llt) 1119 if (ptr->getType() != llt)
1120 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp"); 1120 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
1121 //Logger::cout() << "indexing: " << *ptr << '\n'; 1121 //Logger::cout() << "indexing: " << *ptr << '\n';
1122 if (gIR->irDsymbol[vd].irField->indexOffset) 1122 if (vd->ir.irField->indexOffset)
1123 ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(gIR->irDsymbol[vd].irField->indexOffset), "tmp", gIR->scopebb()); 1123 ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
1124 //Logger::cout() << "indexing: " << *ptr << '\n'; 1124 //Logger::cout() << "indexing: " << *ptr << '\n';
1125 return ptr; 1125 return ptr;
1126 } 1126 }
1127 else if (vdtype->ty == Tstruct && (vd->offset + vdtype->size()) > os) { 1127 else if (vdtype->ty == Tstruct && (vd->offset + vdtype->size()) > os) {
1128 TypeStruct* ts = (TypeStruct*)vdtype; 1128 TypeStruct* ts = (TypeStruct*)vdtype;
1129 StructDeclaration* ssd = ts->sym; 1129 StructDeclaration* ssd = ts->sym;
1130 idxs.push_back(gIR->irDsymbol[vd].irField->index + dataoffset); 1130 idxs.push_back(vd->ir.irField->index + dataoffset);
1131 if (gIR->irDsymbol[vd].irField->indexOffset) { 1131 if (vd->ir.irField->indexOffset) {
1132 Logger::println("has union field offset"); 1132 Logger::println("has union field offset");
1133 ptr = DtoGEP(ptr, idxs, "tmp"); 1133 ptr = DtoGEP(ptr, idxs, "tmp");
1134 if (ptr->getType() != llt) 1134 if (ptr->getType() != llt)
1135 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp"); 1135 ptr = gIR->ir->CreateBitCast(ptr, llt, "tmp");
1136 ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(gIR->irDsymbol[vd].irField->indexOffset), "tmp", gIR->scopebb()); 1136 ptr = new llvm::GetElementPtrInst(ptr, DtoConstUint(vd->ir.irField->indexOffset), "tmp", gIR->scopebb());
1137 std::vector<unsigned> tmp; 1137 std::vector<unsigned> tmp;
1138 return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp); 1138 return DtoIndexStruct(ptr, ssd, t, os-vd->offset, tmp);
1139 } 1139 }
1140 else { 1140 else {
1141 const llvm::Type* sty = getPtrToType(DtoType(vd->type)); 1141 const llvm::Type* sty = getPtrToType(DtoType(vd->type));
1184 1184
1185 ////////////////////////////////////////////////////////////////////////////////////////// 1185 //////////////////////////////////////////////////////////////////////////////////////////
1186 1186
1187 void DtoDeclareClassInfo(ClassDeclaration* cd) 1187 void DtoDeclareClassInfo(ClassDeclaration* cd)
1188 { 1188 {
1189 if (gIR->irDsymbol[cd].irStruct->classDeclared) return; 1189 if (cd->ir.irStruct->classDeclared) return;
1190 gIR->irDsymbol[cd].irStruct->classDeclared = true; 1190 cd->ir.irStruct->classDeclared = true;
1191 1191
1192 Logger::println("DtoDeclareClassInfo(%s)", cd->toChars()); 1192 Logger::println("DtoDeclareClassInfo(%s)", cd->toChars());
1193 LOG_SCOPE; 1193 LOG_SCOPE;
1194 1194
1195 ClassDeclaration* cinfo = ClassDeclaration::classinfo; 1195 ClassDeclaration* cinfo = ClassDeclaration::classinfo;
1200 if (!cd->isInterfaceDeclaration()) 1200 if (!cd->isInterfaceDeclaration())
1201 gname.append("7__ClassZ"); 1201 gname.append("7__ClassZ");
1202 else 1202 else
1203 gname.append("11__InterfaceZ"); 1203 gname.append("11__InterfaceZ");
1204 1204
1205 const llvm::Type* st = gIR->irType[cinfo->type].type->get(); 1205 const llvm::Type* st = cinfo->type->ir.type->get();
1206 1206
1207 gIR->irDsymbol[cd].irStruct->classInfo = new llvm::GlobalVariable(st, true, DtoLinkage(cd), NULL, gname, gIR->module); 1207 cd->ir.irStruct->classInfo = new llvm::GlobalVariable(st, true, DtoLinkage(cd), NULL, gname, gIR->module);
1208 } 1208 }
1209 1209
1210 static llvm::Constant* build_offti_entry(VarDeclaration* vd) 1210 static llvm::Constant* build_offti_entry(VarDeclaration* vd)
1211 { 1211 {
1212 std::vector<const llvm::Type*> types; 1212 std::vector<const llvm::Type*> types;
1223 inits.push_back(DtoConstSize_t(offset)); 1223 inits.push_back(DtoConstSize_t(offset));
1224 1224
1225 vd->type->getTypeInfo(NULL); 1225 vd->type->getTypeInfo(NULL);
1226 assert(vd->type->vtinfo); 1226 assert(vd->type->vtinfo);
1227 DtoForceDeclareDsymbol(vd->type->vtinfo); 1227 DtoForceDeclareDsymbol(vd->type->vtinfo);
1228 llvm::Constant* c = isaConstant(gIR->irDsymbol[vd->type->vtinfo].getIrValue()); 1228 llvm::Constant* c = isaConstant(vd->type->vtinfo->ir.getIrValue());
1229 1229
1230 const llvm::Type* tiTy = getPtrToType(gIR->irType[Type::typeinfo->type].type->get()); 1230 const llvm::Type* tiTy = getPtrToType(Type::typeinfo->type->ir.type->get());
1231 //Logger::cout() << "tiTy = " << *tiTy << '\n'; 1231 //Logger::cout() << "tiTy = " << *tiTy << '\n';
1232 1232
1233 types.push_back(tiTy); 1233 types.push_back(tiTy);
1234 inits.push_back(llvm::ConstantExpr::getBitCast(c, tiTy)); 1234 inits.push_back(llvm::ConstantExpr::getBitCast(c, tiTy));
1235 1235
1266 1266
1267 if (ninits > 0) { 1267 if (ninits > 0) {
1268 // OffsetTypeInfo type 1268 // OffsetTypeInfo type
1269 std::vector<const llvm::Type*> elemtypes; 1269 std::vector<const llvm::Type*> elemtypes;
1270 elemtypes.push_back(DtoSize_t()); 1270 elemtypes.push_back(DtoSize_t());
1271 const llvm::Type* tiTy = getPtrToType(gIR->irType[Type::typeinfo->type].type->get()); 1271 const llvm::Type* tiTy = getPtrToType(Type::typeinfo->type->ir.type->get());
1272 elemtypes.push_back(tiTy); 1272 elemtypes.push_back(tiTy);
1273 const llvm::StructType* sTy = llvm::StructType::get(elemtypes); 1273 const llvm::StructType* sTy = llvm::StructType::get(elemtypes);
1274 1274
1275 // array type 1275 // array type
1276 const llvm::ArrayType* arrTy = llvm::ArrayType::get(sTy, ninits); 1276 const llvm::ArrayType* arrTy = llvm::ArrayType::get(sTy, ninits);
1291 1291
1292 static llvm::Constant* build_class_dtor(ClassDeclaration* cd) 1292 static llvm::Constant* build_class_dtor(ClassDeclaration* cd)
1293 { 1293 {
1294 // construct the function 1294 // construct the function
1295 std::vector<const llvm::Type*> paramTypes; 1295 std::vector<const llvm::Type*> paramTypes;
1296 paramTypes.push_back(getPtrToType(gIR->irType[cd->type].type->get())); 1296 paramTypes.push_back(getPtrToType(cd->type->ir.type->get()));
1297 1297
1298 const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy, paramTypes, false); 1298 const llvm::FunctionType* fnTy = llvm::FunctionType::get(llvm::Type::VoidTy, paramTypes, false);
1299 1299
1300 if (cd->dtors.dim == 0) { 1300 if (cd->dtors.dim == 0) {
1301 return llvm::ConstantPointerNull::get(getPtrToType(llvm::Type::Int8Ty)); 1301 return llvm::ConstantPointerNull::get(getPtrToType(llvm::Type::Int8Ty));
1302 } 1302 }
1303 else if (cd->dtors.dim == 1) { 1303 else if (cd->dtors.dim == 1) {
1304 DtorDeclaration *d = (DtorDeclaration *)cd->dtors.data[0]; 1304 DtorDeclaration *d = (DtorDeclaration *)cd->dtors.data[0];
1305 DtoForceDeclareDsymbol(d); 1305 DtoForceDeclareDsymbol(d);
1306 assert(gIR->irDsymbol[d].irFunc->func); 1306 assert(d->ir.irFunc->func);
1307 return llvm::ConstantExpr::getBitCast(isaConstant(gIR->irDsymbol[d].irFunc->func), getPtrToType(llvm::Type::Int8Ty)); 1307 return llvm::ConstantExpr::getBitCast(isaConstant(d->ir.irFunc->func), getPtrToType(llvm::Type::Int8Ty));
1308 } 1308 }
1309 1309
1310 std::string gname("_D"); 1310 std::string gname("_D");
1311 gname.append(cd->mangle()); 1311 gname.append(cd->mangle());
1312 gname.append("12__destructorMFZv"); 1312 gname.append("12__destructorMFZv");
1320 1320
1321 for (size_t i = 0; i < cd->dtors.dim; i++) 1321 for (size_t i = 0; i < cd->dtors.dim; i++)
1322 { 1322 {
1323 DtorDeclaration *d = (DtorDeclaration *)cd->dtors.data[i]; 1323 DtorDeclaration *d = (DtorDeclaration *)cd->dtors.data[i];
1324 DtoForceDeclareDsymbol(d); 1324 DtoForceDeclareDsymbol(d);
1325 assert(gIR->irDsymbol[d].irFunc->func); 1325 assert(d->ir.irFunc->func);
1326 builder.CreateCall(gIR->irDsymbol[d].irFunc->func, thisptr); 1326 builder.CreateCall(d->ir.irFunc->func, thisptr);
1327 } 1327 }
1328 builder.CreateRetVoid(); 1328 builder.CreateRetVoid();
1329 1329
1330 return llvm::ConstantExpr::getBitCast(func, getPtrToType(llvm::Type::Int8Ty)); 1330 return llvm::ConstantExpr::getBitCast(func, getPtrToType(llvm::Type::Int8Ty));
1331 } 1331 }
1376 // void *deallocator; 1376 // void *deallocator;
1377 // OffsetTypeInfo[] offTi; 1377 // OffsetTypeInfo[] offTi;
1378 // void *defaultConstructor; 1378 // void *defaultConstructor;
1379 // } 1379 // }
1380 1380
1381 if (gIR->irDsymbol[cd].irStruct->classDefined) return; 1381 if (cd->ir.irStruct->classDefined) return;
1382 gIR->irDsymbol[cd].irStruct->classDefined = true; 1382 cd->ir.irStruct->classDefined = true;
1383 1383
1384 Logger::println("DtoDefineClassInfo(%s)", cd->toChars()); 1384 Logger::println("DtoDefineClassInfo(%s)", cd->toChars());
1385 LOG_SCOPE; 1385 LOG_SCOPE;
1386 1386
1387 assert(cd->type->ty == Tclass); 1387 assert(cd->type->ty == Tclass);
1388 assert(gIR->irDsymbol[cd].irStruct->classInfo); 1388 assert(cd->ir.irStruct->classInfo);
1389 1389
1390 TypeClass* cdty = (TypeClass*)cd->type; 1390 TypeClass* cdty = (TypeClass*)cd->type;
1391 if (!cd->isInterfaceDeclaration() && !cd->isAbstract()) { 1391 if (!cd->isInterfaceDeclaration() && !cd->isAbstract()) {
1392 assert(gIR->irDsymbol[cd].irStruct->init); 1392 assert(cd->ir.irStruct->init);
1393 assert(gIR->irDsymbol[cd].irStruct->constInit); 1393 assert(cd->ir.irStruct->constInit);
1394 assert(gIR->irDsymbol[cd].irStruct->vtbl); 1394 assert(cd->ir.irStruct->vtbl);
1395 assert(gIR->irDsymbol[cd].irStruct->constVtbl); 1395 assert(cd->ir.irStruct->constVtbl);
1396 } 1396 }
1397 1397
1398 // holds the list of initializers for llvm 1398 // holds the list of initializers for llvm
1399 std::vector<llvm::Constant*> inits; 1399 std::vector<llvm::Constant*> inits;
1400 1400
1401 ClassDeclaration* cinfo = ClassDeclaration::classinfo; 1401 ClassDeclaration* cinfo = ClassDeclaration::classinfo;
1402 DtoForceConstInitDsymbol(cinfo); 1402 DtoForceConstInitDsymbol(cinfo);
1403 assert(gIR->irDsymbol[cinfo].irStruct->constInit); 1403 assert(cinfo->ir.irStruct->constInit);
1404 1404
1405 llvm::Constant* c; 1405 llvm::Constant* c;
1406 1406
1407 // own vtable 1407 // own vtable
1408 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(0); 1408 c = cinfo->ir.irStruct->constInit->getOperand(0);
1409 assert(c); 1409 assert(c);
1410 inits.push_back(c); 1410 inits.push_back(c);
1411 1411
1412 // monitor 1412 // monitor
1413 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(1); 1413 c = cinfo->ir.irStruct->constInit->getOperand(1);
1414 inits.push_back(c); 1414 inits.push_back(c);
1415 1415
1416 // byte[] init 1416 // byte[] init
1417 const llvm::Type* byteptrty = getPtrToType(llvm::Type::Int8Ty); 1417 const llvm::Type* byteptrty = getPtrToType(llvm::Type::Int8Ty);
1418 if (cd->isInterfaceDeclaration() || cd->isAbstract()) { 1418 if (cd->isInterfaceDeclaration() || cd->isAbstract()) {
1419 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(2); 1419 c = cinfo->ir.irStruct->constInit->getOperand(2);
1420 } 1420 }
1421 else { 1421 else {
1422 c = llvm::ConstantExpr::getBitCast(gIR->irDsymbol[cd].irStruct->init, byteptrty); 1422 c = llvm::ConstantExpr::getBitCast(cd->ir.irStruct->init, byteptrty);
1423 assert(!gIR->irDsymbol[cd].irStruct->constInit->getType()->isAbstract()); 1423 assert(!cd->ir.irStruct->constInit->getType()->isAbstract());
1424 size_t initsz = getABITypeSize(gIR->irDsymbol[cd].irStruct->constInit->getType()); 1424 size_t initsz = getABITypeSize(cd->ir.irStruct->constInit->getType());
1425 c = DtoConstSlice(DtoConstSize_t(initsz), c); 1425 c = DtoConstSlice(DtoConstSize_t(initsz), c);
1426 } 1426 }
1427 inits.push_back(c); 1427 inits.push_back(c);
1428 1428
1429 // class name 1429 // class name
1438 c = DtoConstString(name); 1438 c = DtoConstString(name);
1439 inits.push_back(c); 1439 inits.push_back(c);
1440 1440
1441 // vtbl array 1441 // vtbl array
1442 if (cd->isInterfaceDeclaration() || cd->isAbstract()) { 1442 if (cd->isInterfaceDeclaration() || cd->isAbstract()) {
1443 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(4); 1443 c = cinfo->ir.irStruct->constInit->getOperand(4);
1444 } 1444 }
1445 else { 1445 else {
1446 const llvm::Type* byteptrptrty = getPtrToType(byteptrty); 1446 const llvm::Type* byteptrptrty = getPtrToType(byteptrty);
1447 assert(!gIR->irDsymbol[cd].irStruct->vtbl->getType()->isAbstract()); 1447 assert(!cd->ir.irStruct->vtbl->getType()->isAbstract());
1448 c = llvm::ConstantExpr::getBitCast(gIR->irDsymbol[cd].irStruct->vtbl, byteptrptrty); 1448 c = llvm::ConstantExpr::getBitCast(cd->ir.irStruct->vtbl, byteptrptrty);
1449 assert(!gIR->irDsymbol[cd].irStruct->constVtbl->getType()->isAbstract()); 1449 assert(!cd->ir.irStruct->constVtbl->getType()->isAbstract());
1450 size_t vtblsz = gIR->irDsymbol[cd].irStruct->constVtbl->getType()->getNumElements(); 1450 size_t vtblsz = cd->ir.irStruct->constVtbl->getType()->getNumElements();
1451 c = DtoConstSlice(DtoConstSize_t(vtblsz), c); 1451 c = DtoConstSlice(DtoConstSize_t(vtblsz), c);
1452 } 1452 }
1453 inits.push_back(c); 1453 inits.push_back(c);
1454 1454
1455 // interfaces array 1455 // interfaces array
1456 IrStruct* irstruct = gIR->irDsymbol[cd].irStruct; 1456 IrStruct* irstruct = cd->ir.irStruct;
1457 if (cd->isInterfaceDeclaration() || !irstruct->interfaceInfos || cd->isAbstract()) { 1457 if (cd->isInterfaceDeclaration() || !irstruct->interfaceInfos || cd->isAbstract()) {
1458 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(5); 1458 c = cinfo->ir.irStruct->constInit->getOperand(5);
1459 } 1459 }
1460 else { 1460 else {
1461 const llvm::Type* t = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(5)->getType()->getContainedType(1); 1461 const llvm::Type* t = cinfo->ir.irStruct->constInit->getOperand(5)->getType()->getContainedType(1);
1462 c = llvm::ConstantExpr::getBitCast(irstruct->interfaceInfos, t); 1462 c = llvm::ConstantExpr::getBitCast(irstruct->interfaceInfos, t);
1463 size_t iisz = irstruct->interfaceInfosTy->getNumElements(); 1463 size_t iisz = irstruct->interfaceInfosTy->getNumElements();
1464 c = DtoConstSlice(DtoConstSize_t(iisz), c); 1464 c = DtoConstSlice(DtoConstSize_t(iisz), c);
1465 } 1465 }
1466 inits.push_back(c); 1466 inits.push_back(c);
1467 1467
1468 // base classinfo 1468 // base classinfo
1469 if (cd->baseClass && !cd->isInterfaceDeclaration() && !cd->isAbstract()) { 1469 if (cd->baseClass && !cd->isInterfaceDeclaration() && !cd->isAbstract()) {
1470 DtoDeclareClassInfo(cd->baseClass); 1470 DtoDeclareClassInfo(cd->baseClass);
1471 c = gIR->irDsymbol[cd->baseClass].irStruct->classInfo; 1471 c = cd->baseClass->ir.irStruct->classInfo;
1472 assert(c); 1472 assert(c);
1473 inits.push_back(c); 1473 inits.push_back(c);
1474 } 1474 }
1475 else { 1475 else {
1476 // null 1476 // null
1477 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(6); 1477 c = cinfo->ir.irStruct->constInit->getOperand(6);
1478 inits.push_back(c); 1478 inits.push_back(c);
1479 } 1479 }
1480 1480
1481 // destructor 1481 // destructor
1482 if (cd->isInterfaceDeclaration() || cd->isAbstract()) { 1482 if (cd->isInterfaceDeclaration() || cd->isAbstract()) {
1483 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(7); 1483 c = cinfo->ir.irStruct->constInit->getOperand(7);
1484 } 1484 }
1485 else { 1485 else {
1486 c = build_class_dtor(cd); 1486 c = build_class_dtor(cd);
1487 } 1487 }
1488 inits.push_back(c); 1488 inits.push_back(c);
1489 1489
1490 // invariant 1490 // invariant
1491 // TODO 1491 // TODO
1492 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(8); 1492 c = cinfo->ir.irStruct->constInit->getOperand(8);
1493 inits.push_back(c); 1493 inits.push_back(c);
1494 1494
1495 // uint flags 1495 // uint flags
1496 if (cd->isInterfaceDeclaration() || cd->isAbstract()) { 1496 if (cd->isInterfaceDeclaration() || cd->isAbstract()) {
1497 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(9); 1497 c = cinfo->ir.irStruct->constInit->getOperand(9);
1498 } 1498 }
1499 else { 1499 else {
1500 uint flags = build_classinfo_flags(cd); 1500 uint flags = build_classinfo_flags(cd);
1501 c = DtoConstUint(flags); 1501 c = DtoConstUint(flags);
1502 } 1502 }
1503 inits.push_back(c); 1503 inits.push_back(c);
1504 1504
1505 // allocator 1505 // allocator
1506 // TODO 1506 // TODO
1507 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(10); 1507 c = cinfo->ir.irStruct->constInit->getOperand(10);
1508 inits.push_back(c); 1508 inits.push_back(c);
1509 1509
1510 // offset typeinfo 1510 // offset typeinfo
1511 if (cd->isInterfaceDeclaration() || cd->isAbstract()) { 1511 if (cd->isInterfaceDeclaration() || cd->isAbstract()) {
1512 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(11); 1512 c = cinfo->ir.irStruct->constInit->getOperand(11);
1513 } 1513 }
1514 else { 1514 else {
1515 c = build_offti_array(cd, gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(11)); 1515 c = build_offti_array(cd, cinfo->ir.irStruct->constInit->getOperand(11));
1516 } 1516 }
1517 inits.push_back(c); 1517 inits.push_back(c);
1518 1518
1519 // default constructor 1519 // default constructor
1520 if (cd->defaultCtor && !cd->isInterfaceDeclaration() && !cd->isAbstract()) { 1520 if (cd->defaultCtor && !cd->isInterfaceDeclaration() && !cd->isAbstract()) {
1521 DtoForceDeclareDsymbol(cd->defaultCtor); 1521 DtoForceDeclareDsymbol(cd->defaultCtor);
1522 c = isaConstant(gIR->irDsymbol[cd->defaultCtor].irFunc->func); 1522 c = isaConstant(cd->defaultCtor->ir.irFunc->func);
1523 const llvm::Type* toTy = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(12)->getType(); 1523 const llvm::Type* toTy = cinfo->ir.irStruct->constInit->getOperand(12)->getType();
1524 c = llvm::ConstantExpr::getBitCast(c, toTy); 1524 c = llvm::ConstantExpr::getBitCast(c, toTy);
1525 } 1525 }
1526 else { 1526 else {
1527 c = gIR->irDsymbol[cinfo].irStruct->constInit->getOperand(12); 1527 c = cinfo->ir.irStruct->constInit->getOperand(12);
1528 } 1528 }
1529 inits.push_back(c); 1529 inits.push_back(c);
1530 1530
1531 /*size_t n = inits.size(); 1531 /*size_t n = inits.size();
1532 for (size_t i=0; i<n; ++i) 1532 for (size_t i=0; i<n; ++i)
1533 { 1533 {
1534 Logger::cout() << "inits[" << i << "]: " << *inits[i] << '\n'; 1534 Logger::cout() << "inits[" << i << "]: " << *inits[i] << '\n';
1535 }*/ 1535 }*/
1536 1536
1537 // build the initializer 1537 // build the initializer
1538 const llvm::StructType* st = isaStruct(gIR->irDsymbol[cinfo].irStruct->constInit->getType()); 1538 const llvm::StructType* st = isaStruct(cinfo->ir.irStruct->constInit->getType());
1539 llvm::Constant* finalinit = llvm::ConstantStruct::get(st, inits); 1539 llvm::Constant* finalinit = llvm::ConstantStruct::get(st, inits);
1540 //Logger::cout() << "built the classinfo initializer:\n" << *finalinit <<'\n'; 1540 //Logger::cout() << "built the classinfo initializer:\n" << *finalinit <<'\n';
1541 1541
1542 gIR->irDsymbol[cd].irStruct->constClassInfo = finalinit; 1542 cd->ir.irStruct->constClassInfo = finalinit;
1543 gIR->irDsymbol[cd].irStruct->classInfo->setInitializer(finalinit); 1543 cd->ir.irStruct->classInfo->setInitializer(finalinit);
1544 } 1544 }