Changeset 224

Show
Ignore:
Timestamp:
08/02/06 14:27:59 (2 years ago)
Author:
pragma
Message:

Bugfixes for linking and improvments to debug output.
Still buggy.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/ddl/DynamicModule.d

    r218 r224  
    135135        is undefined and could easily result in a protection-fault/segmentation-fault. 
    136136    */ 
    137     public bit isResolved();  
     137    public bool isResolved();  
    138138     
    139139    /** 
    …… 
    146146        If true, the module is being linked.  If false, the module is not being linked. 
    147147    */ 
    148     public bit isLinking; 
     148    public bool isLinking; 
    149149} 
    150150 

  • trunk/ddl/Linker.d

    r221 r224  
    109109        return this.registry; 
    110110    } 
    111      
     111 
    112112    /** 
    113113        Initalizes a ModuleInfo instance from a DynamicModule. 
    …… 
    116116    */ 
    117117    protected void initModule(ModuleInfo m, int skip){ 
    118         if(!m) return; 
     118        if(m is null) return; 
    119119        if (m.flags & MIctordone) return; 
    120120 
    121121        debug debugLog("this module: %0.8X",cast(void*)m); 
    122         debug debugLog("(name: %0.8X)",m.name.ptr);        
     122        debug debugLog("(name: %0.8X %d)",m.name.ptr,m.name.length);       
    123123        debug debugLog("(ctor: %0.8X)",cast(void*)(m.ctor)); 
    124124        debug debugLog("(dtor: %0.8X)",cast(void*)(m.dtor)); 
    …… 
    136136            debug debugLog("running imported modules (%d)...",m.importedModules.length); 
    137137            foreach(ModuleInfo imported; m.importedModules){ 
     138                debug debugLog("running: [%0.8X]",cast(void*)imported); 
    138139                initModule(imported,0); 
     140                debug debugLog("-done."); 
    139141            } 
    140142            if (m.ctor) 
    …… 
    150152            debug debugLog("running imported modules (%d)...",m.importedModules.length); 
    151153            foreach(ModuleInfo imported; m.importedModules){ 
     154                debug debugLog("running: [%0.8X]",cast(void*)imported); 
    152155                initModule(imported,1); 
     156                debug debugLog("-done."); 
    153157            } 
    154158        }     
    155159    } 
     160     
     161    alias ModuleInfo[DynamicModule] ModuleSet;   
    156162         
    157163    /** 
    …… 
    162168         
    163169        The parameter canSelfResolve is passed as 'true' for registraion variants of link  
    164         routines 
    165     */ 
    166     public void link(DynamicModule mod,bool canSelfResolve=false){ 
     170        routines. 
     171         
     172        moduleSet a set of modules that need initalization following the link pass. 
     173    */ 
     174    public void link(DynamicModule mod, inout ModuleSet moduleSet, bool canSelfResolve=false){ 
     175        uint i; 
     176         
    167177        //protect against infinite recursion here by returning early 
    168178        //by this, we count on the module being resolved further up the call stack 
    …… 
    174184         
    175185        auto moduleSymbols = mod.getSymbols(); 
    176         for(uint i=0; i<moduleSymbols.length; i++){ 
     186        for(i=0; i<moduleSymbols.length; i++){ 
    177187            auto symbol = &(moduleSymbols[i]); 
    178188             
    …… 
    181191            foreach(lib; this.libraries){ 
    182192                auto libMod = lib.getModuleForSymbol(symbol.name); 
    183                 if(libMod){ 
     193                if(libMod && libMod != mod){ 
    184194                    if(!libMod.isResolved()){ 
    185                         this.link(libMod,true); 
     195                        this.link(libMod,moduleSet,true); 
    186196                    } 
    187197                    auto otherSymbol = libMod.getSymbol(symbol.name); 
    …… 
    204214     
    205215        if(canSelfResolve){ 
    206             foreach(sym; mod.getSymbols){ 
    207                 if(sym.type == SymbolType.Weak) sym.type = SymbolType.Strong; 
     216            for(i=0; i<moduleSymbols.length; i++){ 
     217                auto symbol = &(moduleSymbols[i]); 
     218                if(symbol.type == SymbolType.Weak) symbol.type = SymbolType.Strong; 
    208219            } 
    209220        } 
    …… 
    218229        } 
    219230                     
    220         // dig up the ModuleInfo (if applicable) and initalize it! 
    221         foreach(sym; mod.getSymbols){ 
    222             if(!sym.address) continue; 
    223             if(getDemangleType(sym.name) == DemangleType.ModuleInfo){ 
    224                 // found it, now get it and run the constructor 
    225                 ModuleInfo moduleInfo = cast(ModuleInfo)(sym.address); 
    226                 debug debugLog("init! %s %s %0.8X",sym.name,sym.getTypeName,sym.address); 
    227                 initModule(moduleInfo,0); 
    228                 debug debugLog("init done."); 
    229                 break; 
     231        // dig up the ModuleInfo (if applicable) and store it for later use. 
     232        if(!(mod in moduleSet)){ 
     233            debug debugLog("looking for: %s","__ModuleInfo_" ~ mod.getRawNamespace); 
     234            auto sym = mod.getSymbol("__ModuleInfo_" ~ mod.getRawNamespace); 
     235            if(sym.address != null){ 
     236                debug debugLog("Found moduleinfo for %s at [%0.8X] %s",mod.getNamespace,sym.address,sym.name); 
     237                moduleSet[mod] = cast(ModuleInfo)(sym.address); 
    230238            } 
    231239        } 
    …… 
    246254        Linker linker; 
    247255         
    248         linker.add(lib); // add to xref first 
     256        linker.register(lib); // add to xref first 
    249257        linker.link(lib); // link in the library and its aggregate modules 
    250258        --- 
    251259    */ 
    252260    public void link(DynamicLibrary lib){ 
     261        ModuleSet moduleSet; 
     262         
     263        // link 
    253264        foreach(DynamicModule mod; lib.getModules){ 
    254             this.link(mod); 
     265            this.link(mod,moduleSet); 
     266        } 
     267        // init 
     268        foreach(mod,moduleInfo; moduleSet){ 
     269            debug debugLog("running %s init at [%0.8X]",mod.getName,cast(void*)moduleInfo); 
     270            this.initModule(moduleInfo,0); 
    255271        } 
    256272    } 

  • trunk/ddl/Mangle.d

    r221 r224  
    6565    uint i=0; 
    6666    uint last=0; 
    67     result ~= "_D"; 
    6867    while(i < text.length){ 
    6968        if(text[i] == '.'){ 

  • trunk/ddl/insitu/InSituModule.d

    r218 r224  
    3737     
    3838    public char[] getName(){ 
    39         return ""; 
     39        return "<in-situ>"; 
    4040    } 
    4141         

  • trunk/ddl/omf/OMFBinary.d

    r220 r224  
    121121} 
    122122 
    123 void parse(inout EXTDEF[] externs,inout FixupTarget[] targets,OMFReader reader){ 
     123void parse(inout EXTDEF[] externs,OMFReader reader){ 
    124124    while(reader.hasMore()){ 
    125125        EXTDEF extdef;       
    126126        extdef.parse(reader); 
    127         externs ~= extdef; 
    128          
    129         FixupTarget target; 
    130         target.type = FixupTarget.EXTDEF; 
    131         target.index = externs.length-1; 
    132         targets ~= target;       
     127        externs ~= extdef;   
    133128    } 
    134129} 
    …… 
    154149} 
    155150 
    156 void parse(inout PUBDEF[] publics,inout FixupTarget[] targets,OMFReader reader){ 
     151void parse(inout PUBDEF[] publics,OMFReader reader){ 
    157152    OMFIndex groupIndex; 
    158153    OMFIndex segmentIndex; 
    …… 
    181176         
    182177        publics ~= pub; 
    183          
    184         FixupTarget target; 
    185         target.type = FixupTarget.PUBDEF; 
    186         target.index = publics.length-1; 
    187         targets ~= target; 
    188178    } 
    189179} 
    …… 
    366356        //not used 
    367357    } 
    368 } 
    369  
    370  
    371 /** 
    372     Defines a mapping between a record and a logical fixup target index. 
    373 */ 
    374 struct FixupTarget{ 
    375     enum: ubyte{ 
    376         PUBDEF, 
    377         CEXTDEF, 
    378         COMDAT, 
    379         EXTDEF 
    380     } 
    381     ubyte type; 
    382     uint index; 
    383358} 
    384359 
    …… 
    710685} 
    711686 
    712 void parse(inout CEXTDEF[] commonExterns,inout FixupTarget[] targets,OMFReader reader){ 
     687void parse(inout CEXTDEF[] commonExterns,OMFReader reader){ 
    713688    while(reader.hasMore()){ 
    714689        CEXTDEF def; 
    715690        def.parse(reader); 
    716691        commonExterns ~= def; 
    717          
    718         FixupTarget target; 
    719         target.type = FixupTarget.CEXTDEF; 
    720         target.index = commonExterns.length-1; 
    721         targets ~= target; 
    722692    } 
    723693} 
    …… 
    774744} 
    775745 
    776 void parse(inout COMDAT[] commonData,inout FixupData fixupData,inout FixupTarget[] targets,OMFReader reader){ 
     746void parse(inout COMDAT[] commonData,inout FixupData fixupData,OMFReader reader){ 
    777747    while(reader.hasMore()){ 
    778748        COMDAT data; 
    …… 
    784754        fixupData.offset = data.enumDataOffset; 
    785755        fixupData.destNameIndex = data.nameIndex; 
    786          
    787         if(!data.isContinuation){        
    788             FixupTarget target; 
    789             target.type = FixupTarget.COMDAT; 
    790             target.index = commonData.length-1; 
    791             targets ~= target; 
    792         } 
    793756    } 
    794757} 
    …… 
    898861    LString libraryName; 
    899862    LString[] names; 
    900     FixupTarget[] targets; 
    901863     
    902864    // comment sub data 
    …… 
    942904        names.length = names.length+1; 
    943905        externs.length = externs.length+1; 
    944         targets.length = targets.length+1; 
    945906         
    946907        while(mainReader.hasMore()){ 
    …… 
    967928             
    968929            case 0x8C: //EXTDEF 
    969                 .parse(externs,targets,reader); 
     930                .parse(externs,reader); 
    970931                break; 
    971932             
    972933            case 0x90: //PUBDEF 
    973                 .parse(publics,targets,reader);  
     934                .parse(publics,reader);  
    974935                break; 
    975936             
    …… 
    1007968                 
    1008969            case 0xBC: //CEXTDEF 
    1009                 .parse(communalExterns,targets,reader);  
     970                .parse(communalExterns,reader);  
    1010971                break; 
    1011972                 
    1012973            case 0xC2: //COMDAT 
    1013                 .parse(communalData,fixupData,targets,reader);  
     974                .parse(communalData,fixupData,reader);  
    1014975                break; 
    1015976                 
    …… 
    12751236            } 
    12761237        } 
    1277          
    1278         result ~= "Fixup Targets:\n"; 
    1279         foreach(idx,target; targets) with(target){ 
    1280             char[] targetTypeName; 
    1281             switch(type){ 
    1282             case FixupTarget.COMDAT: targetTypeName = "COMDAT"; break; 
    1283             case FixupTarget.PUBDEF: targetTypeName = "PUBDEF"; break; 
    1284             case FixupTarget.EXTDEF: targetTypeName = "EXTDEF"; break; 
    1285             case FixupTarget.CEXTDEF: targetTypeName = "CEXTDEF"; break; 
    1286             } 
    1287             result ~= sprint("  %d: %s %d\n",idx,targetTypeName,index); 
    1288         }        
    12891238                     
    12901239        return result; 

  • trunk/ddl/omf/OMFModule.d

    r223 r224  
    3535 
    3636private import mango.io.model.IReader; 
     37private import mango.text.Text; 
    3738 
    3839version(Windows){ 
    …… 
    4950        bool isExternStyleFixup; 
    5051        bool isSegmentRelative; 
    51         void* destAddress; 
     52        ExportSymbolPtr destSymbol; 
     53        uint destSymbolOffset; 
     54        void* destSegmentAddress; 
    5255    } 
    5356     
    …… 
    9194        foreach(idx,fix; fixups) with(fix){ 
    9295            uint fixupValue; 
     96            uint destAddress; 
     97             
     98            // get the dest address 
     99            if(destSymbol){ 
     100                destAddress = cast(uint)destSymbol.address + destSymbolOffset; 
     101            } 
     102            else{ 
     103                destAddress = cast(uint)destSegmentAddress; 
     104            } 
    93105             
    94106            // get the fixup value 
    …… 
    104116                fixupValue = cast(uint)(segmentImages[targetIndex].data.ptr); 
    105117            } 
     118            debug debugLog("fixup dest [%0.8X] = fixupValue [%0.8X] rel:%d",destAddress,fixupValue,cast(uint)isSegmentRelative); 
    106119             
    107120            // apply the fixup value 
    …… 
    116129            } 
    117130            else{ // self relative 
    118                 *cast(uint*)destAddress += fixupValue;           
    119             } 
     131                *cast(uint*)destAddress += fixupValue;       
     132            } 
     133             
     134            debug debugLog("\tfixed to: [%0.8X]",*cast(uint*)destAddress); 
    120135        } 
    121136        this.fixups = remainingFixups; 
    …… 
    141156        //TODO: alter this to zero in on D namespaces and C/asm namespaces 
    142157        this.moduleName = binary.libraryName; 
     158        this.moduleName = Text.replace(this.moduleName,'\\','.'); 
    143159        //debug debugLog(moduleName); 
    144160         
    …… 
    378394            newFix.isExternStyleFixup = fix.isExternStyleFixup; 
    379395            newFix.targetIndex = fix.targetIndex; 
     396            newFix.destSymbolOffset = 0; 
     397            newFix.destSymbol = null; 
     398            newFix.destSegmentAddress = null; 
    380399             
    381400            if(fix.destNameIndex > 0){ 
    382401                //TODO: this assumes that these fixups are strong - needs to be loosened so that weak symbols can be resolved (?) 
    383                 newFix.destAddress = symbolXref[binary.names[fix.destNameIndex]].address + fix.destOffset; 
     402                newFix.destSymbol = symbolXref[binary.names[fix.destNameIndex]]; 
     403                newFix.destSymbolOffset = fix.destOffset; 
    384404            } 
    385405            else{ 
    386                 newFix.destAddress = cast(uint*)(segmentImages[fix.destSegmentIndex].data.ptr + fix.destOffset); 
     406                newFix.destSegmentAddress = cast(uint*)(segmentImages[fix.destSegmentIndex].data.ptr + fix.destOffset); 
    387407            } 
    388408            fixups ~= newFix; 
    …… 
    422442                    char[] ext = isExternStyleFixup ? "externStyle" : "segmentStyle"; 
    423443                             
    424                     result ~= sprint("  %d: %0.8X %s %s",idx,destAddress,rel,ext); 
    425      
    426                     if(isExternStyleFixup){ 
    427                         result ~= sprint(" | %s\n",symbols[targetIndex-1].name); 
     444                    result ~= sprint("  %d: %s %s",idx,rel,ext); 
     445 
     446                    if(destSymbol){ 
     447                        result ~= sprint(" | %s [%0.8X]",destSymbol.name,cast(uint)destSymbol.address+destSymbolOffset); 
    428448                    } 
    429449                    else{ 
    430                         result ~= sprint(" | segment #%d\n",targetIndex); 
    431                     }                
     450                        result ~= sprint(" | [%0.8X]",cast(uint)destSegmentAddress); 
     451                    }                    
     452                         
     453                    if(isExternStyleFixup){ 
     454                        result ~= sprint(" | %s [%0.8X]",symbols[targetIndex-1].name,symbols[targetIndex-1].address); 
     455                    } 
     456                    else{ 
     457                        result ~= sprint(" | segment #%d [%0.8X]",targetIndex,segmentImages[targetIndex].data.ptr); 
     458                    } 
     459                    result ~= "\n"; 
    432460                } 
    433461            }            

  • trunk/test/testconfig.d

    r223 r224  
    2626 
    2727/// path to DMD directory - change as needed 
    28 static char[] dmdPath = "d:\\programs\\dmd\\"; 
     28static char[] dmdPath = "c:\\programs\\dmd\\"; 
    2929 
    3030/// path to DMC linker and utils - change as needed 
    31 static char[] dmPath = "d:\\programs\\dm\\"; 
     31static char[] dmPath = "c:\\programs\\dm\\"; 

  • trunk/test/testmodule.d

    r221 r224  
    5050    } 
    5151    public void callable() { 
    52       writefln("In externally callable function, A=", a); 
     52      printf("In externally callable function, A=%d\n", a); 
    5353    } 
    5454     
    5555    private void test(){ 
    56         writefln("A = %d",a); 
     56        printf("A = %d\n",a); 
    5757    } 
    5858     
    5959    static this(){ 
    60         writefln("TestClass initialized"); 
     60        printf("writefln: [%0.8X]\n",&writefln); 
     61        //writefln(""); 
     62    } 
     63     
     64    public void exceptionTest(){ 
     65        throw new Exception("From - test.testmodule.TestClass.exceptionTest()"); 
    6166    } 
    6267} 
    6368 
     69uint intialized = false; 
     70 
    6471static this(){ 
    6572    printf("testmodule initalized\n"); 
     73    intialized = true; 
    6674} 
    6775 
    …… 
    100108} 
    101109 
     110public void exceptionTest(){ 
     111    printf("Throwing..."); 
     112    throw new Exception("From - test.testmodule.exceptionTest()"); 
     113    printf("You shouldn't be here. :(\n"); 
     114} 
     115 
     116public void exceptionTest2(){ 
     117    try{ 
     118        exceptionTest(); 
     119    } 
     120    catch(Exception e){ 
     121        printf("That worked alright.\n"); 
     122    } 
     123    printf("Done with exceptionTest2\n"); 
     124} 
    102125  
    103126/* Eratosthenes Sieve prime number calculation. */ 

  • trunk/utils/bless_bn.d

    r222 r224  
    22// This file is automatically maintained by the BUILD utility, 
    33// Please refrain from manually editing it. 
    4 long auto_build_number = 660; 
     4long auto_build_number = 662; 

  • trunk/utils/ddlinfo_bn.d

    r222 r224  
    22// This file is automatically maintained by the BUILD utility, 
    33// Please refrain from manually editing it. 
    4 long auto_build_number = 710; 
     4long auto_build_number = 713; 

  • trunk/utils/insitu_bn.d

    r222 r224  
    22// This file is automatically maintained by the BUILD utility, 
    33// Please refrain from manually editing it. 
    4 long auto_build_number = 657; 
     4long auto_build_number = 659;