Mercurial > projects > ldc

comparison gen/toir.cpp @ 1545:7fcb72d518f6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
More factory methods moved to LLVMContext
author Benjamin Kramer <benny.kra@gmail.com>
date Wed, 15 Jul 2009 18:09:41 +0200
parents 61f12f4651b5
children a326f145a57b
comparison
equal deleted inserted replaced
1544:8863cf7236e6 1545:7fcb72d518f6
286 Logger::print("IntegerExp::toConstElem: %s @ %s\n", toChars(), type->toChars()); 286 Logger::print("IntegerExp::toConstElem: %s @ %s\n", toChars(), type->toChars());
287 LOG_SCOPE; 287 LOG_SCOPE;
288 const LLType* t = DtoType(type); 288 const LLType* t = DtoType(type);
289 if (isaPointer(t)) { 289 if (isaPointer(t)) {
290 Logger::println("pointer"); 290 Logger::println("pointer");
291 LLConstant* i = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)value,false); 291 LLConstant* i = gIR->context().getConstantInt(DtoSize_t(),(uint64_t)value,false);
292 return llvm::ConstantExpr::getIntToPtr(i, t); 292 return llvm::ConstantExpr::getIntToPtr(i, t);
293 } 293 }
294 assert(llvm::isa<LLIntegerType>(t)); 294 assert(llvm::isa<LLIntegerType>(t));
295 LLConstant* c = llvm::ConstantInt::get(t,(uint64_t)value,!type->isunsigned()); 295 LLConstant* c = gIR->context().getConstantInt(t,(uint64_t)value,!type->isunsigned());
296 assert(c); 296 assert(c);
297 if (Logger::enabled()) 297 if (Logger::enabled())
298 Logger::cout() << "value = " << *c << '\n'; 298 Logger::cout() << "value = " << *c << '\n';
299 return c; 299 return c;
300 } 300 }
400 400
401 LLConstant* _init; 401 LLConstant* _init;
402 if (cty->size() == 1) { 402 if (cty->size() == 1) {
403 uint8_t* str = (uint8_t*)string; 403 uint8_t* str = (uint8_t*)string;
404 std::string cont((char*)str, len); 404 std::string cont((char*)str, len);
405 _init = llvm::ConstantArray::get(cont,true); 405 _init = gIR->context().getConstantArray(cont,true);
406 } 406 }
407 else if (cty->size() == 2) { 407 else if (cty->size() == 2) {
408 uint16_t* str = (uint16_t*)string; 408 uint16_t* str = (uint16_t*)string;
409 std::vector<LLConstant*> vals; 409 std::vector<LLConstant*> vals;
410 vals.reserve(len+1); 410 vals.reserve(len+1);
411 for(size_t i=0; i<len; ++i) { 411 for(size_t i=0; i<len; ++i) {
412 vals.push_back(llvm::ConstantInt::get(ct, str[i], false));; 412 vals.push_back(gIR->context().getConstantInt(ct, str[i], false));;
413 } 413 }
414 vals.push_back(llvm::ConstantInt::get(ct, 0, false)); 414 vals.push_back(gIR->context().getConstantInt(ct, 0, false));
415 _init = llvm::ConstantArray::get(at,vals); 415 _init = llvm::ConstantArray::get(at,vals);
416 } 416 }
417 else if (cty->size() == 4) { 417 else if (cty->size() == 4) {
418 uint32_t* str = (uint32_t*)string; 418 uint32_t* str = (uint32_t*)string;
419 std::vector<LLConstant*> vals; 419 std::vector<LLConstant*> vals;
420 vals.reserve(len+1); 420 vals.reserve(len+1);
421 for(size_t i=0; i<len; ++i) { 421 for(size_t i=0; i<len; ++i) {
422 vals.push_back(llvm::ConstantInt::get(ct, str[i], false));; 422 vals.push_back(gIR->context().getConstantInt(ct, str[i], false));;
423 } 423 }
424 vals.push_back(llvm::ConstantInt::get(ct, 0, false)); 424 vals.push_back(gIR->context().getConstantInt(ct, 0, false));
425 _init = llvm::ConstantArray::get(at,vals); 425 _init = llvm::ConstantArray::get(at,vals);
426 } 426 }
427 else 427 else
428 assert(0); 428 assert(0);
429 429
430 llvm::GlobalValue::LinkageTypes _linkage = llvm::GlobalValue::InternalLinkage; 430 llvm::GlobalValue::LinkageTypes _linkage = llvm::GlobalValue::InternalLinkage;
431 if (Logger::enabled()) 431 if (Logger::enabled())
432 Logger::cout() << "type: " << *at << "\ninit: " << *_init << '\n'; 432 Logger::cout() << "type: " << *at << "\ninit: " << *_init << '\n';
433 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(*gIR->module,at,true,_linkage,_init,".str"); 433 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(*gIR->module,at,true,_linkage,_init,".str");
434 434
435 llvm::ConstantInt* zero = llvm::ConstantInt::get(LLType::Int32Ty, 0, false); 435 llvm::ConstantInt* zero = gIR->context().getConstantInt(LLType::Int32Ty, 0, false);
436 LLConstant* idxs[2] = { zero, zero }; 436 LLConstant* idxs[2] = { zero, zero };
437 LLConstant* arrptr = llvm::ConstantExpr::getGetElementPtr(gvar,idxs,2); 437 LLConstant* arrptr = llvm::ConstantExpr::getGetElementPtr(gvar,idxs,2);
438 438
439 if (dtype->ty == Tarray) { 439 if (dtype->ty == Tarray) {
440 LLConstant* clen = llvm::ConstantInt::get(DtoSize_t(),len,false); 440 LLConstant* clen = gIR->context().getConstantInt(DtoSize_t(),len,false);
441 return new DImValue(type, DtoConstSlice(clen, arrptr)); 441 return new DImValue(type, DtoConstSlice(clen, arrptr));
442 } 442 }
443 else if (dtype->ty == Tsarray) { 443 else if (dtype->ty == Tsarray) {
444 const LLType* dstType = getPtrToType(LLArrayType::get(ct, len)); 444 const LLType* dstType = getPtrToType(LLArrayType::get(ct, len));
445 LLValue* emem = (gvar->getType() == dstType) ? gvar : DtoBitCast(gvar, dstType); 445 LLValue* emem = (gvar->getType() == dstType) ? gvar : DtoBitCast(gvar, dstType);
471 471
472 LLConstant* _init; 472 LLConstant* _init;
473 if (cty->size() == 1) { 473 if (cty->size() == 1) {
474 uint8_t* str = (uint8_t*)string; 474 uint8_t* str = (uint8_t*)string;
475 std::string cont((char*)str, len); 475 std::string cont((char*)str, len);
476 _init = llvm::ConstantArray::get(cont, nullterm); 476 _init = gIR->context().getConstantArray(cont, nullterm);
477 } 477 }
478 else if (cty->size() == 2) { 478 else if (cty->size() == 2) {
479 uint16_t* str = (uint16_t*)string; 479 uint16_t* str = (uint16_t*)string;
480 std::vector<LLConstant*> vals; 480 std::vector<LLConstant*> vals;
481 vals.reserve(len+1); 481 vals.reserve(len+1);
482 for(size_t i=0; i<len; ++i) { 482 for(size_t i=0; i<len; ++i) {
483 vals.push_back(llvm::ConstantInt::get(ct, str[i], false));; 483 vals.push_back(gIR->context().getConstantInt(ct, str[i], false));;
484 } 484 }
485 if (nullterm) 485 if (nullterm)
486 vals.push_back(llvm::ConstantInt::get(ct, 0, false)); 486 vals.push_back(gIR->context().getConstantInt(ct, 0, false));
487 _init = llvm::ConstantArray::get(at,vals); 487 _init = llvm::ConstantArray::get(at,vals);
488 } 488 }
489 else if (cty->size() == 4) { 489 else if (cty->size() == 4) {
490 uint32_t* str = (uint32_t*)string; 490 uint32_t* str = (uint32_t*)string;
491 std::vector<LLConstant*> vals; 491 std::vector<LLConstant*> vals;
492 vals.reserve(len+1); 492 vals.reserve(len+1);
493 for(size_t i=0; i<len; ++i) { 493 for(size_t i=0; i<len; ++i) {
494 vals.push_back(llvm::ConstantInt::get(ct, str[i], false));; 494 vals.push_back(gIR->context().getConstantInt(ct, str[i], false));;
495 } 495 }
496 if (nullterm) 496 if (nullterm)
497 vals.push_back(llvm::ConstantInt::get(ct, 0, false)); 497 vals.push_back(gIR->context().getConstantInt(ct, 0, false));
498 _init = llvm::ConstantArray::get(at,vals); 498 _init = llvm::ConstantArray::get(at,vals);
499 } 499 }
500 else 500 else
501 assert(0); 501 assert(0);
502 502
506 } 506 }
507 507
508 llvm::GlobalValue::LinkageTypes _linkage = llvm::GlobalValue::InternalLinkage; 508 llvm::GlobalValue::LinkageTypes _linkage = llvm::GlobalValue::InternalLinkage;
509 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(*gIR->module,_init->getType(),true,_linkage,_init,".str"); 509 llvm::GlobalVariable* gvar = new llvm::GlobalVariable(*gIR->module,_init->getType(),true,_linkage,_init,".str");
510 510
511 llvm::ConstantInt* zero = llvm::ConstantInt::get(LLType::Int32Ty, 0, false); 511 llvm::ConstantInt* zero = gIR->context().getConstantInt(LLType::Int32Ty, 0, false);
512 LLConstant* idxs[2] = { zero, zero }; 512 LLConstant* idxs[2] = { zero, zero };
513 LLConstant* arrptr = llvm::ConstantExpr::getGetElementPtr(gvar,idxs,2); 513 LLConstant* arrptr = llvm::ConstantExpr::getGetElementPtr(gvar,idxs,2);
514 514
515 if (t->ty == Tpointer) { 515 if (t->ty == Tpointer) {
516 return arrptr; 516 return arrptr;
517 } 517 }
518 else if (t->ty == Tarray) { 518 else if (t->ty == Tarray) {
519 LLConstant* clen = llvm::ConstantInt::get(DtoSize_t(),len,false); 519 LLConstant* clen = gIR->context().getConstantInt(DtoSize_t(),len,false);
520 return DtoConstSlice(clen, arrptr); 520 return DtoConstSlice(clen, arrptr);
521 } 521 }
522 522
523 assert(0); 523 assert(0);
524 return NULL; 524 return NULL;
1523 Type* e2type = e2->type->toBasetype(); 1523 Type* e2type = e2->type->toBasetype();
1524 1524
1525 if (e1type->isintegral()) 1525 if (e1type->isintegral())
1526 { 1526 {
1527 assert(e2type->isintegral()); 1527 assert(e2type->isintegral());
1528 LLValue* one = llvm::ConstantInt::get(val->getType(), 1, !e2type->isunsigned()); 1528 LLValue* one = gIR->context().getConstantInt(val->getType(), 1, !e2type->isunsigned());
1529 if (op == TOKplusplus) { 1529 if (op == TOKplusplus) {
1530 post = llvm::BinaryOperator::CreateAdd(val,one,"tmp",p->scopebb()); 1530 post = llvm::BinaryOperator::CreateAdd(val,one,"tmp",p->scopebb());
1531 } 1531 }
1532 else if (op == TOKminusminus) { 1532 else if (op == TOKminusminus) {
1533 post = llvm::BinaryOperator::CreateSub(val,one,"tmp",p->scopebb()); 1533 post = llvm::BinaryOperator::CreateSub(val,one,"tmp",p->scopebb());
1534 } 1534 }
1535 } 1535 }
1536 else if (e1type->ty == Tpointer) 1536 else if (e1type->ty == Tpointer)
1537 { 1537 {
1538 assert(e2type->isintegral()); 1538 assert(e2type->isintegral());
1539 LLConstant* minusone = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)-1,true); 1539 LLConstant* minusone = gIR->context().getConstantInt(DtoSize_t(),(uint64_t)-1,true);
1540 LLConstant* plusone = llvm::ConstantInt::get(DtoSize_t(),(uint64_t)1,false); 1540 LLConstant* plusone = gIR->context().getConstantInt(DtoSize_t(),(uint64_t)1,false);
1541 LLConstant* whichone = (op == TOKplusplus) ? plusone : minusone; 1541 LLConstant* whichone = (op == TOKplusplus) ? plusone : minusone;
1542 post = llvm::GetElementPtrInst::Create(val, whichone, "tmp", p->scopebb()); 1542 post = llvm::GetElementPtrInst::Create(val, whichone, "tmp", p->scopebb());
1543 } 1543 }
1544 else if (e1type->isfloating()) 1544 else if (e1type->isfloating())
1545 { 1545 {
2144 LOG_SCOPE; 2144 LOG_SCOPE;
2145 2145
2146 DValue* u = e1->toElem(p); 2146 DValue* u = e1->toElem(p);
2147 2147
2148 LLValue* value = u->getRVal(); 2148 LLValue* value = u->getRVal();
2149 LLValue* minusone = llvm::ConstantInt::get(value->getType(), (uint64_t)-1, true); 2149 LLValue* minusone = gIR->context().getConstantInt(value->getType(), (uint64_t)-1, true);
2150 value = llvm::BinaryOperator::Create(llvm::Instruction::Xor, value, minusone, "tmp", p->scopebb()); 2150 value = llvm::BinaryOperator::Create(llvm::Instruction::Xor, value, minusone, "tmp", p->scopebb());
2151 2151
2152 return new DImValue(type, value); 2152 return new DImValue(type, value);
2153 } 2153 }
2154 2154
2499 std::vector<LLConstant*> constvals(values.size(), NULL); 2499 std::vector<LLConstant*> constvals(values.size(), NULL);
2500 for (size_t i = 0; i < values.size(); ++i) 2500 for (size_t i = 0; i < values.size(); ++i)
2501 constvals[i] = llvm::cast<LLConstant>(values[i]); 2501 constvals[i] = llvm::cast<LLConstant>(values[i]);
2502 2502
2503 // return constant struct 2503 // return constant struct
2504 return LLConstantStruct::get(constvals, sd->ir.irStruct->packed); 2504 return gIR->context().getConstantStruct(constvals, sd->ir.irStruct->packed);
2505 } 2505 }
2506 2506
2507 ////////////////////////////////////////////////////////////////////////////////////////// 2507 //////////////////////////////////////////////////////////////////////////////////////////
2508 2508
2509 DValue* InExp::toElem(IRState* p) 2509 DValue* InExp::toElem(IRState* p)