Changeset 395

Show
Ignore:
Timestamp:
02/21/10 21:21:56 (2 years ago)
Author:
walter
Message:

asserts to use ModuleInfo?

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/backend/rtlsym.h

    r251 r395  
    3030#define SYMBOL_SCPP_TX86(e, fl, saved, n, flags, ty) SYMBOL_Z(e,fl,saved,n,flags,ty) 
    3131#else 
    3232#define SYMBOL_SCPP_TX86(e, fl, saved, n, flags, ty) 
    3333#endif 
    3434 
    3535#if MARS 
    3636#define SYMBOL_MARS(e, fl, saved, n, flags, ty) SYMBOL_Z(e,fl,saved,n,flags,ty) 
    3737#else 
    3838#define SYMBOL_MARS(e, fl, saved, n, flags, ty) 
    3939#endif 
    4040 
    4141 
    4242#define RTLSYMS \ 
    4343\ 
    4444SYMBOL_MARS(THROW,       FLfunc,(mES | mBP),"_d_throw@4", SFLexit, tw) \ 
    4545SYMBOL_MARS(MONITOR_HANDLER, FLfunc,FREGSAVED,"_d_monitor_handler", 0, 0) \ 
    4646SYMBOL_MARS(MONITOR_PROLOG,  FLfunc,FREGSAVED,"_d_monitor_prolog",0,t) \ 
    4747SYMBOL_MARS(MONITOR_EPILOG,  FLfunc,FREGSAVED,"_d_monitor_epilog",0,t) \ 
    4848SYMBOL_MARS(DCOVER,      FLfunc,FREGSAVED,"_d_cover_register", 0, t) \ 
    4949SYMBOL_MARS(DASSERT,         FLfunc,FREGSAVED,"_d_assert", SFLexit, t) \ 
     50SYMBOL_MARS(DASSERTM,        FLfunc,FREGSAVED,"_d_assertm", SFLexit, t) \ 
    5051SYMBOL_MARS(DASSERT_MSG,     FLfunc,FREGSAVED,"_d_assert_msg", SFLexit, t) \ 
    5152SYMBOL_MARS(DARRAY,      FLfunc,FREGSAVED,"_d_array_bounds", SFLexit, t) \ 
    5253SYMBOL_MARS(DINVARIANT,      FLfunc,FREGSAVED,"D9invariant12_d_invariantFC6ObjectZv", 0, tsdlib) \ 
    5354SYMBOL_MARS(_DINVARIANT,     FLfunc,FREGSAVED,"_D9invariant12_d_invariantFC6ObjectZv", 0, tsdlib) \ 
    5455SYMBOL_MARS(MEMCPY,      FLfunc,FREGSAVED,"memcpy",    0, t) \ 
    5556SYMBOL_MARS(MEMSET8,         FLfunc,FREGSAVED,"memset",    0, t) \ 
    5657SYMBOL_MARS(MEMSET16,        FLfunc,FREGSAVED,"_memset16", 0, t) \ 
    5758SYMBOL_MARS(MEMSET32,        FLfunc,FREGSAVED,"_memset32", 0, t) \ 
    5859SYMBOL_MARS(MEMSET64,        FLfunc,FREGSAVED,"_memset64", 0, t) \ 
    5960SYMBOL_MARS(MEMSET128,       FLfunc,FREGSAVED,"_memset128",0, t) \ 
    6061SYMBOL_MARS(MEMSET80,        FLfunc,FREGSAVED,"_memset80", 0, t) \ 
    6162SYMBOL_MARS(MEMSET160,       FLfunc,FREGSAVED,"_memset160",0, t) \ 
    6263SYMBOL_MARS(MEMSETN,         FLfunc,FREGSAVED,"_memsetn",  0, t) \ 
    6364SYMBOL_MARS(MODULO,      FLfunc,FREGSAVED,"_modulo",   0, t) \ 
    6465SYMBOL_MARS(MONITORENTER,  FLfunc,FREGSAVED,"_d_monitorenter",0, t) \ 
    6566SYMBOL_MARS(MONITOREXIT,   FLfunc,FREGSAVED,"_d_monitorexit",0, t) \ 
    6667SYMBOL_MARS(CRITICALENTER, FLfunc,FREGSAVED,"_d_criticalenter",0, t) \ 
    6768SYMBOL_MARS(CRITICALEXIT,  FLfunc,FREGSAVED,"_d_criticalexit",0, t) \ 
    6869SYMBOL_MARS(SWITCH_STRING, FLfunc,FREGSAVED,"_d_switch_string", 0, t) \ 
    6970SYMBOL_MARS(SWITCH_USTRING,FLfunc,FREGSAVED,"_d_switch_ustring", 0, t) \ 
    7071SYMBOL_MARS(SWITCH_DSTRING,FLfunc,FREGSAVED,"_d_switch_dstring", 0, t) \ 
    71 SYMBOL_MARS(DSWITCHERR,    FLfunc,FREGSAVED,"_d_switch_error", 0, t) \ 
     72SYMBOL_MARS(DSWITCHERR,    FLfunc,FREGSAVED,"_d_switch_error", SFLexit, t) \ 
    7273SYMBOL_MARS(DHIDDENFUNC,   FLfunc,FREGSAVED,"_d_hidden_func", 0, t) \ 
    7374SYMBOL_MARS(NEWCLASS,      FLfunc,FREGSAVED,"_d_newclass", 0, t) \ 
    7475SYMBOL_MARS(NEWARRAYT,     FLfunc,FREGSAVED,"_d_newarrayT", 0, t) \ 
    7576SYMBOL_MARS(NEWARRAYIT,    FLfunc,FREGSAVED,"_d_newarrayiT", 0, t) \ 
    7677SYMBOL_MARS(NEWARRAYMT,    FLfunc,FREGSAVED,"_d_newarraymT", 0, t) \ 
    7778SYMBOL_MARS(NEWARRAYMIT,   FLfunc,FREGSAVED,"_d_newarraymiT", 0, t) \ 
    7879SYMBOL_MARS(ARRAYLITERALT, FLfunc,FREGSAVED,"_d_arrayliteralT", 0, t) \ 
    7980SYMBOL_MARS(ASSOCARRAYLITERALT, FLfunc,FREGSAVED,"_d_assocarrayliteralT", 0, t) \ 
    8081SYMBOL_MARS(CALLFINALIZER, FLfunc,FREGSAVED,"_d_callfinalizer", 0, t) \ 
    8182SYMBOL_MARS(CALLINTERFACEFINALIZER, FLfunc,FREGSAVED,"_d_callinterfacefinalizer", 0, t) \ 
    8283SYMBOL_MARS(DELCLASS,      FLfunc,FREGSAVED,"_d_delclass", 0, t) \ 
    8384SYMBOL_MARS(DELINTERFACE,  FLfunc,FREGSAVED,"_d_delinterface", 0, t) \ 
    8485SYMBOL_MARS(ALLOCMEMORY,   FLfunc,FREGSAVED,"_d_allocmemory", 0, t) \ 
    8586SYMBOL_MARS(DELARRAY,      FLfunc,FREGSAVED,"_d_delarray", 0, t) \ 
    8687SYMBOL_MARS(DELARRAYT,     FLfunc,FREGSAVED,"_d_delarray_t", 0, t) \ 
    8788SYMBOL_MARS(DELMEMORY,     FLfunc,FREGSAVED,"_d_delmemory", 0, t) \ 
    8889SYMBOL_MARS(INTERFACE,     FLfunc,FREGSAVED,"_d_interface_vtbl", 0, t) \ 
    8990SYMBOL_MARS(DYNAMIC_CAST,  FLfunc,FREGSAVED,"_d_dynamic_cast", 0, t) \ 
    9091SYMBOL_MARS(INTERFACE_CAST,FLfunc,FREGSAVED,"_d_interface_cast", 0, t) \ 
    9192SYMBOL_MARS(FATEXIT,       FLfunc,FREGSAVED,"_fatexit", 0, t) \ 

  • trunk/src/glue.c

    r393 r395  
    454454     * Another way to fix it is do the main one last. 
    455455     */ 
    456456    toModuleAssert(); 
    457457    toModuleArray(); 
    458458    } 
    459459 
    460460#if 1 
    461461    // Always generate module info, because of templates and -cov 
    462462    if (1 || needModuleInfo()) 
    463463    genmoduleinfo(); 
    464464#endif 
    465465 
    466466    // If module assert 
    467467    for (int i = 0; i < 2; i++) 
    468468    { 
    469469    Symbol *ma = i ? marray : massert; 
    470470 
    471471    if (ma) 
    472472    { 
    473473        elem *elinnum; 
    474         elem *efilename; 
    475474 
    476475        localgot = NULL; 
    477476 
    478477        // Call dassert(filename, line) 
    479478        // Get sole parameter, linnum 
    480479        { 
    481480        Symbol *sp; 
    482481 
    483482        sp = symbol_calloc("linnum"); 
    484483        sp->Stype = type_fake(TYint); 
    485484        sp->Stype->Tcount++; 
    486485        sp->Sclass = SCfastpar; 
    487486        sp->Spreg = AX; 
    488487        sp->Sflags &= ~SFLspill; 
    489488        sp->Sfl = FLpara;   // FLauto? 
    490489        cstate.CSpsymtab = &ma->Sfunc->Flocsym; 
    491490        symbol_add(sp); 
    492491 
    493492        elinnum = el_var(sp); 
    494493        } 
    495494 
    496         efilename = toEmodulename(); 
    497  
    498         elem *e = el_var(rtlsym[i ? RTLSYM_DARRAY : RTLSYM_DASSERT]); 
     495        elem *efilename = el_ptr(toSymbol()); 
     496 
     497        elem *e = el_var(rtlsym[i ? RTLSYM_DARRAY : RTLSYM_DASSERTM]); 
    499498        e = el_bin(OPcall, TYvoid, e, el_param(elinnum, efilename)); 
    500499 
    501500        block *b = block_calloc(); 
    502501        b->BC = BCret; 
    503502        b->Belem = e; 
    504503        ma->Sfunc->Fstartblock = b; 
    505504        ma->Sclass = SCglobal; 
    506505        ma->Sfl = 0; 
    507506        writefunc(ma); 
    508507    } 
    509508    } 
    510509 
    511510    obj_termfile(); 
    512511} 
    513512 
    514513 
    515514/* ================================================================== */ 
    516515 
    517516void FuncDeclaration::toObjFile(int multiobj) 
    518517{ 
    …… 
    11421141    Symbol *s; 
    11431142    type *t; 
    11441143 
    11451144    t = Type::tint32->toCtype(); 
    11461145    s = symbol_name("critsec", SCstatic, t); 
    11471146    s->Sfl = FLdata; 
    11481147    /* Must match D_CRITICAL_SECTION in phobos/internal/critical.c 
    11491148     */ 
    11501149    dtnzeros(&s->Sdt, PTRSIZE + os_critsecsize()); 
    11511150#if ELFOBJ || MACHOBJ // Burton 
    11521151    s->Sseg = DATA; 
    11531152#endif 
    11541153    outdata(s); 
    11551154    return s; 
    11561155} 
    11571156 
    11581157/************************************** 
    11591158 * Generate elem that is a pointer to the module file name. 
    11601159 */ 
    11611160 
    1162 elem *Module::toEmodulename() 
    1163 { 
    1164    elem *efilename; 
    1165  
    1166     // Get filename 
    1167     if (needModuleInfo()) 
    1168     {   Symbol *si; 
    1169  
    1170     /* Class ModuleInfo is defined in std.moduleinfo. 
    1171      * The module name will be at nameoffset from the start of it. 
    1172      */ 
    1173  
    1174     si = toSymbol(); 
    1175  
    1176     //printf("nameoffset = x%x\n", nameoffset); 
    1177     assert(nameoffset >= 4); 
    1178  
    1179     efilename = el_ptr(si); 
    1180     efilename = el_bin(OPadd, TYnptr, efilename, el_long(TYsize_t, nameoffset)); 
    1181     efilename = el_pair(TYdarray, el_long(TYsize_t, namelen), efilename); 
    1182     } 
    1183     else // generate our own filename 
    1184     { 
    1185     efilename = toEfilename(); 
    1186     } 
    1187     return efilename; 
    1188 } 
    1189  
    11901161elem *Module::toEfilename() 
    11911162{   elem *efilename; 
    11921163 
    11931164    if (!sfilename) 
    11941165    { 
    11951166    dt_t *dt = NULL; 
    11961167    char *id; 
    11971168    int len; 
    11981169 
    11991170    id = srcfile->toChars(); 
    12001171    len = strlen(id); 
    12011172    dtdword(&dt, len); 
    12021173    dtabytes(&dt,TYnptr, 0, len + 1, id); 
    12031174 
    12041175    sfilename = symbol_generate(SCstatic,type_fake(TYdarray)); 
    12051176    sfilename->Sdt = dt; 
    12061177    sfilename->Sfl = FLdata; 
    12071178#if ELFOBJ 
    12081179    sfilename->Sseg = CDATA; 
    12091180#endif 

  • trunk/src/module.h

    r393 r395  
    153153    unsigned *covb;     // bit array of valid code line numbers 
    154154 
    155155    Symbol *sictor;     // module order independent constructor 
    156156    Symbol *sctor;      // module constructor 
    157157    Symbol *sdtor;      // module destructor 
    158158    Symbol *ssharedctor;    // module shared constructor 
    159159    Symbol *sshareddtor;    // module shared destructor 
    160160    Symbol *stest;      // module unit test 
    161161 
    162162    Symbol *sfilename;      // symbol for filename 
    163163 
    164164    Symbol *massert;        // module assert function 
    165165    Symbol *toModuleAssert();   // get module assert function 
    166166 
    167167    Symbol *marray;     // module array bounds function 
    168168    Symbol *toModuleArray();    // get module array bounds function 
    169169 
    170170 
    171171    static Symbol *gencritsec(); 
    172172    elem *toEfilename(); 
    173     elem *toEmodulename(); 
    174173 
    175174    Symbol *toSymbol(); 
    176175    void genmoduleinfo(); 
    177176 
    178177    Module *isModule() { return this; } 
    179178}; 
    180179 
    181180 
    182181struct ModuleDeclaration 
    183182{ 
    184183    Identifier *id; 
    185184    Array *packages;        // array of Identifier's representing packages 
    186185    bool safe; 
    187186 
    188187    ModuleDeclaration(Array *packages, Identifier *id, bool safe); 
    189188 
    190189    char *toChars(); 
    191190}; 
    192191 
    193192#endif /* DMD_MODULE_H */ 

  • trunk/src/s2ir.c

    r288 r395  
    11351135    for (block *bt = b->Btry; bt != bdest->Btry; bt = bt->Btry) 
    11361136    { 
    11371137        if (!bt) 
    11381138        { 
    11391139        //printf("b->Btry = %p, bdest->Btry = %p\n", b->Btry, bdest->Btry); 
    11401140        error("cannot goto into try block"); 
    11411141        break; 
    11421142        } 
    11431143    } 
    11441144 
    11451145    //setScopeIndex(blx, b, bdest->Btry ? bdest->Btry->Bscope_index : -1); 
    11461146    } 
    11471147 
    11481148    list_append(&b->Bsucc,bdest); 
    11491149    incUsage(irs, loc); 
    11501150    block_next(blx,BCgoto,NULL); 
    11511151} 
    11521152 
    11531153void SwitchErrorStatement::toIR(IRState *irs) 
    11541154{ 
    1155     elem *e; 
    1156     elem *elinnum; 
    1157     elem *efilename; 
    11581155    Blockx *blx = irs->blx; 
    11591156 
    11601157    //printf("SwitchErrorStatement::toIR()\n"); 
    11611158 
    1162     efilename = blx->module->toEmodulename(); 
    1163     elinnum = el_long(TYint, loc.linnum); 
    1164     e = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_DSWITCHERR]), el_param(elinnum, efilename)); 
     1159    elem *efilename = el_ptr(blx->module->toSymbol()); 
     1160    elem *elinnum = el_long(TYint, loc.linnum); 
     1161    elem *e = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_DSWITCHERR]), el_param(elinnum, efilename)); 
    11651162    block_appendexp(blx->curblock, e); 
    11661163} 
    11671164 
    11681165/************************************** 
    11691166 */ 
    11701167 
    11711168void ReturnStatement::toIR(IRState *irs) 
    11721169{ 
    11731170    Blockx *blx = irs->blx; 
    11741171 
    11751172    incUsage(irs, loc); 
    11761173    if (exp) 
    11771174    {   elem *e; 
    11781175 
    11791176    FuncDeclaration *func = irs->getFunc(); 
    11801177    assert(func); 
    11811178    assert(func->type->ty == Tfunction); 
    11821179    TypeFunction *tf = (TypeFunction *)(func->type); 
    11831180 
    11841181    enum RET retmethod = tf->retStyle(); 

  • trunk/src/toobj.c

    r394 r395  
    156156#endif 
    157157        dtxoff(&dt, s, 0, TYnptr); 
    158158        } 
    159159    } 
    160160    } 
    161161    if (flags & MIlocalClasses) 
    162162    { 
    163163    dtdword(&dt, aclasses.dim); 
    164164    for (int i = 0; i < aclasses.dim; i++) 
    165165    { 
    166166        ClassDeclaration *cd = (ClassDeclaration *)aclasses.data[i]; 
    167167        dtxoff(&dt, cd->toSymbol(), 0, TYnptr); 
    168168    } 
    169169    } 
    170170 
    171171    // Put out module name as a 0-terminated string, to save bytes 
    172172    nameoffset = dt_size(dt); 
    173173    const char *name = toPrettyChars(); 
    174174    namelen = strlen(name); 
    175175    dtnbytes(&dt, namelen + 1, name); 
     176    //printf("nameoffset = x%x\n", nameoffset); 
    176177#else 
    177178    /* The layout is: 
    178179       { 
    179180        void **vptr; 
    180181        monitor_t monitor; 
    181182        char[] name;        // class name 
    182183        ModuleInfo importedModules[]; 
    183184        ClassInfo localClasses[]; 
    184185        uint flags;         // initialization state 
    185186        void *ctor; 
    186187        void *dtor; 
    187188        void *unitTest; 
    188189        const(MemberInfo[]) function(string) xgetMembers;   // module getMembers() function 
    189190        void *ictor; 
    190191        void *sharedctor; 
    191192        void *shareddtor; 
    192193        uint index; 
    193194        void*[1] reserved; 
    194195       } 
    195196     */