Mercurial > projects > ldc

comparison gen/toir.c @ 34:4648206ca213 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r38] * resizing dynamic arrays support * throw is replaced with assert(0) * catch is ignored * better foreach support * various bugfixes
author lindquist
date Tue, 09 Oct 2007 02:50:00 +0200
parents a86fe7496b58
children c0967c4b2a74
comparison
equal deleted inserted replaced
33:bc641b23a714 34:4648206ca213
116 { 116 {
117 tid->toObjFile(); 117 tid->toObjFile();
118 e->mem = tid->llvmValue; 118 e->mem = tid->llvmValue;
119 e->type = elem::VAR; 119 e->type = elem::VAR;
120 } 120 }
121 else 121 else {
122 assert(0 && "only magic supported is typeinfo"); 122 Logger::println("unsupported: %s\n", vd->toChars());
123 assert(0 && "only magic supported is typeinfo");
124 }
123 } 125 }
124 return e; 126 return e;
125 } 127 }
126 128
127 // function parameter 129 // function parameter
329 331
330 p->lvals.push_back(l->mem); 332 p->lvals.push_back(l->mem);
331 elem* r = e2->toElem(p); 333 elem* r = e2->toElem(p);
332 p->lvals.pop_back(); 334 p->lvals.pop_back();
333 335
336 if (l->type == elem::ARRAYLEN)
337 {
338 LLVM_DtoResizeDynArray(l->mem, r->getValue());
339 delete r;
340 delete l;
341 return 0;
342 }
343
334 // handle function argument - allocate temp storage for it :/ annoying 344 // handle function argument - allocate temp storage for it :/ annoying
335 if (l->mem == 0) { 345 if (l->mem == 0) {
336 LLVM_DtoGiveArgumentStorage(l); 346 assert(l->val);
347 if (llvm::isa<llvm::Argument>(l->val))
348 LLVM_DtoGiveArgumentStorage(l);
349 else {
350 Logger::cout() << "here it comes... " << *l->val << '\n';
351 assert(0);
352 }
337 } 353 }
338 //e->val = l->store(r->getValue()); 354 //e->val = l->store(r->getValue());
339 355
340 TY e1ty = e1->type->ty; 356 TY e1ty = e1->type->ty;
341 TY e2ty = e2->type->ty; 357 TY e2ty = e2->type->ty;
1824 t = LLVM_DtoType(newtype->next); 1840 t = LLVM_DtoType(newtype->next);
1825 assert(arguments); 1841 assert(arguments);
1826 if (arguments->dim == 1) { 1842 if (arguments->dim == 1) {
1827 elem* sz = ((Expression*)arguments->data[0])->toElem(p); 1843 elem* sz = ((Expression*)arguments->data[0])->toElem(p);
1828 llvm::Value* dimval = sz->getValue(); 1844 llvm::Value* dimval = sz->getValue();
1829 llvm::Value* usedimval = dimval; 1845 /*llvm::Value* usedimval = dimval;
1830 if (dimval->getType() != llvm::Type::Int32Ty) 1846 if (dimval->getType() != llvm::Type::Int32Ty)
1831 usedimval = new llvm::TruncInst(dimval, llvm::Type::Int32Ty,"tmp",p->scopebb()); 1847 usedimval = new llvm::TruncInst(dimval, llvm::Type::Int32Ty,"tmp",p->scopebb());*/
1832 e->mem = new llvm::MallocInst(t,usedimval,"tmp",p->scopebb()); 1848
1833 1849 //e->mem = LLVM_DtoRealloc(0,t);
1834 LLVM_DtoSetArray(p->toplval(), dimval, e->mem); 1850 //new llvm::MallocInst(t,usedimval,"tmp",p->scopebb());
1851
1852 //LLVM_DtoSetArray(p->toplval(), dimval, e->mem);
1853
1854 LLVM_DtoNewDynArray(p->toplval(), dimval, t);
1835 delete sz; 1855 delete sz;
1836 } 1856 }
1837 else { 1857 else {
1838 assert(0); 1858 assert(0);
1839 } 1859 }
1946 LOG_SCOPE; 1966 LOG_SCOPE;
1947 1967
1948 elem* e = new elem; 1968 elem* e = new elem;
1949 elem* u = e1->toElem(p); 1969 elem* u = e1->toElem(p);
1950 1970
1951 llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 1971 if (p->inLvalue)
1952 llvm::Value* ptr = LLVM_DtoGEP(u->mem,zero,zero,"tmp",p->scopebb()); 1972 {
1953 e->val = new llvm::LoadInst(ptr, "tmp", p->scopebb()); 1973 e->mem = u->mem;
1954 e->type = elem::VAL; 1974 e->type = elem::ARRAYLEN;
1955 1975 }
1976 else
1977 {
1978 llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false);
1979 llvm::Value* ptr = LLVM_DtoGEP(u->mem,zero,zero,"tmp",p->scopebb());
1980 e->val = new llvm::LoadInst(ptr, "tmp", p->scopebb());
1981 e->type = elem::VAL;
1982 }
1956 delete u; 1983 delete u;
1957 1984
1958 return e; 1985 return e;
1959 } 1986 }
1960 1987
1963 elem* AssertExp::toElem(IRState* p) 1990 elem* AssertExp::toElem(IRState* p)
1964 { 1991 {
1965 Logger::print("AssertExp::toElem: %s | %s\n", toChars(), type->toChars()); 1992 Logger::print("AssertExp::toElem: %s | %s\n", toChars(), type->toChars());
1966 LOG_SCOPE; 1993 LOG_SCOPE;
1967 1994
1968 elem* e = new elem;
1969 elem* u = e1->toElem(p); 1995 elem* u = e1->toElem(p);
1970 elem* m = msg ? msg->toElem(p) : 0; 1996 elem* m = msg ? msg->toElem(p) : NULL;
1971 1997
1972 std::vector<llvm::Value*> llargs; 1998 llvm::Value* loca = llvm::ConstantInt::get(llvm::Type::Int32Ty, loc.linnum, false);
1973 llargs.resize(3); 1999 LLVM_DtoAssert(u->getValue(), loca, m ? m->val : NULL);
1974 llargs[0] = LLVM_DtoBoolean(u->getValue()); 2000
1975 llargs[1] = llvm::ConstantInt::get(llvm::Type::Int32Ty, loc.linnum, false);
1976 llargs[2] = m ? m->val : llvm::ConstantPointerNull::get(llvm::PointerType::get(llvm::Type::Int8Ty));
1977
1978 delete m; 2001 delete m;
1979 delete u; 2002 delete u;
1980 2003
1981 //Logger::cout() << *llargs[0] << '|' << *llargs[1] << '\n'; 2004 return new elem;
1982
1983 llvm::Function* fn = LLVM_D_GetRuntimeFunction(p->module, "_d_assert");
1984 assert(fn);
1985 llvm::CallInst* call = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", p->scopebb());
1986 call->setCallingConv(llvm::CallingConv::C);
1987
1988 return e;
1989 } 2005 }
1990 2006
1991 ////////////////////////////////////////////////////////////////////////////////////////// 2007 //////////////////////////////////////////////////////////////////////////////////////////
1992 2008
1993 elem* NotExp::toElem(IRState* p) 2009 elem* NotExp::toElem(IRState* p)