Mercurial > projects > ldc

comparison gen/arrays.c @ 40:8b0e809563df trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn r44] Lots of bug fixes. New array literal support New array ~= operator support (for single element) New with statement support More...
author lindquist
date Fri, 19 Oct 2007 07:43:21 +0200
parents 77cdca8c210f
children eb7bf7b7972e
comparison
equal deleted inserted replaced
39:fd5e8bbfcb25 40:8b0e809563df
1 #include "llvm/Constants.h" 1 #include "gen/llvm.h"
2 #include "llvm/Type.h"
3 #include "llvm/DerivedTypes.h"
4 #include "llvm/Instructions.h"
5 #include "llvm/CallingConv.h"
6 2
7 #include "mtype.h" 3 #include "mtype.h"
8 #include "dsymbol.h" 4 #include "dsymbol.h"
9 #include "aggregate.h" 5 #include "aggregate.h"
10 #include "declaration.h" 6 #include "declaration.h"
216 llvm::Value* arrptr = LLVM_DtoGEP(arr,zero,one,"tmp",gIR->scopebb()); 212 llvm::Value* arrptr = LLVM_DtoGEP(arr,zero,one,"tmp",gIR->scopebb());
217 new llvm::StoreInst(ptr, arrptr, gIR->scopebb()); 213 new llvm::StoreInst(ptr, arrptr, gIR->scopebb());
218 } 214 }
219 215
220 ////////////////////////////////////////////////////////////////////////////////////////// 216 //////////////////////////////////////////////////////////////////////////////////////////
221 llvm::Constant* LLVM_DtoArrayInitializer(ArrayInitializer* arrinit) 217 llvm::Constant* LLVM_DtoConstArrayInitializer(ArrayInitializer* arrinit)
222 { 218 {
223 Logger::println("arr init begin"); 219 Logger::println("arr init begin");
224 assert(arrinit->type->ty == Tsarray); 220 Type* arrinittype = LLVM_DtoDType(arrinit->type);
225 TypeSArray* t = (TypeSArray*)arrinit->type; 221 assert(arrinittype->ty == Tsarray);
222 TypeSArray* t = (TypeSArray*)arrinittype;
226 integer_t tdim = t->dim->toInteger(); 223 integer_t tdim = t->dim->toInteger();
227 224
228 std::vector<llvm::Constant*> inits(tdim, 0); 225 std::vector<llvm::Constant*> inits(tdim, 0);
229 226
230 const llvm::Type* elemty = LLVM_DtoType(arrinit->type->next); 227 const llvm::Type* elemty = LLVM_DtoType(arrinittype->next);
231 228
232 assert(arrinit->index.dim == arrinit->value.dim); 229 assert(arrinit->index.dim == arrinit->value.dim);
233 for (int i=0,j=0; i < tdim; ++i) 230 for (int i=0,j=0; i < tdim; ++i)
234 { 231 {
235 Initializer* init = 0; 232 Initializer* init = 0;
253 250
254 llvm::Constant* v = 0; 251 llvm::Constant* v = 0;
255 252
256 if (!init) 253 if (!init)
257 { 254 {
258 elem* e = t->next->defaultInit()->toElem(gIR); 255 v = t->next->defaultInit()->toConstElem(gIR);
259 v = llvm::cast<llvm::Constant>(e->val);
260 delete e;
261 } 256 }
262 else if (ExpInitializer* ex = init->isExpInitializer()) 257 else if (ExpInitializer* ex = init->isExpInitializer())
263 { 258 {
264 elem* e = ex->exp->toElem(gIR); 259 v = ex->exp->toConstElem(gIR);
265 v = llvm::cast<llvm::Constant>(e->val);
266 delete e;
267 } 260 }
268 else if (StructInitializer* si = init->isStructInitializer()) 261 else if (StructInitializer* si = init->isStructInitializer())
269 { 262 {
270 v = LLVM_DtoStructInitializer(si); 263 v = LLVM_DtoConstStructInitializer(si);
271 } 264 }
272 else if (ArrayInitializer* ai = init->isArrayInitializer()) 265 else if (ArrayInitializer* ai = init->isArrayInitializer())
273 { 266 {
274 v = LLVM_DtoArrayInitializer(ai); 267 v = LLVM_DtoConstArrayInitializer(ai);
275 } 268 }
276 else if (init->isVoidInitializer()) 269 else if (init->isVoidInitializer())
277 { 270 {
278 v = llvm::UndefValue::get(elemty); 271 v = llvm::UndefValue::get(elemty);
279 } 272 }
413 406
414 llvm::Value* len = LLVM_DtoGEPi(arr, 0, 0, "tmp", gIR->scopebb()); 407 llvm::Value* len = LLVM_DtoGEPi(arr, 0, 0, "tmp", gIR->scopebb());
415 new llvm::StoreInst(sz,len,gIR->scopebb()); 408 new llvm::StoreInst(sz,len,gIR->scopebb());
416 } 409 }
417 410
411 //////////////////////////////////////////////////////////////////////////////////////////
412 void LLVM_DtoCatArrayElement(llvm::Value* arr, Expression* exp)
413 {
414 llvm::Value* ptr = LLVM_DtoGEPi(arr, 0, 0, "tmp", gIR->scopebb());
415 llvm::Value* idx = new llvm::LoadInst(ptr, "tmp", gIR->scopebb());
416 llvm::Value* one = llvm::ConstantInt::get(idx->getType(),1,false);
417 llvm::Value* len = llvm::BinaryOperator::createAdd(idx, one, "tmp", gIR->scopebb());
418 LLVM_DtoResizeDynArray(arr,len);
419
420 ptr = LLVM_DtoGEPi(arr, 0, 1, "tmp", gIR->scopebb());
421 ptr = new llvm::LoadInst(ptr, "tmp", gIR->scopebb());
422 ptr = new llvm::GetElementPtrInst(ptr, idx, "tmp", gIR->scopebb());
423
424 elem* e = exp->toElem(gIR);
425 Type* et = LLVM_DtoDType(exp->type);
426
427 if (et->ty == Tstruct) {
428 TypeStruct* ts = (TypeStruct*)et;
429 LLVM_DtoStructCopy(ts,ptr,e->getValue());
430 }
431 else {
432 llvm::Value* val = e->getValue();
433 Logger::cout() << "ptr = '" << *ptr << "' element = '" << *val << "'\n";
434 new llvm::StoreInst(val, ptr, gIR->scopebb());
435 }
436 }
437
438 //////////////////////////////////////////////////////////////////////////////////////////
439 llvm::Value* LLVM_DtoStaticArrayCompare(TOK op, llvm::Value* l, llvm::Value* r)
440 {
441 const char* fname;
442 if (op == TOKequal)
443 fname = "_d_static_array_eq";
444 else if (op == TOKnotequal)
445 fname = "_d_static_array_neq";
446 else
447 assert(0);
448 llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, fname);
449 assert(fn);
450
451 assert(l->getType() == r->getType());
452 assert(llvm::isa<llvm::PointerType>(l->getType()));
453 const llvm::Type* arrty = l->getType()->getContainedType(0);
454 assert(llvm::isa<llvm::ArrayType>(arrty));
455
456 llvm::Value* ll = new llvm::BitCastInst(l, llvm::PointerType::get(llvm::Type::Int8Ty), "tmp", gIR->scopebb());
457 llvm::Value* rr = new llvm::BitCastInst(r, llvm::PointerType::get(llvm::Type::Int8Ty), "tmp", gIR->scopebb());
458 llvm::Value* n = llvm::ConstantInt::get(LLVM_DtoSize_t(),gTargetData->getTypeSize(arrty),false);
459
460 std::vector<llvm::Value*> args;
461 args.push_back(ll);
462 args.push_back(rr);
463 args.push_back(n);
464 return new llvm::CallInst(fn, args.begin(), args.end(), "tmp", gIR->scopebb());
465 }
466
467 //////////////////////////////////////////////////////////////////////////////////////////
468