Mercurial > projects > ldc

comparison gen/toobj.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 a8cd9bc1021a
children f5ca6bbbf1d7
comparison
equal deleted inserted replaced
172:68a7dd38c03c 173:db9890b3fb64
63 // TODO look at making the instance static and moving most functionality into IrModule where it belongs 63 // TODO look at making the instance static and moving most functionality into IrModule where it belongs
64 IRState ir; 64 IRState ir;
65 gIR = &ir; 65 gIR = &ir;
66 ir.dmodule = this; 66 ir.dmodule = this;
67 67
68 // reset all IR data stored in Dsymbols and Types
69 IrDsymbol::resetAll();
70 IrType::resetAll();
71
68 // module ir state 72 // module ir state
69 // might already exist via import, just overwrite... 73 // might already exist via import, just overwrite...
70 gIR->irDsymbol[this].irModule = new IrModule(this); 74 this->ir.irModule = new IrModule(this);
71 75
72 // name the module 76 // name the module
73 std::string mname(toChars()); 77 std::string mname(toChars());
74 if (md != 0) 78 if (md != 0)
75 mname = md->toChars(); 79 mname = md->toChars();
96 RegisterDwarfSymbols(ir.module); 100 RegisterDwarfSymbols(ir.module);
97 DtoDwarfCompileUnit(this); 101 DtoDwarfCompileUnit(this);
98 } 102 }
99 103
100 // start out by providing opaque for the built-in class types 104 // start out by providing opaque for the built-in class types
101 if (!gIR->irType[ClassDeclaration::object->type].type) 105 if (!ClassDeclaration::object->type->ir.type)
102 gIR->irType[ClassDeclaration::object->type].type = new llvm::PATypeHolder(llvm::OpaqueType::get()); 106 ClassDeclaration::object->type->ir.type = new llvm::PATypeHolder(llvm::OpaqueType::get());
103 107
104 if (!gIR->irType[Type::typeinfo->type].type) 108 if (!Type::typeinfo->type->ir.type)
105 gIR->irType[Type::typeinfo->type].type = new llvm::PATypeHolder(llvm::OpaqueType::get()); 109 Type::typeinfo->type->ir.type = new llvm::PATypeHolder(llvm::OpaqueType::get());
106 110
107 if (!gIR->irType[ClassDeclaration::classinfo->type].type) 111 if (!ClassDeclaration::classinfo->type->ir.type)
108 gIR->irType[ClassDeclaration::classinfo->type].type = new llvm::PATypeHolder(llvm::OpaqueType::get()); 112 ClassDeclaration::classinfo->type->ir.type = new llvm::PATypeHolder(llvm::OpaqueType::get());
109 113
110 /*if (!gIR->irType[Type::typeinfoclass->type].type) 114 /*if (!Type::typeinfoclass->type->ir.type)
111 gIR->irType[Type::typeinfoclass->type].type = new llvm::PATypeHolder(llvm::OpaqueType::get());*/ 115 Type::typeinfoclass->type->ir.type = new llvm::PATypeHolder(llvm::OpaqueType::get());*/
112 116
113 // process module members 117 // process module members
114 for (int k=0; k < members->dim; k++) { 118 for (int k=0; k < members->dim; k++) {
115 Dsymbol* dsym = (Dsymbol*)(members->data[k]); 119 Dsymbol* dsym = (Dsymbol*)(members->data[k]);
116 assert(dsym); 120 assert(dsym);
175 if (gIR->ctors.empty()) 179 if (gIR->ctors.empty())
176 return NULL; 180 return NULL;
177 181
178 size_t n = gIR->ctors.size(); 182 size_t n = gIR->ctors.size();
179 if (n == 1) 183 if (n == 1)
180 return gIR->irDsymbol[gIR->ctors[0]].irFunc->func; 184 return gIR->ctors[0]->ir.irFunc->func;
181 185
182 std::string name("_D"); 186 std::string name("_D");
183 name.append(gIR->dmodule->mangle()); 187 name.append(gIR->dmodule->mangle());
184 name.append("6__ctorZ"); 188 name.append("6__ctorZ");
185 189
190 194
191 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn); 195 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
192 LLVMBuilder builder(bb); 196 LLVMBuilder builder(bb);
193 197
194 for (size_t i=0; i<n; i++) { 198 for (size_t i=0; i<n; i++) {
195 llvm::Function* f = gIR->irDsymbol[gIR->ctors[i]].irFunc->func; 199 llvm::Function* f = gIR->ctors[i]->ir.irFunc->func;
196 llvm::CallInst* call = builder.CreateCall(f,""); 200 llvm::CallInst* call = builder.CreateCall(f,"");
197 call->setCallingConv(llvm::CallingConv::Fast); 201 call->setCallingConv(llvm::CallingConv::Fast);
198 } 202 }
199 203
200 builder.CreateRetVoid(); 204 builder.CreateRetVoid();
208 if (gIR->dtors.empty()) 212 if (gIR->dtors.empty())
209 return NULL; 213 return NULL;
210 214
211 size_t n = gIR->dtors.size(); 215 size_t n = gIR->dtors.size();
212 if (n == 1) 216 if (n == 1)
213 return gIR->irDsymbol[gIR->dtors[0]].irFunc->func; 217 return gIR->dtors[0]->ir.irFunc->func;
214 218
215 std::string name("_D"); 219 std::string name("_D");
216 name.append(gIR->dmodule->mangle()); 220 name.append(gIR->dmodule->mangle());
217 name.append("6__dtorZ"); 221 name.append("6__dtorZ");
218 222
223 227
224 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn); 228 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
225 LLVMBuilder builder(bb); 229 LLVMBuilder builder(bb);
226 230
227 for (size_t i=0; i<n; i++) { 231 for (size_t i=0; i<n; i++) {
228 llvm::Function* f = gIR->irDsymbol[gIR->dtors[i]].irFunc->func; 232 llvm::Function* f = gIR->dtors[i]->ir.irFunc->func;
229 llvm::CallInst* call = builder.CreateCall(f,""); 233 llvm::CallInst* call = builder.CreateCall(f,"");
230 call->setCallingConv(llvm::CallingConv::Fast); 234 call->setCallingConv(llvm::CallingConv::Fast);
231 } 235 }
232 236
233 builder.CreateRetVoid(); 237 builder.CreateRetVoid();
241 if (gIR->unitTests.empty()) 245 if (gIR->unitTests.empty())
242 return NULL; 246 return NULL;
243 247
244 size_t n = gIR->unitTests.size(); 248 size_t n = gIR->unitTests.size();
245 if (n == 1) 249 if (n == 1)
246 return gIR->irDsymbol[gIR->unitTests[0]].irFunc->func; 250 return gIR->unitTests[0]->ir.irFunc->func;
247 251
248 std::string name("_D"); 252 std::string name("_D");
249 name.append(gIR->dmodule->mangle()); 253 name.append(gIR->dmodule->mangle());
250 name.append("10__unittestZ"); 254 name.append("10__unittestZ");
251 255
256 260
257 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn); 261 llvm::BasicBlock* bb = new llvm::BasicBlock("entry", fn);
258 LLVMBuilder builder(bb); 262 LLVMBuilder builder(bb);
259 263
260 for (size_t i=0; i<n; i++) { 264 for (size_t i=0; i<n; i++) {
261 llvm::Function* f = gIR->irDsymbol[gIR->unitTests[i]].irFunc->func; 265 llvm::Function* f = gIR->unitTests[i]->ir.irFunc->func;
262 llvm::CallInst* call = builder.CreateCall(f,""); 266 llvm::CallInst* call = builder.CreateCall(f,"");
263 call->setCallingConv(llvm::CallingConv::Fast); 267 call->setCallingConv(llvm::CallingConv::Fast);
264 } 268 }
265 269
266 builder.CreateRetVoid(); 270 builder.CreateRetVoid();
287 // resolve ModuleInfo 291 // resolve ModuleInfo
288 assert(moduleinfo); 292 assert(moduleinfo);
289 DtoForceConstInitDsymbol(moduleinfo); 293 DtoForceConstInitDsymbol(moduleinfo);
290 294
291 // moduleinfo llvm struct type 295 // moduleinfo llvm struct type
292 const llvm::StructType* moduleinfoTy = isaStruct(gIR->irType[moduleinfo->type].type->get()); 296 const llvm::StructType* moduleinfoTy = isaStruct(moduleinfo->type->ir.type->get());
293 297
294 // classinfo llvm struct type 298 // classinfo llvm struct type
295 const llvm::StructType* classinfoTy = isaStruct(gIR->irType[ClassDeclaration::classinfo->type].type->get()); 299 const llvm::StructType* classinfoTy = isaStruct(ClassDeclaration::classinfo->type->ir.type->get());
296 300
297 // initializer vector 301 // initializer vector
298 std::vector<llvm::Constant*> initVec; 302 std::vector<llvm::Constant*> initVec;
299 llvm::Constant* c = 0; 303 llvm::Constant* c = 0;
300 304
301 // vtable 305 // vtable
302 c = gIR->irDsymbol[moduleinfo].irStruct->vtbl; 306 c = moduleinfo->ir.irStruct->vtbl;
303 initVec.push_back(c); 307 initVec.push_back(c);
304 308
305 // monitor 309 // monitor
306 c = getNullPtr(getPtrToType(llvm::Type::Int8Ty)); 310 c = getNullPtr(getPtrToType(llvm::Type::Int8Ty));
307 initVec.push_back(c); 311 initVec.push_back(c);
341 if (!m_gvar) m_gvar = new llvm::GlobalVariable(importArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module); 345 if (!m_gvar) m_gvar = new llvm::GlobalVariable(importArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module);
342 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(importArrTy->getElementType())); 346 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(importArrTy->getElementType()));
343 c = DtoConstSlice(DtoConstSize_t(importInits.size()), c); 347 c = DtoConstSlice(DtoConstSize_t(importInits.size()), c);
344 } 348 }
345 else 349 else
346 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(3); 350 c = moduleinfo->ir.irStruct->constInit->getOperand(3);
347 initVec.push_back(c); 351 initVec.push_back(c);
348 352
349 // localClasses[] 353 // localClasses[]
350 ClassDeclarations aclasses; 354 ClassDeclarations aclasses;
351 //printf("members->dim = %d\n", members->dim); 355 //printf("members->dim = %d\n", members->dim);
366 { 370 {
367 Logger::println("skipping interface '%s' in moduleinfo", cd->toPrettyChars()); 371 Logger::println("skipping interface '%s' in moduleinfo", cd->toPrettyChars());
368 continue; 372 continue;
369 } 373 }
370 Logger::println("class: %s", cd->toPrettyChars()); 374 Logger::println("class: %s", cd->toPrettyChars());
371 assert(gIR->irDsymbol[cd].irStruct->classInfo); 375 assert(cd->ir.irStruct->classInfo);
372 classInits.push_back(gIR->irDsymbol[cd].irStruct->classInfo); 376 classInits.push_back(cd->ir.irStruct->classInfo);
373 } 377 }
374 // has class array? 378 // has class array?
375 if (!classInits.empty()) 379 if (!classInits.empty())
376 { 380 {
377 const llvm::ArrayType* classArrTy = llvm::ArrayType::get(getPtrToType(classinfoTy), classInits.size()); 381 const llvm::ArrayType* classArrTy = llvm::ArrayType::get(getPtrToType(classinfoTy), classInits.size());
382 llvm::GlobalVariable* m_gvar = new llvm::GlobalVariable(classArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module); 386 llvm::GlobalVariable* m_gvar = new llvm::GlobalVariable(classArrTy, true, llvm::GlobalValue::InternalLinkage, c, m_name, gIR->module);
383 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(classArrTy->getElementType())); 387 c = llvm::ConstantExpr::getBitCast(m_gvar, getPtrToType(classArrTy->getElementType()));
384 c = DtoConstSlice(DtoConstSize_t(classInits.size()), c); 388 c = DtoConstSlice(DtoConstSize_t(classInits.size()), c);
385 } 389 }
386 else 390 else
387 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(4); 391 c = moduleinfo->ir.irStruct->constInit->getOperand(4);
388 initVec.push_back(c); 392 initVec.push_back(c);
389 393
390 // flags 394 // flags
391 c = DtoConstUint(0); 395 c = DtoConstUint(0);
392 if (!needmoduleinfo) 396 if (!needmoduleinfo)
393 c = DtoConstUint(4); // flags (4 means MIstandalone) 397 c = DtoConstUint(4); // flags (4 means MIstandalone)
394 initVec.push_back(c); 398 initVec.push_back(c);
395 399
396 // ctor 400 // ctor
397 llvm::Function* fctor = build_module_ctor(); 401 llvm::Function* fctor = build_module_ctor();
398 c = fctor ? fctor : gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(6); 402 c = fctor ? fctor : moduleinfo->ir.irStruct->constInit->getOperand(6);
399 initVec.push_back(c); 403 initVec.push_back(c);
400 404
401 // dtor 405 // dtor
402 llvm::Function* fdtor = build_module_dtor(); 406 llvm::Function* fdtor = build_module_dtor();
403 c = fdtor ? fdtor : gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(7); 407 c = fdtor ? fdtor : moduleinfo->ir.irStruct->constInit->getOperand(7);
404 initVec.push_back(c); 408 initVec.push_back(c);
405 409
406 // unitTest 410 // unitTest
407 llvm::Function* unittest = build_module_unittest(); 411 llvm::Function* unittest = build_module_unittest();
408 c = unittest ? unittest : gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(8); 412 c = unittest ? unittest : moduleinfo->ir.irStruct->constInit->getOperand(8);
409 initVec.push_back(c); 413 initVec.push_back(c);
410 414
411 // xgetMembers 415 // xgetMembers
412 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(9); 416 c = moduleinfo->ir.irStruct->constInit->getOperand(9);
413 initVec.push_back(c); 417 initVec.push_back(c);
414 418
415 // ictor 419 // ictor
416 c = gIR->irDsymbol[moduleinfo].irStruct->constInit->getOperand(10); 420 c = moduleinfo->ir.irStruct->constInit->getOperand(10);
417 initVec.push_back(c); 421 initVec.push_back(c);
418 422
419 /*Logger::println("MODULE INFO INITIALIZERS"); 423 /*Logger::println("MODULE INFO INITIALIZERS");
420 for (size_t i=0; i<initVec.size(); ++i) 424 for (size_t i=0; i<initVec.size(); ++i)
421 { 425 {
511 // we don't want to touch private static members at all !!! 515 // we don't want to touch private static members at all !!!
512 if ((prot() == PROTprivate) && getModule() != gIR->dmodule) 516 if ((prot() == PROTprivate) && getModule() != gIR->dmodule)
513 return; 517 return;
514 518
515 // don't duplicate work 519 // don't duplicate work
516 if (gIR->irDsymbol[this].resolved) return; 520 if (this->ir.resolved) return;
517 gIR->irDsymbol[this].resolved = true; 521 this->ir.resolved = true;
518 gIR->irDsymbol[this].declared = true; 522 this->ir.declared = true;
519 523
520 gIR->irDsymbol[this].irGlobal = new IrGlobal(this); 524 this->ir.irGlobal = new IrGlobal(this);
521 525
522 Logger::println("parent: %s (%s)", parent->toChars(), parent->kind()); 526 Logger::println("parent: %s (%s)", parent->toChars(), parent->kind());
523 527
524 // handle static local variables 528 // handle static local variables
525 bool static_local = false; 529 bool static_local = false;
532 } 536 }
533 } 537 }
534 538
535 Logger::println("Creating global variable"); 539 Logger::println("Creating global variable");
536 540
537 const llvm::Type* _type = gIR->irDsymbol[this].irGlobal->type.get(); 541 const llvm::Type* _type = this->ir.irGlobal->type.get();
538 llvm::GlobalValue::LinkageTypes _linkage = DtoLinkage(this); 542 llvm::GlobalValue::LinkageTypes _linkage = DtoLinkage(this);
539 std::string _name(mangle()); 543 std::string _name(mangle());
540 544
541 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(_type,_isconst,_linkage,NULL,_name,gIR->module); 545 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(_type,_isconst,_linkage,NULL,_name,gIR->module);
542 gIR->irDsymbol[this].irGlobal->value = gvar; 546 this->ir.irGlobal->value = gvar;
543 547
544 Logger::cout() << *gvar << '\n'; 548 Logger::cout() << *gvar << '\n';
545 549
546 if (static_local) 550 if (static_local)
547 DtoConstInitGlobal(this); 551 DtoConstInitGlobal(this);
553 else 557 else
554 { 558 {
555 Logger::println("Aggregate var declaration: '%s' offset=%d", toChars(), offset); 559 Logger::println("Aggregate var declaration: '%s' offset=%d", toChars(), offset);
556 560
557 const llvm::Type* _type = DtoType(type); 561 const llvm::Type* _type = DtoType(type);
558 gIR->irDsymbol[this].irField = new IrField(this); 562 this->ir.irField = new IrField(this);
559 563
560 // add the field in the IRStruct 564 // add the field in the IRStruct
561 gIR->topstruct()->offsets.insert(std::make_pair(offset, IrStruct::Offset(this, _type))); 565 gIR->topstruct()->offsets.insert(std::make_pair(offset, IrStruct::Offset(this, _type)));
562 } 566 }
563 567