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

Changeset 86:fd32135dca3e

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

[svn r90] Major updates to the gen directory. Redesigned the 'elem' struct. Much more... !!!
Lots of bugfixes.
Added support for special foreach on strings.
Added std.array, std.utf, std.ctype and std.uni to phobos.
Changed all the .c files in the gen dir to .cpp (it *is* C++ after all)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • dmd/declaration.h

    r82 r86  
    528528    llvm::Value* llvmArgPtr; 
    529529    llvm::Constant* llvmDwarfSubProgram; 
     530    bool llvmRunTimeHack; 
    530531}; 
    531532 

  • dmd/expression.h

    r40 r86  
    5757struct dt_t; 
    5858 
     59#if IN_LLVM 
     60struct DValue; 
     61typedef DValue elem; 
     62#else 
    5963#ifdef IN_GCC 
    6064union tree_node; typedef union tree_node elem; 
    6165#else 
    6266struct elem; 
     67#endif 
    6368#endif 
    6469 

  • dmd/func.c

    r82 r86  
    8080    llvmArgPtr = NULL; 
    8181    llvmDwarfSubProgram = NULL; 
     82    llvmRunTimeHack = false; 
    8283} 
    8384 

  • dmd/module.h

    r52 r86  
    2727 
    2828// Back end 
    29 #if IN_GCC 
     29#if IN_LLVM 
     30struct DValue; 
     31typedef DValue elem; 
     32#else 
     33#ifdef IN_GCC 
    3034union tree_node; typedef union tree_node elem; 
    3135#else 
    3236struct elem; 
     37#endif 
    3338#endif 
    3439 

  • dmd/statement.c

    r37 r86  
    14391439        else 
    14401440            fdapply = FuncDeclaration::genCfunc(Type::tindex, "_aaApply"); 
     1441        fdapply->llvmRunTimeHack = true; 
    14411442        ec = new VarExp(0, fdapply); 
    14421443        Expressions *exps = new Expressions(); 
    …… 
    14801481        assert(j < sizeof(fdname)); 
    14811482        fdapply = FuncDeclaration::genCfunc(Type::tindex, fdname); 
     1483        fdapply->llvmRunTimeHack = true; 
    14821484 
    14831485        ec = new VarExp(0, fdapply); 

  • dmd/statement.h

    r37 r86  
    5959struct IRState; 
    6060struct Blockx; 
     61#if IN_LLVM 
     62struct DValue; 
     63typedef DValue elem; 
     64#endif 
     65 
    6166#if IN_GCC 
    6267union tree_node; typedef union tree_node block; 
    63 union tree_node; typedef union tree_node elem; 
     68//union tree_node; typedef union tree_node elem; 
    6469#else 
    6570struct block; 
    66 struct elem; 
     71//struct elem; 
    6772#endif 
    6873struct code; 

  • gen/arrays.cpp

    r81 r86  
    1212#include "gen/runtime.h" 
    1313#include "gen/logger.h" 
    14 #include "gen/elem.h" 
     14#include "gen/dvalue.h" 
    1515 
    1616////////////////////////////////////////////////////////////////////////////////////////// 
    …… 
    126126    const llvm::PointerType* ptrty = llvm::cast<llvm::PointerType>(l->getType()); 
    127127    const llvm::Type* t = ptrty->getContainedType(0); 
    128     const llvm::ArrayType* arrty = llvm::cast_or_null<llvm::ArrayType>(t); 
     128    const llvm::ArrayType* arrty = llvm::dyn_cast<llvm::ArrayType>(t); 
    129129    if (arrty) 
    130130    { 
    131131        llvm::Value* ptr = DtoGEPi(l,0,0,"tmp",gIR->scopebb()); 
    132132        llvm::Value* dim = llvm::ConstantInt::get(DtoSize_t(), arrty->getNumElements(), false); 
    133         llvm::Value* val = r; 
    134         DtoArrayInit(ptr, dim, val); 
     133        DtoArrayInit(ptr, dim, r); 
    135134    } 
    136135    else if (llvm::isa<llvm::StructType>(t)) 
    137136    { 
    138         assert(0 && "Only static arrays support initialisers atm"); 
     137        llvm::Value* dim = DtoLoad(DtoGEPi(l, 0,0, "tmp")); 
     138        llvm::Value* ptr = DtoLoad(DtoGEPi(l, 0,1, "tmp")); 
     139        DtoArrayInit(ptr, dim, r); 
    139140    } 
    140141    else 
    …… 
    160161void DtoArrayInit(llvm::Value* ptr, llvm::Value* dim, llvm::Value* val) 
    161162{ 
     163    Logger::println("HELLO"); 
     164    Logger::cout() << "array: " << *ptr << " dim: " << *dim << " val: " << *val << '\n'; 
    162165    const llvm::Type* pt = ptr->getType()->getContainedType(0); 
    163166    const llvm::Type* t = val->getType(); 
    …… 
    251254    Logger::println("arr init begin"); 
    252255    Type* arrinittype = DtoDType(arrinit->type); 
    253     assert(arrinittype->ty == Tsarray); 
    254     TypeSArray* t = (TypeSArray*)arrinittype; 
    255     integer_t tdim = t->dim->toInteger(); 
     256 
     257    Type* t; 
     258    integer_t tdim; 
     259    if (arrinittype->ty == Tsarray) { 
     260        TypeSArray* tsa = (TypeSArray*)arrinittype; 
     261        tdim = tsa->dim->toInteger(); 
     262        t = tsa; 
     263    } 
     264    else if (arrinittype->ty == Tarray) { 
     265        t = arrinittype; 
     266        tdim = arrinit->dim; 
     267    } 
     268    else 
     269    assert(0); 
    256270 
    257271    std::vector<llvm::Constant*> inits(tdim, 0); 
    …… 
    309323    } 
    310324 
    311     const llvm::ArrayType* arrty = DtoStaticArrayType(t); 
    312     return llvm::ConstantArray::get(arrty, inits); 
    313 } 
    314  
    315 ////////////////////////////////////////////////////////////////////////////////////////// 
    316 static llvm::Value* get_slice_ptr(elem* e, llvm::Value*& sz) 
    317 { 
    318     assert(e->mem); 
    319     const llvm::Type* t = e->mem->getType()->getContainedType(0); 
     325    const llvm::ArrayType* arrty = llvm::ArrayType::get(elemty,tdim); 
     326    llvm::Constant* constarr = llvm::ConstantArray::get(arrty, inits); 
     327 
     328    if (arrinittype->ty == Tsarray) 
     329        return constarr; 
     330    else 
     331        assert(arrinittype->ty == Tarray); 
     332 
     333    llvm::GlobalVariable* gvar = new llvm::GlobalVariable(arrty,true,llvm::GlobalValue::InternalLinkage,constarr,"constarray",gIR->module); 
     334    llvm::Constant* idxs[2] = { DtoConstUint(0), DtoConstUint(0) }; 
     335    llvm::Constant* gep = llvm::ConstantExpr::getGetElementPtr(gvar,idxs,2); 
     336    return DtoConstSlice(DtoConstSize_t(tdim),gep); 
     337} 
     338 
     339////////////////////////////////////////////////////////////////////////////////////////// 
     340static llvm::Value* get_slice_ptr(DSliceValue* e, llvm::Value*& sz) 
     341{ 
     342    const llvm::Type* t = e->ptr->getType()->getContainedType(0); 
    320343    llvm::Value* ret = 0; 
    321     if (e->arg != 0) { 
     344    if (e->len != 0) { 
    322345        // this means it's a real slice 
    323         ret = e->mem; 
     346        ret = e->ptr; 
    324347 
    325348        size_t elembsz = gTargetData->getTypeSize(ret->getType()); 
    326349        llvm::ConstantInt* elemsz = llvm::ConstantInt::get(DtoSize_t(), elembsz, false); 
    327350 
    328         if (llvm::isa<llvm::ConstantInt>(e->arg)) { 
    329             sz = llvm::ConstantExpr::getMul(elemsz, llvm::cast<llvm::Constant>(e->arg)); 
     351        if (llvm::isa<llvm::ConstantInt>(e->len)) { 
     352            sz = llvm::ConstantExpr::getMul(elemsz, llvm::cast<llvm::Constant>(e->len)); 
    330353        } 
    331354        else { 
    332             sz = llvm::BinaryOperator::createMul(elemsz,e->arg,"tmp",gIR->scopebb()); 
     355            sz = llvm::BinaryOperator::createMul(elemsz,e->len,"tmp",gIR->scopebb()); 
    333356        } 
    334357    } 
    335358    else if (llvm::isa<llvm::ArrayType>(t)) { 
    336         ret = DtoGEPi(e->mem, 0, 0, "tmp", gIR->scopebb()); 
     359        ret = DtoGEPi(e->ptr, 0, 0, "tmp", gIR->scopebb()); 
    337360 
    338361        size_t elembsz = gTargetData->getTypeSize(ret->getType()->getContainedType(0)); 
    …… 
    345368    } 
    346369    else if (llvm::isa<llvm::StructType>(t)) { 
    347         ret = DtoGEPi(e->mem, 0, 1, "tmp", gIR->scopebb()); 
     370        ret = DtoGEPi(e->ptr, 0, 1, "tmp", gIR->scopebb()); 
    348371        ret = new llvm::LoadInst(ret, "tmp", gIR->scopebb()); 
    349372 
    …… 
    351374        llvm::ConstantInt* elemsz = llvm::ConstantInt::get(DtoSize_t(), elembsz, false); 
    352375 
    353         llvm::Value* len = DtoGEPi(e->mem, 0, 0, "tmp", gIR->scopebb()); 
     376        llvm::Value* len = DtoGEPi(e->ptr, 0, 0, "tmp", gIR->scopebb()); 
    354377        len = new llvm::LoadInst(len, "tmp", gIR->scopebb()); 
    355378        sz = llvm::BinaryOperator::createMul(len,elemsz,"tmp",gIR->scopebb()); 
    …… 
    361384} 
    362385 
    363 void DtoArrayCopy(elem* dst, elem* src) 
    364 { 
    365     Logger::cout() << "Array copy ((((" << *src->mem << ")))) into ((((" << *dst->mem << "))))\n"; 
    366  
    367     assert(dst->type == elem::SLICE); 
    368     assert(src->type == elem::SLICE); 
    369  
     386void DtoArrayCopy(DSliceValue* dst, DSliceValue* src) 
     387{ 
    370388    llvm::Type* arrty = llvm::PointerType::get(llvm::Type::Int8Ty); 
    371389 
    …… 
    436454 
    437455    if (doinit) { 
    438         elem* e = dty->defaultInit()->toElem(gIR); 
    439         DtoArrayInit(newptr,dim,e->getValue()); 
    440         delete e; 
     456        DValue* e = dty->defaultInit()->toElem(gIR); 
     457        DtoArrayInit(newptr,dim,e->getRVal()); 
    441458    } 
    442459 
    …… 
    450467 
    451468////////////////////////////////////////////////////////////////////////////////////////// 
    452 void DtoResizeDynArray(llvm::Value* arr, llvm::Value* sz) 
     469llvm::Value* DtoResizeDynArray(llvm::Value* arr, llvm::Value* sz) 
    453470{ 
    454471    llvm::Value* ptr = DtoGEPi(arr, 0, 1, "tmp", gIR->scopebb()); 
    …… 
    464481    llvm::Value* len = DtoGEPi(arr, 0, 0, "tmp", gIR->scopebb()); 
    465482    new llvm::StoreInst(sz,len,gIR->scopebb()); 
     483 
     484    return newptr; 
    466485} 
    467486 
    …… 
    469488void DtoCatAssignElement(llvm::Value* arr, Expression* exp) 
    470489{ 
    471     llvm::Value* ptr = DtoGEPi(arr, 0, 0, "tmp", gIR->scopebb()); 
    472     llvm::Value* idx = new llvm::LoadInst(ptr, "tmp", gIR->scopebb()); 
     490    llvm::Value* ptr = DtoGEPi(arr, 0, 0, "tmp"); 
     491    llvm::Value* idx = DtoLoad(ptr); 
    473492    llvm::Value* one = llvm::ConstantInt::get(idx->getType(),1,false); 
    474493    llvm::Value* len = llvm::BinaryOperator::createAdd(idx, one, "tmp", gIR->scopebb()); 
    475494    DtoResizeDynArray(arr,len); 
    476495 
    477     ptr = DtoGEPi(arr, 0, 1, "tmp", gIR->scopebb()); 
    478     ptr = new llvm::LoadInst(ptr, "tmp", gIR->scopebb()); 
     496    ptr = DtoLoad(DtoGEPi(arr, 0, 1, "tmp")); 
    479497    ptr = new llvm::GetElementPtrInst(ptr, idx, "tmp", gIR->scopebb()); 
    480498 
    481     elem* e = exp->toElem(gIR); 
    482     Type* et = DtoDType(exp->type); 
    483     DtoAssign(et, ptr, e->getValue()); 
    484     delete e; 
     499    DValue* dptr = new DVarValue(exp->type, ptr, true); 
     500 
     501    gIR->exps.push_back(IRExp(0,exp,dptr)); 
     502    DValue* e = exp->toElem(gIR); 
     503    gIR->exps.pop_back(); 
     504 
     505    if (!e->inPlace()) 
     506        DtoAssign(dptr, e); 
     507} 
     508 
     509////////////////////////////////////////////////////////////////////////////////////////// 
     510void DtoCatAssignArray(llvm::Value* arr, Expression* exp) 
     511{ 
     512    DValue* e = exp->toElem(gIR); 
     513 
     514    llvm::Value *len1, *len2, *src1, *src2, *res; 
     515 
     516    DValue* darr = new DVarValue(exp->type, arr, true); 
     517 
     518    len1 = DtoArrayLen(darr); 
     519    len2 = DtoArrayLen(e); 
     520    res = gIR->ir->CreateAdd(len1,len2,"tmp"); 
     521 
     522    llvm::Value* mem = DtoResizeDynArray(arr,res); 
     523 
     524    src1 = DtoArrayPtr(darr); 
     525    src2 = DtoArrayPtr(e); 
     526 
     527    mem = gIR->ir->CreateGEP(mem,len1,"tmp"); 
     528    DtoMemCpy(mem,src2,len2); 
    485529} 
    486530 
    …… 
    494538    assert(t1->ty == t2->ty); 
    495539 
    496     elem* e1 = exp1->toElem(gIR); 
    497     llvm::Value* a = e1->getValue(); 
    498     delete e1; 
    499  
    500     elem* e2 = exp2->toElem(gIR); 
    501     llvm::Value* b = e2->getValue(); 
    502     delete e2; 
     540    DValue* e1 = exp1->toElem(gIR); 
     541    llvm::Value* a = e1->getRVal(); 
     542 
     543    DValue* e2 = exp2->toElem(gIR); 
     544    llvm::Value* b = e2->getRVal(); 
    503545 
    504546    llvm::Value *len1, *len2, *src1, *src2, *res; 
    …… 
    671713    return llvm::ConstantArray::get(at, initvals); 
    672714} 
     715 
     716////////////////////////////////////////////////////////////////////////////////////////// 
     717llvm::Value* DtoArrayLen(DValue* v) 
     718{ 
     719    Type* t = DtoDType(v->getType()); 
     720    if (t->ty == Tarray) { 
     721        if (DSliceValue* s = v->isSlice()) { 
     722            if (s->len) return s->len; 
     723            DValue* next = new DVarValue(t,s->ptr,true); 
     724            return DtoArrayLen(next); 
     725        } 
     726        return DtoLoad(DtoGEPi(v->getRVal(), 0,0, "tmp")); 
     727    } 
     728    else if (t->ty == Tsarray) { 
     729        const llvm::ArrayType* t = llvm::cast<llvm::ArrayType>(v->getLVal()->getType()); 
     730        return DtoConstSize_t(t->getNumElements()); 
     731    } 
     732    assert(0); 
     733    return 0; 
     734} 
     735 
     736////////////////////////////////////////////////////////////////////////////////////////// 
     737llvm::Value* DtoArrayPtr(DValue* v) 
     738{ 
     739    Type* t = DtoDType(v->getType()); 
     740    if (t->ty == Tarray) { 
     741        if (DSliceValue* s = v->isSlice()) { 
     742            if (s->len) return s->ptr; 
     743            DValue* next = new DVarValue(t,s->ptr,true); 
     744            return DtoArrayPtr(next); 
     745        } 
     746        return DtoLoad(DtoGEPi(v->getRVal(), 0,1, "tmp")); 
     747    } 
     748    else if (t->ty == Tsarray) { 
     749        return DtoGEPi(v->getRVal(), 0,0, "tmp"); 
     750    } 
     751    assert(0); 
     752    return 0; 
     753} 
     754 

  • gen/arrays.h

    r81 r86  
    11#ifndef LLVMC_GEN_ARRAYS_H 
    22#define LLVMC_GEN_ARRAYS_H 
     3 
     4struct DSliceValue; 
    35 
    46const llvm::StructType* DtoArrayType(Type* t); 
    …… 
    911llvm::Constant* DtoConstStaticArray(const llvm::Type* t, llvm::Constant* c); 
    1012 
    11 void DtoArrayCopy(elem* dst, elem* src); 
     13void DtoArrayCopy(DSliceValue* dst, DSliceValue* src); 
     14 
    1215void DtoArrayInit(llvm::Value* l, llvm::Value* r); 
    1316void DtoArrayInit(llvm::Value* ptr, llvm::Value* dim, llvm::Value* val); 
    …… 
    1720 
    1821llvm::Value* DtoNewDynArray(llvm::Value* dst, llvm::Value* dim, Type* dty, bool doinit=true); 
    19 void DtoResizeDynArray(llvm::Value* arr, llvm::Value* sz); 
     22llvm::Value* DtoResizeDynArray(llvm::Value* arr, llvm::Value* sz); 
    2023 
    2124void DtoCatAssignElement(llvm::Value* arr, Expression* exp); 
     25void DtoCatAssignArray(llvm::Value* arr, Expression* exp); 
    2226void DtoCatArrays(llvm::Value* arr, Expression* e1, Expression* e2); 
    2327 
    …… 
    3135llvm::Value* DtoArrayCastLength(llvm::Value* len, const llvm::Type* elemty, const llvm::Type* newelemty); 
    3236 
     37llvm::Value* DtoArrayLen(DValue* v); 
     38llvm::Value* DtoArrayPtr(DValue* v); 
     39 
    3340#endif // LLVMC_GEN_ARRAYS_H 

  • gen/elem.cpp

    r83 r86  
     1/* 
    12#include <iostream> 
    23 
    …… 
    67#include "gen/irstate.h" 
    78#include "gen/logger.h" 
     9#include "gen/dvalue.h" 
    810 
    911////////////////////////////////////////////////////////////////////////////////////////// 
    1012 
    11 elem::elem() 
     13elem::elem(Expression* e) 
    1214{ 
     15    exp = e; 
     16 
    1317    mem = 0; 
    1418    val = 0; 
    …… 
    2529    vardecl = 0; 
    2630    funcdecl = 0; 
     31 
     32    dvalue = 0; 
     33} 
     34 
     35elem::~elem() 
     36{ 
     37    delete dvalue; 
    2738} 
    2839 
    2940llvm::Value* elem::getValue() 
    3041{ 
     42    if (dvalue && !dvalue->isSlice()) { 
     43        Logger::println("HAS DVALUE"); 
     44        return dvalue->getRVal(); 
     45    } 
     46 
    3147    assert(val || mem); 
    3248    switch(type) 
    …… 
    6783    return 0; 
    6884} 
     85*/ 

  • gen/elem.h

    r83 r86  
    11#ifndef LLVMDC_GEN_ELEM_H 
    22#define LLVMDC_GEN_ELEM_H 
     3 
     4#include "dvalue.h" 
     5typedef DValue elem; 
     6 
     7/* 
    38 
    49#include "root.h" 
    510#include "declaration.h" 
    611#include "aggregate.h" 
     12 
     13struct DValue; 
    714 
    815// represents a value. be it a constant literal, a variable etc. 
    …… 
    2330 
    2431public: 
    25     elem(); 
     32    elem(Expression* e); 
     33    virtual ~elem(); 
     34 
     35    Expression* exp; 
    2636 
    2737    llvm::Value* mem; 
    …… 
    4252    //llvm::Value* getMemory(); 
    4353 
     54    DValue* dvalue; 
     55 
    4456    bool isNull()   {return !(mem || val);} 
    4557}; 
    4658 
     59*/ 
     60 
    4761#endif // LLVMDC_GEN_ELEM_H 

  • gen/irstate.cpp

    r82 r86  
    165165} 
    166166 
    167 IRExp::IRExp(Expression* l, Expression* r, llvm::Value* val) 
     167IRExp::IRExp(Expression* l, Expression* r, DValue* val) 
    168168{ 
    169169    e1 = l; 

  • gen/irstate.h

    r82 r86  
    102102    Expression* e1; 
    103103    Expression* e2; 
    104     llvm::Value* v; 
     104    DValue* v; 
    105105    IRExp(); 
    106     IRExp(Expression* l, Expression* r, llvm::Value* val); 
     106    IRExp(Expression* l, Expression* r, DValue* val); 
    107107}; 
    108108 
    …… 
    159159    // VarDeclaration for __dollar, but I can't see how to get the 
    160160    // array pointer from this :( 
    161     std::vector<llvm::Value*> arrays; 
     161    std::vector<DValue*> arrays; 
    162162 
    163163    // builder helper 

  • gen/statements.cpp

    r82 r86  
    2424#include "gen/arrays.h" 
    2525#include "gen/todebug.h" 
     26#include "gen/dvalue.h" 
    2627 
    2728////////////////////////////////////////////////////////////////////////////// 
    …… 
    6768            if (global.params.symdebug) DtoDwarfStopPoint(loc.linnum); 
    6869 
    69             p->exps.push_back(IRExp(NULL,exp,f->llvmRetArg)); 
    70             elem* e = exp->toElem(p); 
     70            DValue* rvar = new DVarValue(f->next, f->llvmRetArg, true); 
     71 
     72            p->exps.push_back(IRExp(NULL,exp,rvar)); 
     73            DValue* e = exp->toElem(p); 
    7174            p->exps.pop_back(); 
    7275 
    73             if (expty == Tstruct) { 
    74                 if (!e->inplace) 
    75                     DtoStructCopy(f->llvmRetArg,e->getValue()); 
    76             } 
    77             else if (expty == Tdelegate) { 
    78                 if (!e->inplace) 
    79                     DtoDelegateCopy(f->llvmRetArg,e->getValue()); 
    80             } 
    81             else if (expty == Tarray) { 
    82                 if (e->type == elem::SLICE) { 
    83                     assert(e->mem); 
    84                     DtoSetArray(f->llvmRetArg,e->arg,e->mem); 
    85                 } 
    86                 else if (!e->inplace) { 
    87                     if (e->type == elem::NUL) { 
    88                         DtoNullArray(f->llvmRetArg); 
    89                     } 
    90                     else { 
    91                         DtoArrayAssign(f->llvmRetArg, e->getValue()); 
    92                     } 
    93                 } 
    94             } 
    95             else 
    96             assert(0); 
     76            if (!e->inPlace()) 
     77                DtoAssign(rvar, e); 
    9778 
    9879            IRFunction::FinallyVec& fin = p->func().finallys; 
    …… 
    10485                new llvm::BranchInst(fin.back().retbb, p->scopebb()); 
    10586            } 
    106             delete e; 
    10787        } 
    10888        else { 
    10989            if (global.params.symdebug) DtoDwarfStopPoint(loc.linnum); 
    110             elem* e = exp->toElem(p); 
    111             llvm::Value* v = e->getValue(); 
     90            DValue* e = exp->toElem(p); 
     91            llvm::Value* v = e->getRVal(); 
    11292            delete e; 
    11393            Logger::cout() << "return value is '" <<*v << "'\n"; 
    …… 
    175155    LOG_SCOPE; 
    176156 
    177     elem* cond_e = condition->toElem(p); 
    178     llvm::Value* cond_val = cond_e->getValue(); 
     157    DValue* cond_e = condition->toElem(p); 
     158    llvm::Value* cond_val = cond_e->getRVal(); 
    179159    delete cond_e; 
    180160 
    …… 
    266246 
    267247    // create the condition 
    268     elem* cond_e = condition->toElem(p); 
    269     llvm::Value* cond_val = DtoBoolean(cond_e->getValue()); 
     248    DValue* cond_e = condition->toElem(p); 
     249    llvm::Value* cond_val = DtoBoolean(cond_e->getRVal()); 
    270250    delete cond_e; 
    271251 
    …… 
    309289 
    310290    // create the condition 
    311     elem* cond_e = condition->toElem(p); 
    312     llvm::Value* cond_val = DtoBoolean(cond_e->getValue()); 
     291    DValue* cond_e = condition->toElem(p); 
     292    llvm::Value* cond_val = DtoBoolean(cond_e->getRVal()); 
    313293    delete cond_e; 
    314294 
    …… 
    348328 
    349329    // create the condition 
    350     elem* cond_e = condition->toElem(p); 
    351     llvm::Value* cond_val = DtoBoolean(cond_e->getValue()); 
     330    DValue* cond_e = condition->toElem(p); 
     331    llvm::Value* cond_val = DtoBoolean(cond_e->getRVal()); 
    352332    delete cond_e; 
    353333 
    …… 
    367347    // increment 
    368348    if (increment) { 
    369         elem* inc = increment->toElem(p); 
     349        DValue* inc = increment->toElem(p); 
    370350        delete inc; 
    371351    } 
    …… 
    544524    /* 
    545525    assert(exp); 
    546     elem* e = exp->toElem(p); 
     526    DValue* e = exp->toElem(p); 
    547527    delete e; 
    548528    */ 
    …… 
    566546 
    567547        // get the case value 
    568         elem* e = cs->exp->toElem(p); 
    569         assert(e->val && llvm::isa<llvm::ConstantInt>(e->val)); 
    570         llvm::ConstantInt* ec = llvm::cast<llvm::ConstantInt>(e->val); 
     548        DValue* e = cs->exp->toElem(p); 
     549        DConstValue* ce = e->isConst(); 
     550        assert(ce && llvm::isa<llvm::ConstantInt>(ce->c)); 
     551        llvm::ConstantInt* ec = llvm::cast<llvm::ConstantInt>(ce->c); 
    571552        delete e; 
    572553 
    …… 
    588569 
    589570    // condition var 
    590     elem* cond = condition->toElem(p); 
    591     llvm::SwitchInst* si = new llvm::SwitchInst(cond->getValue(), defbb ? defbb : endbb, cases->dim, p->scopebb()); 
     571    DValue* cond = condition->toElem(p); 
     572    llvm::SwitchInst* si = new llvm::SwitchInst(cond->getRVal(), defbb ? defbb : endbb, cases->dim, p->scopebb()); 
    592573    delete cond; 
    593574 
    …… 
    679660    Logger::println("func = %s", func->toChars()); 
    680661 
    681     elem* arr = aggr->toElem(p); 
    682     llvm::Value* val = arr->getValue(); 
    683     Logger::cout() << "aggr2llvm = " << *val << '\n'; 
     662    DValue* arr = aggr->toElem(p); 
     663    llvm::Value* val = 0; 
     664    if (!arr->isSlice()) { 
     665        val = arr->getRVal(); 
     666        Logger::cout() << "aggr2llvm = " << *val << '\n'; 
     667    } 
    684668 
    685669    llvm::Value* numiters = 0; 
    …… 
    690674 
    691675    const llvm::Type* valtype = DtoType(value->type); 
    692     llvm::Value* valvar = !value->isRef() ? new llvm::AllocaInst(valtype, "foreachval", p->topallocapoint()) : NULL; 
     676    llvm::Value* valvar = !(value->isRef() || value->isOut()) ? new llvm::AllocaInst(valtype, "foreachval", p->topallocapoint()) : NULL; 
    693677 
    694678    Type* aggrtype = DtoDType(aggr->type); 
    …… 
    703687    else if (aggrtype->ty == Tarray) 
    704688    { 
    705         if (arr->type == elem::SLICE) { 
    706             numiters = arr->arg; 
    707             val = arr->mem; 
     689        if (DSliceValue* slice = arr->isSlice()) { 
     690            numiters = slice->len; 
     691            val = slice->ptr; 
    708692        } 
    709693        else { 
    …… 
    761745        value->llvmValue = new llvm::GetElementPtrInst(val,loadedKey,"tmp",p->scopebb()); 
    762746 
    763     if (!value->isRef()) { 
    764         elem* e = new elem; 
    765         e->mem = value->llvmValue; 
    766         e->type = elem::VAR; 
    767         DtoAssign(DtoDType(value->type), valvar, e->getValue()); 
    768         delete e; 
     747    if (!value->isRef() && !value->isOut()) { 
     748        DValue* dst = new DVarValue(value->type, valvar, true); 
     749        DValue* src = new DVarValue(value->type, value->llvmValue, true); 
     750        DtoAssign(dst, src); 
     751        delete dst; 
     752        delete src; 
    769753        value->llvmValue = valvar; 
    770754    } 
    …… 
    799783        llvmBB = new llvm::BasicBlock("label", p->topfunc(), oldend); 
    800784 
    801     new llvm::BranchInst(llvmBB, p->scopebb()); 
     785    if (!p->scopereturned()) 
     786        new llvm::BranchInst(llvmBB, p->scopebb()); 
     787 
    802788    p->scope() = IRScope(llvmBB,oldend); 
    803     statement->toIR(p); 
     789    if (statement) 
     790        statement->toIR(p); 
    804791} 
    805792 
    …… 
    818805    if (label->statement->llvmBB == NULL) 
    819806        label->statement->llvmBB = new llvm::BasicBlock("label", p->topfunc()); 
     807    assert(!p->scopereturned()); 
    820808    new llvm::BranchInst(label->statement->llvmBB, p->scopebb()); 
    821809    p->scope() = IRScope(bb,oldend); 
    …… 
    832820    assert(body); 
    833821 
    834     elem* e = exp->toElem(p); 
    835     wthis->llvmValue = e->getValue(); 
     822    DValue* e = exp->toElem(p); 
     823    wthis->llvmValue = e->getRVal(); 
    836824    delete e; 
    837825 

  • gen/toir.cpp

    r85 r86  
    2929#include "gen/arrays.h" 
    3030 
    31 ////////////////////////////////////////////////////////////////////////////////////////// 
    32  
    33 elem* DeclarationExp::toElem(IRState* p) 
     31#include "gen/dvalue.h" 
     32 
     33////////////////////////////////////////////////////////////////////////////////////////// 
     34 
     35DValue* DeclarationExp::toElem(IRState* p) 
    3436{ 
    3537    Logger::print("DeclarationExp::toElem: %s | T=%s\n", toChars(), type->toChars()); 
    3638    LOG_SCOPE; 
    37     elem* e = new elem; 
    3839 
    3940    // variable declaration 
    …… 
    6566                vd->llvmValue = allocainst; 
    6667            } 
    67             elem* ie = DtoInitializer(vd->init); 
     68            DValue* ie = DtoInitializer(vd->init); 
    6869            delete ie; 
    6970        } 
     71 
     72        return new DVarValue(vd, vd->llvmValue, true); 
    7073    } 
    7174    // struct declaration 
    …… 
    98101        assert(0); 
    99102    } 
    100     return e; 
    101 } 
    102  
    103 ////////////////////////////////////////////////////////////////////////////////////////// 
    104  
    105 elem* VarExp::toElem(IRState* p) 
     103    return 0; 
     104} 
     105 
     106////////////////////////////////////////////////////////////////////////////////////////// 
     107 
     108DValue* VarExp::toElem(IRState* p) 
    106109{ 
    107110    Logger::print("VarExp::toElem: %s | %s\n", toChars(), type->toChars()); 
    108111    LOG_SCOPE; 
    109  
    110     elem* e = new elem; 
    111112 
    112113    assert(var); 
    …… 
    119120        { 
    120121            Logger::println("Id::_arguments"); 
    121             vd->llvmValue = p->func().decl->llvmArguments; 
     122            if (!vd->llvmValue) 
     123                vd->llvmValue = p->func().decl->llvmArguments; 
    122124            assert(vd->llvmValue); 
    123             e->mem = vd->llvmValue; 
    124             e->type = elem::VAR; 
     125            return new DVarValue(vd, vd->llvmValue, true); 
    125126        } 
    126127        // _argptr 
    …… 
    128129        { 
    129130            Logger::println("Id::_argptr"); 
    130             vd->llvmValue = p->func().decl->llvmArgPtr; 
     131            if (!vd->llvmValue) 
     132                vd->llvmValue = p->func().decl->llvmArgPtr; 
    131133            assert(vd->llvmValue); 
    132             e->mem = vd->llvmValue; 
    133             e->type = elem::VAR; 
     134            return new DVarValue(vd, vd->llvmValue, true); 
    134135        } 
    135136        // _dollar 
    …… 
    138139            Logger::println("Id::dollar"); 
    139140            assert(!p->arrays.empty()); 
    140             llvm::Value* tmp = DtoGEPi(p->arrays.back(),0,0,"tmp",p->scopebb()); 
    141             e->val = new llvm::LoadInst(tmp,"tmp",p->scopebb()); 
    142             e->type = elem::VAL; 
     141            llvm::Value* tmp = DtoArrayLen(p->arrays.back()); 
     142            return new DVarValue(vd, tmp, false); 
    143143        } 
    144144        // typeinfo 
    …… 
    149149            assert(tid->llvmValue); 
    150150            const llvm::Type* vartype = DtoType(type); 
     151            llvm::Value* m; 
    151152            if (tid->llvmValue->getType() != llvm::PointerType::get(vartype)) 
    152                 e->mem = p->ir->CreateBitCast(tid->llvmValue, vartype, "tmp"); 
     153                m = p->ir->CreateBitCast(tid->llvmValue, vartype, "tmp"); 
    153154            else 
    154                 e->mem = tid->llvmValue; 
    155             e->type = elem::VAR; 
     155                m = tid->llvmValue; 
     156            return new DVarValue(vd, m, true); 
    156157        } 
    157158        // nested variable 
    158159        else if (vd->nestedref) { 
    159160            Logger::println("nested variable"); 
    160             e->mem = DtoNestedVariable(vd); 
    161             e->type = elem::VAR; 
    162             e->vardecl = vd; 
     161            return new DVarValue(vd, DtoNestedVariable(vd), true); 
    163162        } 
    164163        // function parameter 
    …… 
    171170            } 
    172171            if (vd->isRef() || vd->isOut() || DtoIsPassedByRef(vd->type) || llvm::isa<llvm::AllocaInst>(vd->llvmValue)) { 
    173                 e->mem = vd->llvmValue; 
    174                 e->type = elem::VAR; 
    175                 e->vardecl = vd; 
     172                return new DVarValue(vd, vd->llvmValue, true); 
    176173            } 
    177174            else if (llvm::isa<llvm::Argument>(vd->llvmValue)) { 
    178                 e->val = vd->llvmValue; 
    179                 e->type = elem::VAL; 
    180                 e->vardecl = vd; 
     175                return new DImValue(type, vd->llvmValue); 
    181176            } 
    182177            else assert(0); 
    …… 
    187182                vd->toObjFile(); 
    188183            assert(vd->llvmValue); 
    189             e->mem = vd->llvmValue; 
    190             e->vardecl = vd; 
    191             e->type = elem::VAR; 
    192         } 
    193  
    194         assert(e->mem || e->val); 
     184            return new DVarValue(vd, vd->llvmValue, true); 
     185        } 
    195186    } 
    196187    else if (FuncDeclaration* fdecl = var->isFuncDeclaration()) 
    197188    { 
    198189        Logger::println("FuncDeclaration"); 
    199         if (fdecl->llvmInternal != LLVMva_arg && fdecl->llvmValue == 0) 
     190        if (fdecl->llvmInternal != LLVMva_arg)// && fdecl->llvmValue == 0) 
    200191            fdecl->toObjFile(); 
    201         e->val = fdecl->llvmValue; 
    202         e->type = elem::FUNC; 
    203         e->funcdecl = fdecl; 
     192        return new DFuncValue(fdecl, fdecl->llvmValue); 
    204193    } 
    205194    else if (SymbolDeclaration* sdecl = var->isSymbolDeclaration()) 
    …… 
    210199        assert(sdecltype->ty == Tstruct); 
    211200        TypeStruct* ts = (TypeStruct*)sdecltype; 
    212         e->mem = ts->llvmInit; 
    213         assert(e->mem); 
    214         e->type = elem::VAR; 
     201        assert(ts->llvmInit); 
     202        return new DVarValue(type, ts->llvmInit, true); 
    215203    } 
    216204    else 
    …… 
    219207    } 
    220208 
    221     return e; 
     209