Mercurial > projects > ldc

comparison gen/toir.cpp @ 104:4d1e9eb001e0 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[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