Mercurial > projects > ldc
comparison gen/toir.cpp @ 104:4d1e9eb001e0 trunk
[svn r108] Now basic suppport for complex types. =,+,-,*,/ are supported.
author | lindquist |
---|---|
date | Mon, 19 Nov 2007 02:58:58 +0100 |
parents | 027b8d8b71ec |
children | 3efbcc81ba45 |
comparison
equal
deleted
inserted
replaced
103:855adfdb8d38 | 104:4d1e9eb001e0 |
---|---|
26 #include "gen/runtime.h" | 26 #include "gen/runtime.h" |
27 #include "gen/arrays.h" | 27 #include "gen/arrays.h" |
28 #include "gen/structs.h" | 28 #include "gen/structs.h" |
29 #include "gen/classes.h" | 29 #include "gen/classes.h" |
30 #include "gen/typeinf.h" | 30 #include "gen/typeinf.h" |
31 | 31 #include "gen/complex.h" |
32 #include "gen/dvalue.h" | 32 #include "gen/dvalue.h" |
33 | 33 |
34 ////////////////////////////////////////////////////////////////////////////////////////// | 34 ////////////////////////////////////////////////////////////////////////////////////////// |
35 | 35 |
36 DValue* DeclarationExp::toElem(IRState* p) | 36 DValue* DeclarationExp::toElem(IRState* p) |
289 llvm::Constant* RealExp::toConstElem(IRState* p) | 289 llvm::Constant* RealExp::toConstElem(IRState* p) |
290 { | 290 { |
291 Logger::print("RealExp::toConstElem: %s | %s\n", toChars(), type->toChars()); | 291 Logger::print("RealExp::toConstElem: %s | %s\n", toChars(), type->toChars()); |
292 LOG_SCOPE; | 292 LOG_SCOPE; |
293 Type* t = DtoDType(type); | 293 Type* t = DtoDType(type); |
294 const llvm::Type* fty = DtoType(t); | 294 return DtoConstFP(t, value); |
295 if (t->ty == Tfloat32 || t->ty == Timaginary32) | |
296 return llvm::ConstantFP::get(fty,float(value)); | |
297 else if (t->ty == Tfloat64 || t->ty == Timaginary64 || t->ty == Tfloat80 || t->ty == Timaginary80) | |
298 return llvm::ConstantFP::get(fty,double(value)); | |
299 assert(0); | |
300 return NULL; | |
301 } | 295 } |
302 | 296 |
303 ////////////////////////////////////////////////////////////////////////////////////////// | 297 ////////////////////////////////////////////////////////////////////////////////////////// |
304 | 298 |
305 DValue* NullExp::toElem(IRState* p) | 299 DValue* NullExp::toElem(IRState* p) |
332 | 326 |
333 DValue* ComplexExp::toElem(IRState* p) | 327 DValue* ComplexExp::toElem(IRState* p) |
334 { | 328 { |
335 Logger::print("ComplexExp::toElem(): %s | %s\n", toChars(), type->toChars()); | 329 Logger::print("ComplexExp::toElem(): %s | %s\n", toChars(), type->toChars()); |
336 LOG_SCOPE; | 330 LOG_SCOPE; |
337 assert(0 && "no complex yet"); | 331 llvm::Constant* c = toConstElem(p); |
332 | |
333 if (c->isNullValue()) { | |
334 Type* t = DtoDType(type); | |
335 if (t->ty == Tcomplex32) | |
336 c = DtoConstFP(Type::tfloat32, 0); | |
337 else | |
338 c = DtoConstFP(Type::tfloat64, 0); | |
339 return new DComplexValue(type, c, c); | |
340 } | |
341 | |
342 return new DComplexValue(type, c->getOperand(0), c->getOperand(1)); | |
338 } | 343 } |
339 | 344 |
340 ////////////////////////////////////////////////////////////////////////////////////////// | 345 ////////////////////////////////////////////////////////////////////////////////////////// |
341 | 346 |
342 llvm::Constant* ComplexExp::toConstElem(IRState* p) | 347 llvm::Constant* ComplexExp::toConstElem(IRState* p) |
343 { | 348 { |
344 Logger::print("ComplexExp::toConstElem(): %s | %s\n", toChars(), type->toChars()); | 349 Logger::print("ComplexExp::toConstElem(): %s | %s\n", toChars(), type->toChars()); |
345 LOG_SCOPE; | 350 LOG_SCOPE; |
346 assert(0 && "no complex yet"); | 351 return DtoConstComplex(type, value.re, value.im); |
347 } | 352 } |
348 | 353 |
349 ////////////////////////////////////////////////////////////////////////////////////////// | 354 ////////////////////////////////////////////////////////////////////////////////////////// |
350 | 355 |
351 DValue* StringExp::toElem(IRState* p) | 356 DValue* StringExp::toElem(IRState* p) |
482 else | 487 else |
483 DtoAssign(l, r); | 488 DtoAssign(l, r); |
484 } | 489 } |
485 | 490 |
486 return l; | 491 return l; |
487 | |
488 /* | |
489 if (l->type == DValue::ARRAYLEN) | |
490 { | |
491 DtoResizeDynArray(l->mem, r->getValue()); | |
492 delete r; | |
493 delete l; | |
494 return 0; | |
495 } | |
496 | |
497 Type* e1type = DtoDType(e1->type); | |
498 Type* e2type = DtoDType(e2->type); | |
499 TY e1ty = e1type->ty; | |
500 TY e2ty = e2type->ty; | |
501 | |
502 DValue* e = new DValue(this); | |
503 e->type = DValue::VAR; | |
504 | |
505 // struct | |
506 if (e1ty == Tstruct) { | |
507 e->mem = l->mem; | |
508 // struct + struct | |
509 if (e2ty == Tstruct) { | |
510 // struct literals do the assignment themselvs (in place) | |
511 if (!r->inplace) { | |
512 DtoStructCopy(l->mem,r->getValue()); | |
513 } | |
514 else { | |
515 e->inplace = true; | |
516 } | |
517 } | |
518 // struct + const int | |
519 else if (e2type->isintegral()){ | |
520 IntegerExp* iexp = (IntegerExp*)e2; | |
521 assert(iexp->value == 0 && "Only integral struct initializer allowed is zero"); | |
522 DtoStructZeroInit(l->mem); | |
523 } | |
524 // :x | |
525 else | |
526 assert(0 && "struct = unknown"); | |
527 } | |
528 else if (e1ty == Tsarray) { | |
529 assert(0 && "static array not supported"); | |
530 } | |
531 else if (e1ty == Tarray) { | |
532 if (e2type->isscalar() || e2type->ty == Tclass){ | |
533 if (l->type == DValue::SLICE) { | |
534 DtoArrayInit(l->mem, l->arg, r->getValue()); | |
535 } | |
536 else { | |
537 DtoArrayInit(l->mem, r->getValue()); | |
538 } | |
539 } | |
540 else if (e2ty == Tarray) { | |
541 //new llvm::StoreInst(r->val,l->val,p->scopebb()); | |
542 if (r->type == DValue::NUL) { | |
543 llvm::Constant* c = llvm::cast<llvm::Constant>(r->val); | |
544 assert(c->isNullValue()); | |
545 DtoNullArray(l->mem); | |
546 e->mem = l->mem; | |
547 } | |
548 else if (r->type == DValue::SLICE) { | |
549 if (l->type == DValue::SLICE) { | |
550 DtoArrayCopy(l,r); | |
551 e->type = DValue::SLICE; | |
552 e->mem = l->mem; | |
553 e->arg = l->arg; | |
554 } | |
555 else { | |
556 DtoSetArray(l->mem,r->arg,r->mem); | |
557 e->mem = l->mem; | |
558 } | |
559 } | |
560 else { | |
561 // new expressions write directly to the array reference | |
562 // so do string literals | |
563 e->mem = l->mem; | |
564 if (!r->inplace) { | |
565 assert(r->mem); | |
566 DtoArrayAssign(l->mem, r->mem); | |
567 } | |
568 else { | |
569 e->inplace = true; | |
570 } | |
571 } | |
572 } | |
573 else | |
574 assert(0); | |
575 } | |
576 else if (e1ty == Tpointer) { | |
577 e->mem = l->mem; | |
578 if (e2ty == Tpointer) { | |
579 llvm::Value* v = r->field ? r->mem : r->getValue(); | |
580 Logger::cout() << "*=*: " << *v << ", " << *l->mem << '\n'; | |
581 new llvm::StoreInst(v, l->mem, p->scopebb()); | |
582 } | |
583 else | |
584 assert(0); | |
585 } | |
586 else if (e1ty == Tclass) { | |
587 if (e2ty == Tclass) { | |
588 llvm::Value* tmp = r->getValue(); | |
589 Logger::cout() << "tmp: " << *tmp << " ||| " << *l->mem << '\n'; | |
590 // assignment to this in constructor special case | |
591 if (l->isthis) { | |
592 FuncDeclaration* fdecl = p->func().decl; | |
593 // respecify the this param | |
594 if (!llvm::isa<llvm::AllocaInst>(fdecl->llvmThisVar)) | |
595 fdecl->llvmThisVar = new llvm::AllocaInst(tmp->getType(), "newthis", p->topallocapoint()); | |
596 new llvm::StoreInst(tmp, fdecl->llvmThisVar, p->scopebb()); | |
597 e->mem = fdecl->llvmThisVar; | |
598 } | |
599 // regular class ref -> class ref assignment | |
600 else { | |
601 new llvm::StoreInst(tmp, l->mem, p->scopebb()); | |
602 e->mem = l->mem; | |
603 } | |
604 } | |
605 else | |
606 assert(0); | |
607 } | |
608 else if (e1ty == Tdelegate) { | |
609 Logger::println("Assigning to delegate"); | |
610 if (e2ty == Tdelegate) { | |
611 if (r->type == DValue::NUL) { | |
612 llvm::Constant* c = llvm::cast<llvm::Constant>(r->val); | |
613 if (c->isNullValue()) { | |
614 DtoNullDelegate(l->mem); | |
615 e->mem = l->mem; | |
616 } | |
617 else | |
618 assert(0); | |
619 } | |
620 else if (r->inplace) { | |
621 // do nothing | |
622 e->inplace = true; | |
623 e->mem = l->mem; | |
624 } | |
625 else { | |
626 DtoDelegateCopy(l->mem, r->getValue()); | |
627 e->mem = l->mem; | |
628 } | |
629 } | |
630 else | |
631 assert(0); | |
632 } | |
633 // !struct && !array && !pointer && !class | |
634 else { | |
635 Logger::cout() << *l->mem << '\n'; | |
636 new llvm::StoreInst(r->getValue(),l->mem,p->scopebb()); | |
637 e->mem = l->mem; | |
638 } | |
639 | |
640 delete r; | |
641 delete l; | |
642 | |
643 return e; | |
644 */ | |
645 } | 492 } |
646 | 493 |
647 ////////////////////////////////////////////////////////////////////////////////////////// | 494 ////////////////////////////////////////////////////////////////////////////////////////// |
648 | 495 |
649 DValue* AddExp::toElem(IRState* p) | 496 DValue* AddExp::toElem(IRState* p) |
680 } | 527 } |
681 } | 528 } |
682 llvm::Value* v = new llvm::GetElementPtrInst(l->getRVal(), r->getRVal(), "tmp", p->scopebb()); | 529 llvm::Value* v = new llvm::GetElementPtrInst(l->getRVal(), r->getRVal(), "tmp", p->scopebb()); |
683 return new DImValue(type, v); | 530 return new DImValue(type, v); |
684 } | 531 } |
532 else if (t->iscomplex()) { | |
533 return DtoComplexAdd(type, l, r); | |
534 } | |
685 assert(0); | 535 assert(0); |
536 } | |
537 else if (t->iscomplex()) { | |
538 return DtoComplexAdd(type, l, r); | |
686 } | 539 } |
687 else { | 540 else { |
688 return DtoBinAdd(l,r); | 541 return DtoBinAdd(l,r); |
689 } | 542 } |
690 } | 543 } |
699 p->exps.push_back(IRExp(e1,e2,NULL)); | 552 p->exps.push_back(IRExp(e1,e2,NULL)); |
700 DValue* l = e1->toElem(p); | 553 DValue* l = e1->toElem(p); |
701 DValue* r = e2->toElem(p); | 554 DValue* r = e2->toElem(p); |
702 p->exps.pop_back(); | 555 p->exps.pop_back(); |
703 | 556 |
557 Type* t = DtoDType(type); | |
558 | |
704 DValue* res; | 559 DValue* res; |
705 if (DtoDType(e1->type)->ty == Tpointer) { | 560 if (DtoDType(e1->type)->ty == Tpointer) { |
706 llvm::Value* gep = new llvm::GetElementPtrInst(l->getRVal(),r->getRVal(),"tmp",p->scopebb()); | 561 llvm::Value* gep = new llvm::GetElementPtrInst(l->getRVal(),r->getRVal(),"tmp",p->scopebb()); |
707 res = new DImValue(type, gep); | 562 res = new DImValue(type, gep); |
708 } | 563 } |
564 else if (t->iscomplex()) { | |
565 res = DtoComplexAdd(type, l, r); | |
566 } | |
709 else { | 567 else { |
710 res = DtoBinAdd(l,r); | 568 res = DtoBinAdd(l,r); |
711 } | 569 } |
712 DtoAssign(l, res); | 570 DtoAssign(l, res); |
713 | 571 |
714 return l; | 572 return l; |
715 | |
716 /* | |
717 | |
718 Type* e1type = DtoDType(e1->type); | |
719 | |
720 DValue* e = new DValue(this); | |
721 llvm::Value* val = 0; | |
722 if (e1type->ty == Tpointer) { | |
723 val = e->mem = new llvm::GetElementPtrInst(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
724 } | |
725 else { | |
726 val = e->val = llvm::BinaryOperator::createAdd(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
727 } | |
728 | |
729 assert(l->mem); | |
730 new llvm::StoreInst(val,l->mem,p->scopebb()); | |
731 e->type = DValue::VAR; | |
732 | |
733 delete l; | |
734 delete r; | |
735 return e; | |
736 */ | |
737 } | 573 } |
738 | 574 |
739 ////////////////////////////////////////////////////////////////////////////////////////// | 575 ////////////////////////////////////////////////////////////////////////////////////////// |
740 | 576 |
741 DValue* MinExp::toElem(IRState* p) | 577 DValue* MinExp::toElem(IRState* p) |
743 Logger::print("MinExp::toElem: %s | %s\n", toChars(), type->toChars()); | 579 Logger::print("MinExp::toElem: %s | %s\n", toChars(), type->toChars()); |
744 LOG_SCOPE; | 580 LOG_SCOPE; |
745 | 581 |
746 DValue* l = e1->toElem(p); | 582 DValue* l = e1->toElem(p); |
747 DValue* r = e2->toElem(p); | 583 DValue* r = e2->toElem(p); |
584 | |
585 Type* t = DtoDType(type); | |
748 | 586 |
749 if (DtoDType(e1->type)->ty == Tpointer) { | 587 if (DtoDType(e1->type)->ty == Tpointer) { |
750 llvm::Value* lv = l->getRVal(); | 588 llvm::Value* lv = l->getRVal(); |
751 llvm::Value* rv = r->getRVal(); | 589 llvm::Value* rv = r->getRVal(); |
752 Logger::cout() << "lv: " << *lv << " rv: " << *rv << '\n'; | 590 Logger::cout() << "lv: " << *lv << " rv: " << *rv << '\n'; |
757 llvm::Value* diff = p->ir->CreateSub(lv,rv,"tmp"); | 595 llvm::Value* diff = p->ir->CreateSub(lv,rv,"tmp"); |
758 if (diff->getType() != DtoType(type)) | 596 if (diff->getType() != DtoType(type)) |
759 diff = p->ir->CreateIntToPtr(diff, DtoType(type)); | 597 diff = p->ir->CreateIntToPtr(diff, DtoType(type)); |
760 return new DImValue(type, diff); | 598 return new DImValue(type, diff); |
761 } | 599 } |
600 else if (t->iscomplex()) { | |
601 return DtoComplexSub(type, l, r); | |
602 } | |
762 else { | 603 else { |
763 return DtoBinSub(l,r); | 604 return DtoBinSub(l,r); |
764 } | 605 } |
765 | |
766 /* | |
767 llvm::Value* left = l->getValue(); | |
768 if (isaPointer(left->getType())) | |
769 left = new llvm::PtrToIntInst(left,DtoSize_t(),"tmp",p->scopebb()); | |
770 | |
771 llvm::Value* right = r->getValue(); | |
772 if (isaPointer(right->getType())) | |
773 right = new llvm::PtrToIntInst(right,DtoSize_t(),"tmp",p->scopebb()); | |
774 | |
775 e->val = llvm::BinaryOperator::createSub(left,right,"tmp",p->scopebb()); | |
776 e->type = DValue::VAL; | |
777 | |
778 const llvm::Type* totype = DtoType(type); | |
779 if (e->val->getType() != totype) { | |
780 assert(0); | |
781 assert(isaPointer(e->val->getType())); | |
782 assert(llvm::isa<llvm::IntegerType>(totype)); | |
783 e->val = new llvm::IntToPtrInst(e->val,totype,"tmp",p->scopebb()); | |
784 } | |
785 | |
786 delete l; | |
787 delete r; | |
788 return e; | |
789 */ | |
790 } | 606 } |
791 | 607 |
792 ////////////////////////////////////////////////////////////////////////////////////////// | 608 ////////////////////////////////////////////////////////////////////////////////////////// |
793 | 609 |
794 DValue* MinAssignExp::toElem(IRState* p) | 610 DValue* MinAssignExp::toElem(IRState* p) |
796 Logger::print("MinAssignExp::toElem: %s | %s\n", toChars(), type->toChars()); | 612 Logger::print("MinAssignExp::toElem: %s | %s\n", toChars(), type->toChars()); |
797 LOG_SCOPE; | 613 LOG_SCOPE; |
798 | 614 |
799 DValue* l = e1->toElem(p); | 615 DValue* l = e1->toElem(p); |
800 DValue* r = e2->toElem(p); | 616 DValue* r = e2->toElem(p); |
617 | |
618 Type* t = DtoDType(type); | |
801 | 619 |
802 DValue* res; | 620 DValue* res; |
803 if (DtoDType(e1->type)->ty == Tpointer) { | 621 if (DtoDType(e1->type)->ty == Tpointer) { |
804 llvm::Value* tmp = r->getRVal(); | 622 llvm::Value* tmp = r->getRVal(); |
805 llvm::Value* zero = llvm::ConstantInt::get(tmp->getType(),0,false); | 623 llvm::Value* zero = llvm::ConstantInt::get(tmp->getType(),0,false); |
806 tmp = llvm::BinaryOperator::createSub(zero,tmp,"tmp",p->scopebb()); | 624 tmp = llvm::BinaryOperator::createSub(zero,tmp,"tmp",p->scopebb()); |
807 tmp = new llvm::GetElementPtrInst(l->getRVal(),tmp,"tmp",p->scopebb()); | 625 tmp = new llvm::GetElementPtrInst(l->getRVal(),tmp,"tmp",p->scopebb()); |
808 res = new DImValue(type, tmp); | 626 res = new DImValue(type, tmp); |
809 } | 627 } |
628 else if (t->iscomplex()) { | |
629 res = DtoComplexSub(type, l, r); | |
630 } | |
810 else { | 631 else { |
811 res = DtoBinSub(l,r); | 632 res = DtoBinSub(l,r); |
812 } | 633 } |
813 DtoAssign(l, res); | 634 DtoAssign(l, res); |
814 | 635 |
815 return l; | 636 return l; |
816 | |
817 /* | |
818 | |
819 Type* e1type = DtoDType(e1->type); | |
820 | |
821 llvm::Value* tmp = 0; | |
822 if (e1type->ty == Tpointer) { | |
823 tmp = r->getValue(); | |
824 llvm::Value* zero = llvm::ConstantInt::get(tmp->getType(),0,false); | |
825 tmp = llvm::BinaryOperator::createSub(zero,tmp,"tmp",p->scopebb()); | |
826 tmp = new llvm::GetElementPtrInst(l->getValue(),tmp,"tmp",p->scopebb()); | |
827 } | |
828 else { | |
829 tmp = llvm::BinaryOperator::createSub(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
830 } | |
831 | |
832 assert(l->mem); | |
833 new llvm::StoreInst(tmp, l->mem, p->scopebb()); | |
834 | |
835 delete l; | |
836 delete r; | |
837 | |
838 DValue* e = new DValue(this); | |
839 e->val = tmp; | |
840 e->type = DValue::VAR; | |
841 return e; | |
842 */ | |
843 } | 637 } |
844 | 638 |
845 ////////////////////////////////////////////////////////////////////////////////////////// | 639 ////////////////////////////////////////////////////////////////////////////////////////// |
846 | 640 |
847 DValue* MulExp::toElem(IRState* p) | 641 DValue* MulExp::toElem(IRState* p) |
848 { | 642 { |
849 Logger::print("MulExp::toElem: %s\n", toChars()); | 643 Logger::print("MulExp::toElem: %s | %s\n", toChars(), type->toChars()); |
850 LOG_SCOPE; | 644 LOG_SCOPE; |
851 | 645 |
852 DValue* l = e1->toElem(p); | 646 DValue* l = e1->toElem(p); |
853 DValue* r = e2->toElem(p); | 647 DValue* r = e2->toElem(p); |
854 | 648 |
649 if (type->iscomplex()) { | |
650 return DtoComplexMul(type, l, r); | |
651 } | |
652 | |
855 return DtoBinMul(l,r); | 653 return DtoBinMul(l,r); |
856 /* | |
857 if (l->dvalue && r->dvalue) { | |
858 Logger::println("DVALUE PATH"); | |
859 e->dvalue = DtoBinMul(l->dvalue, r->dvalue); | |
860 e->val = e->dvalue->getRVal(); | |
861 } | |
862 else { | |
863 llvm::Value* vl = l->getValue(); | |
864 llvm::Value* vr = r->getValue(); | |
865 Logger::cout() << "mul: " << *vl << ", " << *vr << '\n'; | |
866 e->val = llvm::BinaryOperator::createMul(vl,vr,"tmp",p->scopebb()); | |
867 e->dvalue = new DImValue(type, e->val); | |
868 } | |
869 e->type = DValue::VAL; | |
870 delete l; | |
871 delete r; | |
872 return e; | |
873 */ | |
874 } | 654 } |
875 | 655 |
876 ////////////////////////////////////////////////////////////////////////////////////////// | 656 ////////////////////////////////////////////////////////////////////////////////////////// |
877 | 657 |
878 DValue* MulAssignExp::toElem(IRState* p) | 658 DValue* MulAssignExp::toElem(IRState* p) |
879 { | 659 { |
880 Logger::print("MulAssignExp::toElem: %s\n", toChars()); | 660 Logger::print("MulAssignExp::toElem: %s | %s\n", toChars(), type->toChars()); |
881 LOG_SCOPE; | 661 LOG_SCOPE; |
882 | 662 |
883 DValue* l = e1->toElem(p); | 663 DValue* l = e1->toElem(p); |
884 DValue* r = e2->toElem(p); | 664 DValue* r = e2->toElem(p); |
885 | 665 |
886 DValue* res = DtoBinMul(l,r); | 666 DValue* res; |
667 if (type->iscomplex()) { | |
668 res = DtoComplexMul(type, l, r); | |
669 } | |
670 else { | |
671 res = DtoBinMul(l,r); | |
672 } | |
887 DtoAssign(l, res); | 673 DtoAssign(l, res); |
888 | 674 |
889 return l; | 675 return l; |
890 | |
891 /* | |
892 llvm::Value* vl = l->getValue(); | |
893 llvm::Value* vr = r->getValue(); | |
894 Logger::cout() << "mulassign: " << *vl << ", " << *vr << '\n'; | |
895 llvm::Value* tmp = llvm::BinaryOperator::createMul(vl,vr,"tmp",p->scopebb()); | |
896 | |
897 assert(l->mem); | |
898 new llvm::StoreInst(tmp,l->mem,p->scopebb()); | |
899 | |
900 delete l; | |
901 delete r; | |
902 | |
903 DValue* e = new DValue(this); | |
904 e->val = tmp; | |
905 e->type = DValue::VAR; | |
906 return e; | |
907 */ | |
908 } | 676 } |
909 | 677 |
910 ////////////////////////////////////////////////////////////////////////////////////////// | 678 ////////////////////////////////////////////////////////////////////////////////////////// |
911 | 679 |
912 DValue* DivExp::toElem(IRState* p) | 680 DValue* DivExp::toElem(IRState* p) |
913 { | 681 { |
914 Logger::print("DivExp::toElem: %s\n", toChars()); | 682 Logger::print("DivExp::toElem: %s | %s\n", toChars(), type->toChars()); |
915 LOG_SCOPE; | 683 LOG_SCOPE; |
916 | 684 |
917 DValue* l = e1->toElem(p); | 685 DValue* l = e1->toElem(p); |
918 DValue* r = e2->toElem(p); | 686 DValue* r = e2->toElem(p); |
919 | 687 |
688 if (type->iscomplex()) { | |
689 return DtoComplexDiv(type, l, r); | |
690 } | |
691 | |
920 return DtoBinDiv(l, r); | 692 return DtoBinDiv(l, r); |
921 /* | |
922 | |
923 Type* t = DtoDType(type); | |
924 | |
925 if (t->isunsigned()) | |
926 e->val = llvm::BinaryOperator::createUDiv(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
927 else if (t->isintegral()) | |
928 e->val = llvm::BinaryOperator::createSDiv(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
929 else if (t->isfloating()) | |
930 e->val = llvm::BinaryOperator::createFDiv(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
931 else | |
932 assert(0); | |
933 e->type = DValue::VAL; | |
934 delete l; | |
935 delete r; | |
936 return e; | |
937 */ | |
938 } | 693 } |
939 | 694 |
940 ////////////////////////////////////////////////////////////////////////////////////////// | 695 ////////////////////////////////////////////////////////////////////////////////////////// |
941 | 696 |
942 DValue* DivAssignExp::toElem(IRState* p) | 697 DValue* DivAssignExp::toElem(IRState* p) |
943 { | 698 { |
944 Logger::print("DivAssignExp::toElem: %s\n", toChars()); | 699 Logger::print("DivAssignExp::toElem: %s | %s\n", toChars(), type->toChars()); |
945 LOG_SCOPE; | 700 LOG_SCOPE; |
946 | 701 |
947 DValue* l = e1->toElem(p); | 702 DValue* l = e1->toElem(p); |
948 DValue* r = e2->toElem(p); | 703 DValue* r = e2->toElem(p); |
949 | 704 |
950 DValue* res = DtoBinDiv(l,r); | 705 DValue* res; |
706 if (type->iscomplex()) { | |
707 res = DtoComplexDiv(type, l, r); | |
708 } | |
709 else { | |
710 res = DtoBinDiv(l,r); | |
711 } | |
951 DtoAssign(l, res); | 712 DtoAssign(l, res); |
952 | 713 |
953 return l; | 714 return l; |
954 | |
955 /* | |
956 | |
957 Type* t = DtoDType(type); | |
958 | |
959 llvm::Value* tmp; | |
960 if (t->isunsigned()) | |
961 tmp = llvm::BinaryOperator::createUDiv(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
962 else if (t->isintegral()) | |
963 tmp = llvm::BinaryOperator::createSDiv(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
964 else if (t->isfloating()) | |
965 tmp = llvm::BinaryOperator::createFDiv(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
966 else | |
967 assert(0); | |
968 | |
969 assert(l->mem); | |
970 new llvm::StoreInst(tmp,l->mem,p->scopebb()); | |
971 | |
972 delete l; | |
973 delete r; | |
974 | |
975 DValue* e = new DValue(this); | |
976 e->val = tmp; | |
977 e->type = DValue::VAR; | |
978 return e; | |
979 */ | |
980 } | 715 } |
981 | 716 |
982 ////////////////////////////////////////////////////////////////////////////////////////// | 717 ////////////////////////////////////////////////////////////////////////////////////////// |
983 | 718 |
984 DValue* ModExp::toElem(IRState* p) | 719 DValue* ModExp::toElem(IRState* p) |
985 { | 720 { |
986 Logger::print("ModExp::toElem: %s\n", toChars()); | 721 Logger::print("ModExp::toElem: %s | %s\n", toChars(), type->toChars()); |
987 LOG_SCOPE; | 722 LOG_SCOPE; |
988 | 723 |
989 DValue* l = e1->toElem(p); | 724 DValue* l = e1->toElem(p); |
990 DValue* r = e2->toElem(p); | 725 DValue* r = e2->toElem(p); |
991 | 726 |
992 return DtoBinRem(l, r); | 727 return DtoBinRem(l, r); |
993 /* | |
994 Type* t = DtoDType(type); | |
995 | |
996 if (t->isunsigned()) | |
997 e->val = llvm::BinaryOperator::createURem(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
998 else if (t->isintegral()) | |
999 e->val = llvm::BinaryOperator::createSRem(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
1000 else if (t->isfloating()) | |
1001 e->val = llvm::BinaryOperator::createFRem(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
1002 else | |
1003 assert(0); | |
1004 e->type = DValue::VAL; | |
1005 delete l; | |
1006 delete r; | |
1007 return e; | |
1008 */ | |
1009 } | 728 } |
1010 | 729 |
1011 ////////////////////////////////////////////////////////////////////////////////////////// | 730 ////////////////////////////////////////////////////////////////////////////////////////// |
1012 | 731 |
1013 DValue* ModAssignExp::toElem(IRState* p) | 732 DValue* ModAssignExp::toElem(IRState* p) |
1014 { | 733 { |
1015 Logger::print("ModAssignExp::toElem: %s\n", toChars()); | 734 Logger::print("ModAssignExp::toElem: %s | %s\n", toChars(), type->toChars()); |
1016 LOG_SCOPE; | 735 LOG_SCOPE; |
1017 | 736 |
1018 DValue* l = e1->toElem(p); | 737 DValue* l = e1->toElem(p); |
1019 DValue* r = e2->toElem(p); | 738 DValue* r = e2->toElem(p); |
1020 | 739 |
1021 DValue* res = DtoBinRem(l, r); | 740 DValue* res = DtoBinRem(l, r); |
1022 DtoAssign(l, res); | 741 DtoAssign(l, res); |
1023 | 742 |
1024 return l; | 743 return l; |
1025 | |
1026 /* | |
1027 | |
1028 Type* t = DtoDType(type); | |
1029 | |
1030 llvm::Value* tmp; | |
1031 if (t->isunsigned()) | |
1032 tmp = llvm::BinaryOperator::createURem(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
1033 else if (t->isintegral()) | |
1034 tmp = llvm::BinaryOperator::createSRem(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
1035 else if (t->isfloating()) | |
1036 tmp = llvm::BinaryOperator::createFRem(l->getValue(),r->getValue(),"tmp",p->scopebb()); | |
1037 else | |
1038 assert(0); | |
1039 | |
1040 assert(l->mem); | |
1041 new llvm::StoreInst(tmp,l->mem,p->scopebb()); | |
1042 | |
1043 delete l; | |
1044 delete r; | |
1045 | |
1046 DValue* e = new DValue(this); | |
1047 e->val = tmp; | |
1048 e->type = DValue::VAR; | |
1049 return e; | |
1050 */ | |
1051 } | 744 } |
1052 | 745 |
1053 ////////////////////////////////////////////////////////////////////////////////////////// | 746 ////////////////////////////////////////////////////////////////////////////////////////// |
1054 | 747 |
1055 DValue* CallExp::toElem(IRState* p) | 748 DValue* CallExp::toElem(IRState* p) |
1056 { | 749 { |
1057 Logger::print("CallExp::toElem: %s\n", toChars()); | 750 Logger::print("CallExp::toElem: %s | %s\n", toChars(), type->toChars()); |
1058 LOG_SCOPE; | 751 LOG_SCOPE; |
1059 | 752 |
1060 DValue* fn = e1->toElem(p); | 753 DValue* fn = e1->toElem(p); |
1061 | 754 |
1062 TypeFunction* tf = 0; | 755 TypeFunction* tf = 0; |
1878 default: | 1571 default: |
1879 assert(0); | 1572 assert(0); |
1880 } | 1573 } |
1881 eval = new llvm::ICmpInst(cmpop, l->getRVal(), r->getRVal(), "tmp", p->scopebb()); | 1574 eval = new llvm::ICmpInst(cmpop, l->getRVal(), r->getRVal(), "tmp", p->scopebb()); |
1882 } | 1575 } |
1576 else if (t->iscomplex()) | |
1577 { | |
1578 Logger::println("complex"); | |
1579 eval = DtoComplexEquals(op, l, r); | |
1580 } | |
1883 else if (t->isfloating()) | 1581 else if (t->isfloating()) |
1884 { | 1582 { |
1885 Logger::println("floating"); | 1583 Logger::println("floating"); |
1886 llvm::FCmpInst::Predicate cmpop; | 1584 llvm::FCmpInst::Predicate cmpop; |
1887 switch(op) | 1585 switch(op) |
2437 | 2135 |
2438 llvm::Value* zero = 0; | 2136 llvm::Value* zero = 0; |
2439 if (t->isintegral()) | 2137 if (t->isintegral()) |
2440 zero = llvm::ConstantInt::get(val->getType(), 0, true); | 2138 zero = llvm::ConstantInt::get(val->getType(), 0, true); |
2441 else if (t->isfloating()) { | 2139 else if (t->isfloating()) { |
2442 if (t->ty == Tfloat32) | 2140 if (t->ty == Tfloat32 || t->ty == Timaginary32) |
2443 zero = llvm::ConstantFP::get(val->getType(), float(0)); | 2141 zero = llvm::ConstantFP::get(val->getType(), float(0)); |
2444 else if (t->ty == Tfloat64 || t->ty == Tfloat80) | 2142 else if (t->ty == Tfloat64 || t->ty == Tfloat80 || t->ty == Timaginary64 || t->ty == Timaginary80) |
2445 zero = llvm::ConstantFP::get(val->getType(), double(0)); | 2143 zero = llvm::ConstantFP::get(val->getType(), double(0)); |
2446 else | 2144 else |
2447 assert(0); | 2145 assert(0); |
2448 } | 2146 } |
2449 else | 2147 else |