Mercurial > projects > ldc

comparison gen/toobj.cpp @ 156:ccd07d9f2ce9 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r172] moving all IR state previously stored in Dsymbol into IrDsymbol and a Dsymbol->IrDsymbol map
author ChristianK
date Thu, 01 May 2008 13:05:53 +0200
parents 7f92f477ff53
children 5c17f81fc1c1
comparison
equal deleted inserted replaced
155:7f92f477ff53 156:ccd07d9f2ce9
65 gIR = &ir; 65 gIR = &ir;
66 ir.dmodule = this; 66 ir.dmodule = this;
67 67
68 // module ir state 68 // module ir state
69 // might already exist via import, just overwrite... 69 // might already exist via import, just overwrite...
70 irModule = new IrModule(this); 70 gIR->irDsymbol[this].irModule = new IrModule(this);
71 71
72 // name the module 72 // name the module
73 std::string mname(toChars()); 73 std::string mname(toChars());
74 if (md != 0) 74 if (md != 0)
75 mname = md->toChars(); 75 mname = md->toChars();
175 if (gIR->ctors.empty()) 175 if (gIR->ctors.empty())
176 return NULL; 176 return NULL;
177 177
178 size_t n = gIR->ctors.size(); 178 size_t n = gIR->ctors.size();
179 if (n == 1) 179 if (n == 1)
180 return gIR->irFunc[gIR->ctors[0]]->func; 180 return gIR->irDsymbol[gIR->ctors[0]].irFunc->func;
181 181
182 std::string name("_D"); 182 std::string name("_D");
183 name.append(gIR->dmodule->mangle()); 183 name.append(gIR->dmodule->mangle());
184 name.append("6__ctorZ"); 184 name.append("6__ctorZ");
185 185
190 190
191 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn); 191 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
192 LLVMBuilder builder(bb); 192 LLVMBuilder builder(bb);
193 193
194 for (size_t i=0; i<n; i++) { 194 for (size_t i=0; i<n; i++) {
195 llvm::Function* f = gIR->irFunc[gIR->ctors[i]]->func; 195 llvm::Function* f = gIR->irDsymbol[gIR->ctors[i]].irFunc->func;
196 llvm::CallInst* call = builder.CreateCall(f,""); 196 llvm::CallInst* call = builder.CreateCall(f,"");
197 call->setCallingConv(llvm::CallingConv::Fast); 197 call->setCallingConv(llvm::CallingConv::Fast);
198 } 198 }
199 199
200 builder.CreateRetVoid(); 200 builder.CreateRetVoid();
208 if (gIR->dtors.empty()) 208 if (gIR->dtors.empty())
209 return NULL; 209 return NULL;
210 210
211 size_t n = gIR->dtors.size(); 211 size_t n = gIR->dtors.size();
212 if (n == 1) 212 if (n == 1)
213 return gIR->irFunc[gIR->dtors[0]]->func; 213 return gIR->irDsymbol[gIR->dtors[0]].irFunc->func;
214 214
215 std::string name("_D"); 215 std::string name("_D");
216 name.append(gIR->dmodule->mangle()); 216 name.append(gIR->dmodule->mangle());
217 name.append("6__dtorZ"); 217 name.append("6__dtorZ");
218 218
223 223
224 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn); 224 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
225 LLVMBuilder builder(bb); 225 LLVMBuilder builder(bb);
226 226
227 for (size_t i=0; i<n; i++) { 227 for (size_t i=0; i<n; i++) {
228 llvm::Function* f = gIR->irFunc[gIR->dtors[i]]->func; 228 llvm::Function* f = gIR->irDsymbol[gIR->dtors[i]].irFunc->func;
229 llvm::CallInst* call = builder.CreateCall(f,""); 229 llvm::CallInst* call = builder.CreateCall(f,"");
230 call->setCallingConv(llvm::CallingConv::Fast); 230 call->setCallingConv(llvm::CallingConv::Fast);
231 } 231 }
232 232
233 builder.CreateRetVoid(); 233 builder.CreateRetVoid();
241 if (gIR->unitTests.empty()) 241 if (gIR->unitTests.empty())
242 return NULL; 242 return NULL;
243 243
244 size_t n = gIR->unitTests.size(); 244 size_t n = gIR->unitTests.size();
245 if (n == 1) 245 if (n == 1)
246 return gIR->irFunc[gIR->unitTests[0]]->func; 246 return gIR->irDsymbol[gIR->unitTests[0]].irFunc->func;
247 247
248 std::string name("_D"); 248 std::string name("_D");
249 name.append(gIR->dmodule->mangle()); 249 name.append(gIR->dmodule->mangle());
250 name.append("10__unittestZ"); 250 name.append("10__unittestZ");
251 251
256 256
257 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn); 257 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
258 LLVMBuilder builder(bb); 258 LLVMBuilder builder(bb);
259 259
260 for (size_t i=0; i<n; i++) { 260 for (size_t i=0; i<n; i++) {
261 llvm::Function* f = gIR->irFunc[gIR->unitTests[i]]->func; 261 llvm::Function* f = gIR->irDsymbol[gIR->unitTests[i]].irFunc->func;
262 llvm::CallInst* call = builder.CreateCall(f,""); 262 llvm::CallInst* call = builder.CreateCall(f,"");
263 call->setCallingConv(llvm::CallingConv::Fast); 263 call->setCallingConv(llvm::CallingConv::Fast);
264 } 264 }
265 265
266 builder.CreateRetVoid(); 266 builder.CreateRetVoid();
297 // initializer vector 297 // initializer vector
298 std::vector<llvm::Constant*> initVec; 298 std::vector<llvm::Constant*> initVec;
299 llvm::Constant* c = 0; 299 llvm::Constant* c = 0;
300 300
301 // vtable 301 // vtable
302 c = moduleinfo->irStruct->vtbl; 302 c = gIR->irDsymbol[moduleinfo].irStruct->vtbl;
303 initVec.push_back(c); 303 initVec.push_back(c);
304 304
305 // monitor 305 // monitor
306 c = getNullPtr(getPtrToType(llvm::Type::Int8Ty)); 306 c = getNullPtr(getPtrToType(llvm::Type::Int8Ty));
307 initVec.push_back(c); 307 initVec.push_back(c);
339 llvm::GlobalVariable* m_gvar = new llvm::GlobalVariable(importArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module); 339 llvm::GlobalVariable* m_gvar = new llvm::GlobalVariable(importArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module);
340 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(importArrTy->getElementType())); 340 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(importArrTy->getElementType()));
341 c = DtoConstSlice(DtoConstSize_t(importInits.size()), c); 341 c = DtoConstSlice(DtoConstSize_t(importInits.size()), c);
342 } 342 }
343 else 343 else
344 c = moduleinfo->irStruct->constInit->getOperand(3); 344 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(3);
345 initVec.push_back(c); 345 initVec.push_back(c);
346 346
347 // localClasses[] 347 // localClasses[]
348 ClassDeclarations aclasses; 348 ClassDeclarations aclasses;
349 //printf("members->dim = %d\n", members->dim); 349 //printf("members->dim = %d\n", members->dim);
364 { 364 {
365 Logger::println("skipping interface '%s' in moduleinfo", cd->toPrettyChars()); 365 Logger::println("skipping interface '%s' in moduleinfo", cd->toPrettyChars());
366 continue; 366 continue;
367 } 367 }
368 Logger::println("class: %s", cd->toPrettyChars()); 368 Logger::println("class: %s", cd->toPrettyChars());
369 assert(cd->irStruct->classInfo); 369 assert(gIR->irDsymbol[cd].irStruct->classInfo);
370 classInits.push_back(cd->irStruct->classInfo); 370 classInits.push_back(gIR->irDsymbol[cd].irStruct->classInfo);
371 } 371 }
372 // has class array? 372 // has class array?
373 if (!classInits.empty()) 373 if (!classInits.empty())
374 { 374 {
375 const llvm::ArrayType* classArrTy = llvm::ArrayType::get(getPtrToType(classinfoTy), classInits.size()); 375 const llvm::ArrayType* classArrTy = llvm::ArrayType::get(getPtrToType(classinfoTy), classInits.size());
380 llvm::GlobalVariable* m_gvar = new llvm::GlobalVariable(classArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module); 380 llvm::GlobalVariable* m_gvar = new llvm::GlobalVariable(classArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module);
381 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(classArrTy->getElementType())); 381 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(classArrTy->getElementType()));
382 c = DtoConstSlice(DtoConstSize_t(classInits.size()), c); 382 c = DtoConstSlice(DtoConstSize_t(classInits.size()), c);
383 } 383 }
384 else 384 else
385 c = moduleinfo->irStruct->constInit->getOperand(4); 385 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(4);
386 initVec.push_back(c); 386 initVec.push_back(c);
387 387
388 // flags 388 // flags
389 c = DtoConstUint(0); 389 c = DtoConstUint(0);
390 if (!needmoduleinfo) 390 if (!needmoduleinfo)
391 c = DtoConstUint(4); // flags (4 means MIstandalone) 391 c = DtoConstUint(4); // flags (4 means MIstandalone)
392 initVec.push_back(c); 392 initVec.push_back(c);
393 393
394 // ctor 394 // ctor
395 llvm::Function* fctor = build_module_ctor(); 395 llvm::Function* fctor = build_module_ctor();
396 c = fctor ? fctor : moduleinfo->irStruct->constInit->getOperand(6); 396 c = fctor ? fctor : gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(6);
397 initVec.push_back(c); 397 initVec.push_back(c);
398 398
399 // dtor 399 // dtor
400 llvm::Function* fdtor = build_module_dtor(); 400 llvm::Function* fdtor = build_module_dtor();
401 c = fdtor ? fdtor : moduleinfo->irStruct->constInit->getOperand(7); 401 c = fdtor ? fdtor : gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(7);
402 initVec.push_back(c); 402 initVec.push_back(c);
403 403
404 // unitTest 404 // unitTest
405 llvm::Function* unittest = build_module_unittest(); 405 llvm::Function* unittest = build_module_unittest();
406 c = unittest ? unittest : moduleinfo->irStruct->constInit->getOperand(8); 406 c = unittest ? unittest : gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(8);
407 initVec.push_back(c); 407 initVec.push_back(c);
408 408
409 // xgetMembers 409 // xgetMembers
410 c = moduleinfo->irStruct->constInit->getOperand(9); 410 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(9);
411 initVec.push_back(c); 411 initVec.push_back(c);
412 412
413 // ictor 413 // ictor
414 c = moduleinfo->irStruct->constInit->getOperand(10); 414 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(10);
415 initVec.push_back(c); 415 initVec.push_back(c);
416 416
417 /*Logger::println("MODULE INFO INITIALIZERS"); 417 /*Logger::println("MODULE INFO INITIALIZERS");
418 for (size_t i=0; i<initVec.size(); ++i) 418 for (size_t i=0; i<initVec.size(); ++i)
419 { 419 {
509 // we don't want to touch private static members at all !!! 509 // we don't want to touch private static members at all !!!
510 if ((prot() == PROTprivate) && getModule() != gIR->dmodule) 510 if ((prot() == PROTprivate) && getModule() != gIR->dmodule)
511 return; 511 return;
512 512
513 // don't duplicate work 513 // don't duplicate work
514 if (llvmResolved) return; 514 if (gIR->irDsymbol[this].resolved) return;
515 llvmResolved = true; 515 gIR->irDsymbol[this].resolved = true;
516 llvmDeclared = true; 516 gIR->irDsymbol[this].declared = true;
517 517
518 irGlobal = new IrGlobal(this); 518 gIR->irDsymbol[this].irGlobal = new IrGlobal(this);
519 519
520 Logger::println("parent: %s (%s)", parent->toChars(), parent->kind()); 520 Logger::println("parent: %s (%s)", parent->toChars(), parent->kind());
521 521
522 // handle static local variables 522 // handle static local variables
523 bool static_local = false; 523 bool static_local = false;
530 } 530 }
531 } 531 }
532 532
533 Logger::println("Creating global variable"); 533 Logger::println("Creating global variable");
534 534
535 const llvm::Type* _type = irGlobal->type.get(); 535 const llvm::Type* _type = gIR->irDsymbol[this].irGlobal->type.get();
536 llvm::GlobalValue::LinkageTypes _linkage = DtoLinkage(this); 536 llvm::GlobalValue::LinkageTypes _linkage = DtoLinkage(this);
537 std::string _name(mangle()); 537 std::string _name(mangle());
538 538
539 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(_type,_isconst,_linkage,NULL,_name,gIR->module); 539 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(_type,_isconst,_linkage,NULL,_name,gIR->module);
540 irGlobal->value = gvar; 540 gIR->irDsymbol[this].irGlobal->value = gvar;
541 541
542 if (static_local) 542 if (static_local)
543 DtoConstInitGlobal(this); 543 DtoConstInitGlobal(this);
544 else 544 else
545 gIR->constInitList.push_back(this); 545 gIR->constInitList.push_back(this);
549 else 549 else
550 { 550 {
551 Logger::println("Aggregate var declaration: '%s' offset=%d", toChars(), offset); 551 Logger::println("Aggregate var declaration: '%s' offset=%d", toChars(), offset);
552 552
553 const llvm::Type* _type = DtoType(type); 553 const llvm::Type* _type = DtoType(type);
554 irField = new IrField(this); 554 gIR->irDsymbol[this].irField = new IrField(this);
555 555
556 // add the field in the IRStruct 556 // add the field in the IRStruct
557 gIR->topstruct()->offsets.insert(std::make_pair(offset, IrStruct::Offset(this, _type))); 557 gIR->topstruct()->offsets.insert(std::make_pair(offset, IrStruct::Offset(this, _type)));
558 } 558 }
559 559