Wiki Roadmap Timeline Tickets New Ticket Source Search Help / Guide About Trac Login

Changeset 4:e116aa1488e6

Show
Ignore:
Timestamp:
09/03/07 11:34:30 (1 year ago)
Author:
lindquist
branch:
trunk
Message:

[svn r8] changed backend includes to always use the gen/<foo>.h prefix
fixed passing string literals as array parameters
few other fixes
moved some array routines into gen/arrays

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • gen/elem.c

    r1 r4  
    33#include "llvm/Instructions.h" 
    44 
    5 #include "elem.h" 
    6  
    7 #include "irstate.h" 
    8 #include "logger.h" 
     5#include "gen/elem.h" 
     6#include "gen/irstate.h" 
     7#include "gen/logger.h" 
    98 
    109////////////////////////////////////////////////////////////////////////////////////////// 

  • gen/irstate.c

    r1 r4  
    55 */ 
    66 
    7 #include "irstate.h" 
    8  
    97#include "mtype.h" 
     8#include "gen/irstate.h" 
    109 
    1110IRState* gIR = 0; 

  • gen/logger.c

    r1 r4  
    88#include <string> 
    99 
    10 #include "logger.h" 
     10#include "gen/logger.h" 
    1111 
    1212namespace Logger 

  • gen/runtime.c

    r1 r4  
    55#include "llvm/Support/MemoryBuffer.h" 
    66 
    7 #include "runtime.h" 
    8 #include "logger.h" 
    9  
    107#include "root.h" 
    118#include "mars.h" 
     9 
     10#include "gen/runtime.h" 
     11#include "gen/logger.h" 
    1212 
    1313static llvm::Module* M = NULL; 

  • gen/toir.c

    r1 r4  
    2525#include "mtype.h" 
    2626#include "hdrgen.h" 
    27 #include "irstate.h" 
    28 #include "elem.h" 
    2927#include "port.h" 
    30 #include "logger.h" 
    31  
    32 #include "tollvm.h" 
    33 #include "runtime.h" 
     28 
     29#include "gen/irstate.h" 
     30#include "gen/elem.h" 
     31#include "gen/logger.h" 
     32#include "gen/tollvm.h" 
     33#include "gen/runtime.h" 
     34#include "gen/arrays.h" 
    3435 
    3536////////////////////////////////////////////////////////////////////////////////////////// 
    …… 
    256257 
    257258    if (type->ty == Tarray) { 
    258         llvm::Value* arr = p->toplval(); 
    259         LLVM_DtoSetArray(arr, llvm::ConstantInt::get(LLVM_DtoSize_t(),len,false), arrptr); 
     259        llvm::Constant* clen = llvm::ConstantInt::get(LLVM_DtoSize_t(),len,false); 
     260        if (p->lvals.empty()) { 
     261            e->type = elem::SLICE; 
     262            e->arg = clen; 
     263            e->mem = arrptr; 
     264            return e; 
     265        } 
     266        else { 
     267            llvm::Value* arr = p->toplval(); 
     268            LLVM_DtoSetArray(arr, clen, arrptr); 
     269        } 
    260270    } 
    261271    else if (type->ty == Tpointer) { 
    …… 
    880890                llvm::BasicBlock* entryblock = &p->topfunc()->front(); 
    881891                const llvm::PointerType* pty = llvm::cast<llvm::PointerType>(arg->mem->getType()); 
    882                 allocaInst = new llvm::AllocaInst(pty->getElementType(), "tmpparam", p->topallocapoint()); 
    883892                if (argty == Tstruct) { 
     893                    allocaInst = new llvm::AllocaInst(pty->getElementType(), "tmpparam", p->topallocapoint()); 
    884894                    TypeStruct* ts = (TypeStruct*)argexp->type; 
    885895                    LLVM_DtoStructCopy(ts,allocaInst,arg->mem); 
    886896                } 
    887897                else if (argty == Tdelegate) { 
     898                    allocaInst = new llvm::AllocaInst(pty->getElementType(), "tmpparam", p->topallocapoint()); 
    888899                    LLVM_DtoDelegateCopy(allocaInst,arg->mem); 
    889900                } 
    890901                else if (argty == Tarray) { 
    891                     LLVM_DtoArrayAssign(allocaInst,arg->mem); 
     902                    if (arg->type == elem::SLICE) { 
     903                        allocaInst = new llvm::AllocaInst(LLVM_DtoType(argexp->type), "tmpparam", p->topallocapoint()); 
     904                        LLVM_DtoSetArray(allocaInst, arg->arg, arg->mem); 
     905                    } 
     906                    else { 
     907                        allocaInst = new llvm::AllocaInst(pty->getElementType(), "tmpparam", p->topallocapoint()); 
     908                        LLVM_DtoArrayAssign(allocaInst,arg->mem); 
     909                    } 
    892910                } 
    893911                else 
    …… 
    10401058            else { 
    10411059                llvm::Value* uval = u->getValue(); 
    1042                 llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
    1043                 llvm::Value* one = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1, false); 
    1044                 e->arg = new llvm::GetElementPtrInst(uval,zero,zero,"tmp",p->scopebb()); 
    1045                 e->arg = new llvm::LoadInst(e->arg, "tmp", p->scopebb()); 
    1046  
    1047                 e->mem = new llvm::GetElementPtrInst(uval,zero,one,"tmp",p->scopebb()); 
    1048                 e->mem = new llvm::LoadInst(e->mem, "tmp", p->scopebb()); 
    1049                 e->mem = new llvm::BitCastInst(e->mem, ptrty, "tmp", p->scopebb()); 
     1060                if (from->ty == Tsarray) { 
     1061                    Logger::cout() << "uvalTy = " << *uval->getType() << '\n'; 
     1062                    assert(llvm::isa<llvm::PointerType>(uval->getType())); 
     1063                    const llvm::ArrayType* arrty = llvm::cast<llvm::ArrayType>(uval->getType()->getContainedType(0)); 
     1064                    e->arg = llvm::ConstantInt::get(LLVM_DtoSize_t(), arrty->getNumElements(), false); 
     1065                    e->mem = new llvm::BitCastInst(uval, ptrty, "tmp", p->scopebb()); 
     1066                } 
     1067                else { 
     1068                    llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
     1069                    llvm::Value* one = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1, false); 
     1070                    e->arg = new llvm::GetElementPtrInst(uval,zero,zero,"tmp",p->scopebb()); 
     1071                    e->arg = new llvm::LoadInst(e->arg, "tmp", p->scopebb()); 
     1072 
     1073                    e->mem = new llvm::GetElementPtrInst(uval,zero,one,"tmp",p->scopebb()); 
     1074                    e->mem = new llvm::LoadInst(e->mem, "tmp", p->scopebb()); 
     1075                    //Logger::cout() << *e->mem->getType() << '|' << *ptrty << '\n'; 
     1076                    e->mem = new llvm::BitCastInst(e->mem, ptrty, "tmp", p->scopebb()); 
     1077                } 
    10501078            } 
    10511079            e->type = elem::SLICE; 
    …… 
    11121140        } 
    11131141        else if (offset == 0) { 
    1114             vd->toObjFile(); 
     1142            /*if (!vd->llvmValue) 
     1143                vd->toObjFile();*/ 
     1144            assert(vd->llvmValue); 
    11151145            e = new elem; 
    11161146            e->mem = vd->llvmValue; 

  • gen/tollvm.c

    r1 r4  
    1414#include "init.h" 
    1515 
    16 #include "tollvm.h" 
    17 #include "irstate.h" 
    18 #include "logger.h" 
    19 #include "runtime.h" 
    20 #include "elem.h" 
     16#include "gen/tollvm.h" 
     17#include "gen/irstate.h" 
     18#include "gen/logger.h" 
     19#include "gen/runtime.h" 
     20#include "gen/elem.h" 
     21#include "gen/arrays.h" 
    2122 
    2223const llvm::Type* LLVM_DtoType(Type* t) 
    …… 
    313314} 
    314315 
    315 ////////////////////////////////////////////////////////////////////////////////////////// 
    316  
    317 llvm::StructType* LLVM_DtoArrayType(Type* t) 
    318 { 
    319     assert(t->next); 
    320     const llvm::Type* at = LLVM_DtoType(t->next); 
    321     const llvm::Type* arrty; 
    322  
    323     /*if (t->ty == Tsarray) { 
    324         TypeSArray* tsa = (TypeSArray*)t; 
    325         assert(tsa->dim->type->isintegral()); 
    326         arrty = llvm::ArrayType::get(at,tsa->dim->toUInteger()); 
    327     } 
    328     else { 
    329         arrty = llvm::ArrayType::get(at,0); 
    330     }*/ 
    331     if (at == llvm::Type::VoidTy) { 
    332         at = llvm::Type::Int8Ty; 
    333     } 
    334     arrty = llvm::PointerType::get(at); 
    335  
    336     std::vector<const llvm::Type*> members; 
    337     if (global.params.is64bit) 
    338         members.push_back(llvm::Type::Int64Ty); 
    339     else 
    340         members.push_back(llvm::Type::Int32Ty); 
    341  
    342     members.push_back(arrty); 
    343  
    344     return llvm::StructType::get(members); 
    345 } 
    346  
    347 ////////////////////////////////////////////////////////////////////////////////////////// 
    348  
    349 llvm::ArrayType* LLVM_DtoStaticArrayType(Type* t) 
    350 { 
    351     if (t->llvmType) 
    352         return llvm::cast<llvm::ArrayType>(t->llvmType); 
    353  
    354     assert(t->ty == Tsarray); 
    355     assert(t->next); 
    356  
    357     const llvm::Type* at = LLVM_DtoType(t->next); 
    358  
    359     TypeSArray* tsa = (TypeSArray*)t; 
    360     assert(tsa->dim->type->isintegral()); 
    361     llvm::ArrayType* arrty = llvm::ArrayType::get(at,tsa->dim->toUInteger()); 
    362  
    363     tsa->llvmType = arrty; 
    364     return arrty; 
    365 } 
    366316 
    367317////////////////////////////////////////////////////////////////////////////////////////// 
    …… 
    392342 
    393343// llvm.memset.i32 
    394 static llvm::Function* LLVM_DeclareMemSet32() 
     344llvm::Function* LLVM_DeclareMemSet32() 
    395345{ 
    396346    static llvm::Function* _func = 0; 
    …… 
    403353////////////////////////////////////////////////////////////////////////////////////////// 
    404354 
    405 static llvm::Function* LLVM_DeclareMemSet64() 
     355llvm::Function* LLVM_DeclareMemSet64() 
    406356{ 
    407357    static llvm::Function* _func = 0; 
    …… 
    415365 
    416366// llvm.memcpy.i32 
    417 static llvm::Function* LLVM_DeclareMemCpy32() 
     367llvm::Function* LLVM_DeclareMemCpy32() 
    418368{ 
    419369    static llvm::Function* _func = 0; 
    …… 
    427377 
    428378// llvm.memcpy.i64 
    429 static llvm::Function* LLVM_DeclareMemCpy64() 
     379llvm::Function* LLVM_DeclareMemCpy64() 
    430380{ 
    431381    static llvm::Function* _func = 0; 
    …… 
    557507} 
    558508 
    559 ////////////////////////////////////////////////////////////////////////////////////////// 
    560  
    561 llvm::Value* LLVM_DtoNullArray(llvm::Value* v) 
     509 
     510 
     511////////////////////////////////////////////////////////////////////////////////////////// 
     512 
     513llvm::Value* LLVM_DtoNullDelegate(llvm::Value* v) 
    562514{ 
    563515    assert(gIR); 
    …… 
    576528    llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
    577529 
    578     //Logger::cout() << *fn << '|' << *fn->getType() << '\n'; 
    579     //Logger::cout() << "to null array call: " << *llargs[0] << '|' << *llargs[1] << '|' << *llargs[2] << '|' << *llargs[3] << '\n'; 
    580  
    581     llvm::Value* ret = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb()); 
    582  
    583     return ret; 
    584 } 
    585  
    586 ////////////////////////////////////////////////////////////////////////////////////////// 
    587  
    588 llvm::Value* LLVM_DtoNullDelegate(llvm::Value* v) 
    589 { 
    590     assert(gIR); 
    591     d_uns64 n = (global.params.is64bit) ? 16 : 8; 
    592  
    593     llvm::Type* i8p_ty = llvm::PointerType::get(llvm::Type::Int8Ty); 
    594  
    595     llvm::Value* arr = new llvm::BitCastInst(v,i8p_ty,"tmp",gIR->scopebb()); 
    596  
    597     llvm::Function* fn = LLVM_DeclareMemSet32(); 
    598     std::vector<llvm::Value*> llargs; 
    599     llargs.resize(4); 
    600     llargs[0] = arr; 
    601     llargs[1] = llvm::ConstantInt::get(llvm::Type::Int8Ty, 0, false); 
    602     llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false); 
    603     llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
    604  
    605530    llvm::Value* ret = new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb()); 
    606531 
    …… 
    633558} 
    634559 
    635 ////////////////////////////////////////////////////////////////////////////////////////// 
    636  
    637 llvm::Value* LLVM_DtoArrayAssign(llvm::Value* dst, llvm::Value* src) 
    638 { 
    639     assert(gIR); 
    640     if (dst->getType() == src->getType()) 
    641     { 
    642         d_uns64 n = (global.params.is64bit) ? 16 : 8; 
    643  
    644         llvm::Type* arrty = llvm::PointerType::get(llvm::Type::Int8Ty); 
    645  
    646         llvm::Value* dstarr = new llvm::BitCastInst(dst,arrty,"tmp",gIR->scopebb()); 
    647         llvm::Value* srcarr = new llvm::BitCastInst(src,arrty,"tmp",gIR->scopebb()); 
    648  
    649         llvm::Function* fn = LLVM_DeclareMemCpy32(); 
    650         std::vector<llvm::Value*> llargs; 
    651         llargs.resize(4); 
    652         llargs[0] = dstarr; 
    653         llargs[1] = srcarr; 
    654         llargs[2] = llvm::ConstantInt::get(llvm::Type::Int32Ty, n, false); 
    655         llargs[3] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
    656  
    657         return new llvm::CallInst(fn, llargs.begin(), llargs.end(), "", gIR->scopebb()); 
    658     } 
    659     else 
    660     { 
    661         if (!llvm::isa<llvm::ArrayType>(src->getType()->getContainedType(0))) 
    662         { 
    663             Logger::cout() << "invalid: " << *src << '\n'; 
    664             assert(0); 
    665         } 
    666         const llvm::ArrayType* arrty = llvm::cast<llvm::ArrayType>(src->getType()->getContainedType(0)); 
    667         llvm::Type* dstty = llvm::PointerType::get(arrty->getElementType()); 
    668  
    669         llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
    670         llvm::Value* one = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1, false); 
    671  
    672         llvm::Value* dstlen = new llvm::GetElementPtrInst(dst,zero,zero,"tmp",gIR->scopebb()); 
    673         llvm::Value* srclen = llvm::ConstantInt::get(LLVM_DtoSize_t(), arrty->getNumElements(), false); 
    674         new llvm::StoreInst(srclen, dstlen, gIR->scopebb()); 
    675  
    676         llvm::Value* dstptr = new llvm::GetElementPtrInst(dst,zero,one,"tmp",gIR->scopebb()); 
    677         llvm::Value* srcptr = new llvm::BitCastInst(src,dstty,"tmp",gIR->scopebb()); 
    678         new llvm::StoreInst(srcptr, dstptr, gIR->scopebb()); 
    679     } 
    680 } 
    681  
    682 ////////////////////////////////////////////////////////////////////////////////////////// 
    683  
    684 void LLVM_DtoArrayInit(llvm::Value* l, llvm::Value* r) 
    685 { 
    686     const llvm::PointerType* ptrty = llvm::cast<llvm::PointerType>(l->getType()); 
    687     if (llvm::isa<llvm::ArrayType>(ptrty->getContainedType(0))) 
    688     { 
    689         const llvm::ArrayType* arrty = llvm::cast<llvm::ArrayType>(ptrty->getContainedType(0)); 
    690         llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
    691  
    692         std::vector<llvm::Value*> args; 
    693         args.resize(3); 
    694         args[0] = new llvm::GetElementPtrInst(l,zero,zero,"tmp",gIR->scopebb()); 
    695         args[1] = llvm::ConstantInt::get(LLVM_DtoSize_t(), arrty->getNumElements(), false); 
    696         args[2] = r; 
    697          
    698         const char* funcname = NULL; 
    699          
    700         if (llvm::isa<llvm::PointerType>(arrty->getElementType())) { 
    701             funcname = "_d_array_init_pointer"; 
    702              
    703             const llvm::Type* dstty = llvm::PointerType::get(llvm::PointerType::get(llvm::Type::Int8Ty)); 
    704             if (args[0]->getType() != dstty) 
    705                 args[0] = new llvm::BitCastInst(args[0],dstty,"tmp",gIR->scopebb()); 
    706              
    707             const llvm::Type* valty = llvm::PointerType::get(llvm::Type::Int8Ty); 
    708             if (args[2]->getType() != valty) 
    709                 args[2] = new llvm::BitCastInst(args[2],valty,"tmp",gIR->scopebb()); 
    710         } 
    711         else if (r->getType() == llvm::Type::Int1Ty) { 
    712             funcname = "_d_array_init_i1"; 
    713         } 
    714         else if (r->getType() == llvm::Type::Int8Ty) { 
    715             funcname = "_d_array_init_i8"; 
    716         } 
    717         else if (r->getType() == llvm::Type::Int16Ty) { 
    718             funcname = "_d_array_init_i16"; 
    719         } 
    720         else if (r->getType() == llvm::Type::Int32Ty) { 
    721             funcname = "_d_array_init_i32"; 
    722         } 
    723         else if (r->getType() == llvm::Type::Int64Ty) { 
    724             funcname = "_d_array_init_i64"; 
    725         } 
    726         else if (r->getType() == llvm::Type::FloatTy) { 
    727             funcname = "_d_array_init_float"; 
    728         } 
    729         else if (r->getType() == llvm::Type::DoubleTy) { 
    730             funcname = "_d_array_init_double"; 
    731         } 
    732         else { 
    733             assert(0); 
    734         } 
    735          
    736         Logger::cout() << *args[0] << '|' << *args[2] << '\n'; 
    737          
    738         llvm::Function* fn = LLVM_D_GetRuntimeFunction(gIR->module, funcname); 
    739         assert(fn); 
    740         llvm::CallInst* call = new llvm::CallInst(fn, args.begin(), args.end(), "", gIR->scopebb()); 
    741         call->setCallingConv(llvm::CallingConv::C); 
    742          
    743         Logger::println("array init call ok"); 
    744     } 
    745     else if (llvm::isa<llvm::StructType>(ptrty->getContainedType(0))) 
    746     { 
    747         assert(0 && "Only static arrays support initialisers atm"); 
    748     } 
    749     else 
    750     assert(0); 
    751 } 
    752  
    753 ////////////////////////////////////////////////////////////////////////////////////////// 
    754  
    755 void LLVM_DtoSetArray(llvm::Value* arr, llvm::Value* dim, llvm::Value* ptr) 
    756 { 
    757     const llvm::StructType* st = llvm::cast<llvm::StructType>(arr->getType()->getContainedType(0)); 
    758     //const llvm::PointerType* pt = llvm::cast<llvm::PointerType>(r->getType()); 
    759      
    760     llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0, false); 
    761     llvm::Value* one = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1, false); 
    762  
    763     llvm::Value* arrdim = new llvm::GetElementPtrInst(arr,zero,zero,"tmp",gIR->scopebb()); 
    764     new llvm::StoreInst(dim, arrdim, gIR->scopebb()); 
    765      
    766     llvm::Value* arrptr = new llvm::GetElementPtrInst(arr,zero,one,"tmp",gIR->scopebb()); 
    767     new llvm::StoreInst(ptr, arrptr, gIR->scopebb()); 
    768 } 
    769  
    770 ////////////////////////////////////////////////////////////////////////////////////////// 
    771 llvm::Constant* LLVM_DtoArrayInitializer(ArrayInitializer* arrinit) 
    772 { 
    773     Logger::println("arr init begin"); 
    774     assert(arrinit->type->ty == Tsarray); 
    775     TypeSArray* t = (TypeSArray*)arrinit->type; 
    776     integer_t tdim = t->dim->toInteger(); 
    777  
    778     std::vector<llvm::Constant*> inits(tdim, 0); 
    779  
    780     const llvm::Type* elemty = LLVM_DtoType(arrinit->type->next); 
    781  
    782     assert(arrinit->index.dim == arrinit->value.dim); 
    783     for (int i=0,j=0; i < tdim; ++i) 
    784     { 
    785         Initializer* init = 0; 
    786         Expression* idx = (Expression*)arrinit->index.data[j]; 
    787  
    788         if (idx) 
    789         { 
    790             integer_t k = idx->toInteger(); 
    791             if (i == k) 
    792             { 
    793                 init = (Initializer*)arrinit->value.data[j]; 
    794                 assert(init); 
    795                 ++j; 
    796             } 
    797         } 
    798         else 
    799         { 
    800             init = (Initializer*)arrinit->value.data[j]; 
    801             ++j; 
    802         } 
    803  
    804         llvm::Constant* v = 0; 
    805  
    806         if (!init) 
    807         { 
    808             elem* e = t->next->defaultInit()->toElem(gIR); 
    809             v = llvm::cast<llvm::Constant>(e->val); 
    810             delete e; 
    811         } 
    812         else if (ExpInitializer* ex = init->isExpInitializer()) 
    813         { 
    814             elem* e = ex->exp->toElem(gIR); 
    815             v = llvm::cast<llvm::Constant>(e->val); 
    816             delete e; 
    817         } 
    818         else if (StructInitializer* si = init->isStructInitializer()) 
    819         { 
    820             v = LLVM_DtoStructInitializer(si); 
    821         } 
    822         else if (ArrayInitializer* ai = init->isArrayInitializer()) 
    823         { 
    824             v = LLVM_DtoArrayInitializer(ai); 
    825         } 
    826         else if (init->isVoidInitializer()) 
    827         { 
    828             v = llvm::UndefValue::get(elemty); 
    829         } 
    830         else 
    831         assert(v); 
    832  
    833         inits[i] = v; 
    834     } 
    835  
    836     llvm::ArrayType* arrty = LLVM_DtoStaticArrayType(t); 
    837     return llvm::ConstantArray::get(arrty, inits); 
    838 } 
    839  
    840 ////////////////////////////////////////////////////////////////////////////////////////// 
    841 void LLVM_DtoArrayCopy(elem* dst, elem* src) 
    842 { 
    843     assert(0); 
    844 } 
     560 
    845561 
    846562////////////////////////////////////////////////////////////////////////////////////////// 

  • gen/tollvm.h

    r1 r4  
    1717llvm::Value* LLVM_DtoDelegateCopy(llvm::Value* dst, llvm::Value* src); 
    1818 
    19 llvm::StructType* LLVM_DtoArrayType(Type* t); 
    20 llvm::ArrayType* LLVM_DtoStaticArrayType(Type* t); 
    21 llvm::Value* LLVM_DtoNullArray(llvm::Value* v); 
    22 llvm::Value* LLVM_DtoArrayAssign(llvm::Value* l, llvm::Value* r); 
    23 void LLVM_DtoSetArray(llvm::Value* arr, llvm::Value* dim, llvm::Value* ptr); 
    24 llvm::Constant* LLVM_DtoArrayInitializer(ArrayInitializer* si); 
    25 void LLVM_DtoArrayCopy(elem* dst, elem* src); 
    26  
    27 void LLVM_DtoArrayInit(llvm::Value* l, llvm::Value* r); 
    28  
    2919llvm::GlobalValue::LinkageTypes LLVM_DtoLinkage(PROT prot, uint stc); 
    3020unsigned LLVM_DtoCallingConv(LINK l); 
    …… 
    4232llvm::Constant* LLVM_DtoInitializer(Type* type, Initializer* init); 
    4333 
     34llvm::Function* LLVM_DeclareMemSet32(); 
     35llvm::Function* LLVM_DeclareMemSet64(); 
     36llvm::Function* LLVM_DeclareMemCpy32(); 
     37llvm::Function* LLVM_DeclareMemCpy64(); 
     38 
    4439#include "enums.h" 

  • gen/toobj.c

    r1 r4  
    3535#include "import.h" 
    3636#include "template.h" 
    37 #include "irstate.h" 
    38 #include "elem.h" 
    39 #include "logger.h" 
    40  
    41 #include "tollvm.h" 
     37 
     38#include "gen/irstate.h" 
     39#include "gen/elem.h" 
     40#include "gen/logger.h" 
     41#include "gen/tollvm.h" 
    4242 
    4343////////////////////////////////////////////////////////////////////////////////////////// 

  • gen/typinf.c

    r1 r4  
    2626#include "aggregate.h" 
    2727 
    28 #include "logger.h" 
     28#include "gen/logger.h" 
    2929 
    3030/******************************************* 

  • premake.lua

    r1 r4  
    3030package.config.Debug.buildoptions = { "-g" } 
    3131--package.targetprefix = "llvm" 
    32 package.includepaths = { "dmd" } 
     32package.includepaths = { ".", "dmd" } 
    3333--package.postbuildcommands = { "cd runtime; ./build.sh; cd .." } 
    3434package.links = { "gc" } 

  • test/dotproduct.d

    r1 r4  
    88    } 
    99 
    10     void print(char* n) 
     10    void print(char[] n) 
    1111    { 
    12         printf("%s = vec3(%.4f, %.4f, %.4f)\n", n, x,y,z); 
     12        printf("%.*s = vec3(%.4f, %.4f, %.4f)\n", n.length, n.ptr, x,y,z); 
    1313    } 
    1414} 
Copyright © 2008, LDC Development Team.