Changeset 285

Show
Ignore:
Timestamp:
06/17/07 22:24:47 (1 year ago)
Author:
pragma
Message:

Fixed debug output and fixed subtle bugs with the insitu map loader.
The insitu lib loader is disabled in this release.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/ddl/DefaultRegistry.d

    r271 r285  
    5858            register(new OMFObjLoader()); 
    5959            register(new DDLLoader()); 
    60           register(new InSituLibLoader()); 
     60    //        register(new InSituLibLoader()); 
    6161            register(new InSituMapLoader()); 
    6262            register(new ArchiveLoader());           
    …… 
    6868            register(new ELFObjLoader()); 
    6969            register(new DDLLoader()); 
    70           register(new InSituLibLoader());             
     70    //        register(new InSituLibLoader());             
    7171            register(new OMFLibLoader()); 
    7272            register(new OMFObjLoader()); 

  • trunk/ddl/Linker.d

    r281 r285  
    218218        mod.isLinking = true; 
    219219         
    220         debug debugLog("Linking module: %s",mod.getName); 
     220        debug debugLog("Linking module: {0}",mod.getName); 
    221221         
    222222        auto moduleSymbols = mod.getSymbols(); 
    …… 
    237237                    auto otherSymbol = libMod.getSymbol(symbol.name); 
    238238                    if(otherSymbol.type == SymbolType.Strong){ 
    239                         debug debugLog("[Linker] found %s at %0.8X",otherSymbol.name,otherSymbol.address); 
     239                        debug debugLog("[Linker] found {0} at {1:8X}",otherSymbol.name,otherSymbol.address); 
    240240                        symbol.address = otherSymbol.address; 
    241241                        symbol.type = SymbolType.Strong; 
    …… 
    244244                        goto nextSymbol; 
    245245                    } 
    246                     debug debugLog("symbol is not strong (%s -> %0.8X)",symbol.getTypeName,symbol.address); 
     246                    debug debugLog("symbol is not strong ({0} -> {1:8X})",symbol.getTypeName,symbol.address); 
    247247                } 
    248248            } 
    …… 
    254254                char[] ext = symbol.isExternal ? "external" : "local"; 
    255255                char[] self = canSelfResolve ? "can Self Resolve" : "cannot Self Resolve"; 
    256                 throw new DDLException("cannot resolve symbol: (%s) [%0.8X] %s %s %s\n",self,cast(uint)symbol.address,symbol.getTypeName(),ext,symbol.name); 
     256                throw new DDLException("cannot resolve symbol: ({0}) [{1:8X}] {2} {3} {4}\n",self,cast(uint)symbol.address,symbol.getTypeName(),ext,symbol.name); 
    257257            } 
    258258             
    …… 
    268268        } 
    269269         
    270         debug debugLog("mod is resolved: %s",mod.toString()); 
     270        debug debugLog("mod is resolved: {0}",mod.toString()); 
    271271 
    272272        auto allSymbols = mod.getSymbols(); 
    …… 
    284284            char[] suffix = `__ModuleInfoZ`; 
    285285            if (symbol.name.length > suffix.length && symbol.name[$ - suffix.length .. $] == suffix) { 
    286                 debug debugLog("Found moduleinfo for %s at [%0.8X] %s",mod.getName,symbol.address,symbol.name); 
     286                debug debugLog("Found moduleinfo for {0} at [{1:8X}] {2}",mod.getName,symbol.address,symbol.name); 
    287287                moduleSet[symbol.name] = cast(ModuleInfo)(symbol.address); 
    288288            } 
    …… 
    326326        // init - run whatever initalizers are pending 
    327327        foreach(mod,moduleInfo; moduleSet){ 
    328             debug debugLog("running %s init at [%0.8X]",mod,cast(void*)moduleInfo); 
     328            debug debugLog("running {0} init at [{1:8X}]",mod,cast(void*)moduleInfo); 
    329329            this.initModule(moduleInfo,0); 
    330330        } 
    …… 
    355355    public void register(DynamicLibrary lib){ 
    356356        debug foreach(DynamicModule mod; lib.getModules){ 
    357             debugLog("[Linker.register]: %s",mod.getName); 
     357            debugLog("[Linker.register]: {0}",mod.getName); 
    358358        } 
    359359        libraries ~= lib; 

  • trunk/ddl/ar/ArchiveLibrary.d

    r279 r285  
    8080            offset += 4; 
    8181        } 
    82         debug debugLog("* Found %s symbol offsets in symbol table,latest offset was {0} ", offsets.length, offset); 
     82        debug debugLog("* Found {0} symbol offsets in symbol table,latest offset was {1} ", offsets.length, offset); 
    8383         
    8484        uint offsetIdx = 0; 
    …… 
    135135            } 
    136136         
    137             debug debugLog("* Iterating over files, current is %s", fName);  
     137            debug debugLog("* Iterating over files, current is {0}", fName);  
    138138            switch(fName){ 
    139139            case "/": 

  • trunk/ddl/coff/COFFBinary.d

    r279 r285  
    149149    char[] toString() 
    150150    { 
    151         return format( "%s (%s)", name, filename ); 
     151        return format( "{0} ({1:8X})", name, filename ); 
    152152    } 
    153153======= 
    …… 
    161161    char[] toString() 
    162162    { 
    163         return format( "%s (%s)", name, filename ); 
     163        return format( "{0} ({1:8X})", name, filename ); 
    164164    } 
    165165>>>>>>> .r278 

  • trunk/ddl/coff/CodeViewParser.d

    r264 r285  
    132132            char sigStr[4]; 
    133133            memcpy( sigStr.ptr, &sig.Signature, 4 ); 
    134             writefln( "\t\tCodeView Signature: %08X (%s)", sig.Signature, sigStr ); 
    135             writefln( "\t\tFile offset: %08X", sig.Filepos ); 
     134            writefln( "\t\tCodeView Signature: {0:8X} ({1})", sig.Signature, sigStr ); 
     135            writefln( "\t\tFile offset: {0:8X}", sig.Filepos ); 
    136136        } 
    137137 

  • trunk/ddl/elf/ELFBinary.d

    r279 r285  
    187187                debug{ 
    188188                    foreach(sym; symbols){ 
    189                         debugLog("sym: %d %s %s %s",sym.st_name,toDString(&stringTable[sym.st_name]),sym.getTypeName,sym.getBindName); 
     189                        debugLog("sym: {0} {1} {2} {3}",sym.st_name,toDString(&stringTable[sym.st_name]),sym.getTypeName,sym.getBindName); 
    190190                    } 
    191191                } 

  • trunk/ddl/insitu/InSituLibrary.d

    r279 r285  
    11/+ 
    2     Copyright (c) 2005 Eric Anderton 
     2    Copyright (c) 2005-2007 Eric Anderton 
    33         
    44    Permission is hereby granted, free of charge, to any person 
    …… 
    6060     
    6161    public ExportSymbolPtr getSymbol(char[] name){ 
    62         return dictionary[name]; 
     62        ExportSymbolPtr* value = name in dictionary; 
     63        if(value) return *value; 
     64        return null; 
    6365    } 
    6466     

  • trunk/ddl/insitu/InSituLoader.d

    r279 r285  
    3434 
    3535private import ddl.insitu.InSituMapBinary; 
    36 private import ddl.insitu.InSituLibBinary; 
     36//private import ddl.insitu.InSituLibBinary; 
    3737private import ddl.insitu.InSituLibrary; 
    3838 
     39/* 
    3940class InSituLibLoader : DynamicLibraryLoader{ 
    4041    static char[] typeName = "SITU"; 
    …… 
    5859        return new InSituLibrary(binary);    
    5960    } 
    60 } 
     61}*/ 
    6162 
    6263class InSituMapLoader : DynamicLibraryLoader{ 

  • trunk/ddl/insitu/InSituMapBinary.d

    r279 r285  
    9898    } 
    9999     
    100     protected void parseSegmentDefinitions(LineIterator iter){ 
     100    protected void parseSegmentDefinitions(inout LineIterator iter){ 
    101101        char[] line; 
    102102        line = iter.getNext(); // throw away the first line (blank) 
    …… 
    110110    } 
    111111     
    112     protected void parseExports(LineIterator iter){ 
     112    protected void parseExports(inout LineIterator iter){ 
    113113        char[] line; 
    114114         
    115115        // parse exports section if the header matches correctly 
    116116        line = iter.getNext(); 
    117          
     117                        
    118118        //HACK: the difference between the presence of an exports section in the .map 
    119119        // file is determined by the token " Address" at the start of the line. 
    …… 
    131131    } 
    132132     
    133     protected void parsePublicsByName(LineIterator iter){ 
     133    protected void parsePublicsByName(inout LineIterator iter){ 
    134134        char[] line; 
    135135         

  • trunk/ddl/omf/OMFBinary.d

    r279 r285  
    627627                         
    628628        if(dataType < 0x51){ 
    629             throw new FeatureNotSupportedException("COMDEF segment number only for %s is not supported",communalName,dataType); 
     629            throw new FeatureNotSupportedException("COMDEF segment number only for {0} is not supported",communalName,dataType); 
    630630        } 
    631631        else if(dataType == 0x61){ 
    …… 
    639639        } 
    640640        else{ 
    641             throw new FeatureNotSupportedException("COMDEF type %0.2X is not supported for %s",dataType,communalName); 
     641            throw new FeatureNotSupportedException("COMDEF type {0:2X} is not supported for {1}",dataType,communalName); 
    642642        } 
    643643    } 
    …… 
    10141014            default: //??? 
    10151015                char[] recordName = recordNameLookup[thisRecord.recordType]; 
    1016                 throw new FeatureNotSupportedException("Unsupported Record: %s",recordName); 
     1016                throw new FeatureNotSupportedException("Unsupported Record: {0}",recordName); 
    10171017            } 
    10181018        }        
    …… 
    10811081        foreach(idx,name; names){ 
    10821082            if(idx == 0) continue; 
    1083             result ~= sprint("  %d: %s\n",idx,cast(char[])name); 
     1083            result ~= sprint("  {0}: {1}\n",idx,cast(char[])name); 
    10841084        } 
    10851085         
    …… 
    10901090                char[] mod = moduleName; 
    10911091                if(entryName){ 
    1092                     result ~= sprint("  %d: %s in %s as %s\n",idx,internal,mod,cast(char[])entryName); 
     1092                    result ~= sprint("  {0}: {1} in {2} as {3}\n",idx,internal,mod,cast(char[])entryName); 
    10931093                } 
    10941094                else{ 
    1095                     result ~= sprint("  %d: %s in %s as #%d\n",idx,internal,mod,entryOrdinal); 
     1095                    result ~= sprint("  {0}: {1} in {2} as #{3}\n",idx,internal,mod,entryOrdinal); 
    10961096                } 
    10971097            } 
    …… 
    11061106                uint cextedfsLength = communalExterns.length;    
    11071107                                     
    1108                 result ~= sprint("  %d: (%d) %s --> (%d) %s\n",idx,cast(uint)weakIndex,weakName,cast(uint)resolutionIndex,defaultName); 
     1108                result ~= sprint("  {0}: ({1}) {2} --> ({3}) {4}\n",idx,cast(uint)weakIndex,weakName,cast(uint)resolutionIndex,defaultName); 
    11091109            } 
    11101110        } 
    …… 
    11141114            with(ext){ 
    11151115                char[] name = cast(char[])name; 
    1116                 result ~= sprint("  %d: %s\n",idx,name); 
     1116                result ~= sprint("  {0}: {1}\n",idx,name); 
    11171117            } 
    11181118        }    
    …… 
    11261126                uint ofs = cast(uint)offset; 
    11271127                 
    1128                 result ~= sprint("  %d: %s %s:%s:%0.8X\n",idx,thisName,group,segment,ofs); 
     1128                result ~= sprint("  {0}: {1} {2}:{3}:{4:8X}\n",idx,thisName,group,segment,ofs); 
    11291129            } 
    11301130        }    
    …… 
    11401140                char[] combination = getCombination(); 
    11411141                                 
    1142                 result ~= sprint("  %d: %s %s %s %s %d bytes align:%d\n",idx,name,className,overlayName,combination,length,byteAlignment); 
     1142                result ~= sprint("  {0}: {1} {2} {3} {4} {5} bytes align:{6}\n",idx,name,className,overlayName,combination,length,byteAlignment); 
    11431143            } 
    11441144        }    
    …… 
    11491149            with(grp){ 
    11501150                char[] name = names[nameIndex]; 
    1151                 result ~= sprint("  %d: %s",idx,name); 
     1151                result ~= sprint("  {0}: {1}",idx,name); 
    11521152                 
    11531153                foreach(segmentIndex; segments){ 
    …… 
    11761176                } 
    11771177                 
    1178                 result ~= sprint("  %d: %s:%s%d rel: %s | %d %s\n",idx,segment,destName,destOffset,rel,targetIndex,targetName); 
     1178                result ~= sprint("  {0}: {1}:{2}{3} rel: {4} | {5} {6}\n",idx,segment,destName,destOffset,rel,targetIndex,targetName); 
    11791179            } 
    11801180        }    
    …… 
    11851185                char[] segment = names[segments[segmentIndex].nameIndex]; 
    11861186                uint ofs = offset; 
    1187                 result ~= sprint("  %d: %s %d bytes at offset %d\n",idx,segment,data.length,ofs); 
     1187                result ~= sprint("  {0}: {1} {2} bytes at offset {3}\n",idx,segment,data.length,ofs); 
    11881188            } 
    11891189        }        
    …… 
    11941194                char[] segment = names[segments[segmentIndex].nameIndex]; 
    11951195                uint ofs = offset; 
    1196                 result ~= sprint("  %d: %s %d bytes at offset %d\n",idx,segment,data.length,ofs); 
     1196                result ~= sprint("  {0}: {1} {2} bytes at offset {3}\n",idx,segment,data.length,ofs); 
    11971197            } 
    11981198        }            
    …… 
    12021202            with(comdef){ 
    12031203                char[] name = communalName; 
    1204                 result ~= sprint("  %d: %s %d bytes\n",idx,name,length); 
     1204                result ~= sprint("  {0}: {1} {2} bytes\n",idx,name,length); 
    12051205            } 
    12061206        }        
    …… 
    12101210            with(cextdef){ 
    12111211                char[] name = names[nameIndex];                              
    1212                 result ~= sprint("  %d: %s\n",idx,name); 
     1212                result ~= sprint("  {0}: {1}\n",idx,name); 
    12131213            } 
    12141214        }    
    …… 
    12231223                uint offset = enumDataOffset; 
    12241224                                 
    1225                 result ~= sprint("  %d: %s%s:%s:%0.8X %d bytes %s\n", 
     1225                result ~= sprint("  {0}: {1}{2}:{3}:{4:8X} {5} bytes {6}\n", 
    12261226                    idx,cont,group,segment,offset,data.length,name); 
    12271227            } 
    …… 
    12341234                char[] name = names[nameIndex]; 
    12351235                 
    1236                 result ~= sprint("  %d: Line %d --> %s%s %0.8X\n", 
     1236                result ~= sprint("  {0}: Line {1} --> {2}{3} {4:8X}\n", 
    12371237                    idx,lineNumber,cont,name,cast(uint)baseOffset); 
    12381238            } 
    …… 
    12461246                uint offset = segmentOffset; 
    12471247                                 
    1248                 result ~= sprint("  %d: Line %d --> %s:%s:%0.8X\n", 
     1248                result ~= sprint("  {0}: Line {1} --> {2}:{3}:{4:8X}\n", 
    12491249                    idx,lineNumber,group,segment,offset); 
    12501250            } 

  • trunk/ddl/omf/OMFLibrary.d

    r279 r285  
    8080         
    8181    public DynamicModule getModuleForSymbol(char[] name){ 
    82         debug debugLog("[OMF] looking for %s in %s",name,attributes["omf.filename"]); 
     82        debug debugLog("[OMF] looking for {0} in {1}",name,attributes["omf.filename"]); 
    8383        DynamicModule* mod = name in crossReference; 
    84         debug debugLog("[OMF] Result: %0.8X",mod); 
     84        debug debugLog("[OMF] Result: {0:8X}",mod); 
    8585        if(mod) return *mod; 
    8686        return null; 

  • trunk/ddl/omf/OMFModule.d

    r279 r285  
    113113                if(destSymbol.isExternal){ 
    114114                    // discard this fixup - it references a non-local symbol 
    115                     debug debugLog("Discarded Fixup dest %s:%s [%0.8X] rel:%d",destSymbol.name,destSymbol.getTypeName(),destAddress,cast(uint)isSegmentRelative); 
     115                    debug debugLog("Discarded Fixup dest {0}:{1} [{2:8X}] rel:{3}",destSymbol.name,destSymbol.getTypeName(),destAddress,cast(uint)isSegmentRelative); 
    116116                    continue; 
    117117                } 
    118118                else{ 
    119                     debug debugLog("Fixup dest symbol: %s [%0.8X] %d",destSymbol.name,destSymbol.address,destSymbolOffset); 
     119                    debug debugLog("Fixup dest symbol: {0} [{1:8X}] {2}",destSymbol.name,destSymbol.address,destSymbolOffset); 
    120120                    destAddress = cast(uint)destSymbol.address + destSymbolOffset; 
    121121                } 
    …… 
    126126             
    127127            if(!containsAddress(cast(void*)destAddress)){ 
    128                 debug debugLog("Module does not contain the destination address for fixup. [%0.8X]",destAddress); 
    129                 debug debugLog("dump: %s",this.toString()); 
     128                debug debugLog("Module does not contain the destination address for fixup. [{0:8X}]",destAddress); 
     129                debug debugLog("dump: {0}",this.toString()); 
    130130                assert(false); 
    131131            } 
    …… 
    146146             
    147147            debug if(destSymbol){ 
    148                 debugLog("fixup dest %s:%s [%0.8X] (%0.8X) = fixupValue [%0.8X] rel:%d",destSymbol.name,destSymbol.getTypeName(),destAddress,*cast(uint*)destAddress,fixupValue,cast(uint)isSegmentRelative); 
     148                debugLog("fixup dest {0}:{1} [{2:8X}] ({3:8X}) = fixupValue [{4:8X}] rel:{5}",destSymbol.name,destSymbol.getTypeName(),destAddress,*cast(uint*)destAddress,fixupValue,cast(uint)isSegmentRelative); 
    149149            } 
    150150            else{ 
    151                 debugLog("fixup dest (null) [%0.8X] (%0.8X) = fixupValue [%0.8X] rel:%d",destAddress,*cast(uint*)destAddress,fixupValue,cast(uint)isSegmentRelative); 
     151                debugLog("fixup dest (null) [{0:8X}] ({1:8X}) = fixupValue [{2:8X}] rel:{3}",destAddress,*cast(uint*)destAddress,fixupValue,cast(uint)isSegmentRelative); 
    152152            } 
    153153             
    …… 
    166166            } 
    167167             
    168             debug debugLog("\tfixed to: [%0.8X]",*cast(uint*)destAddress); 
     168            debug debugLog("\tfixed to: [{0:8X}]",*cast(uint*)destAddress); 
    169169        } 
    170170        this.fixups = remainingFixups; 
    …… 
    363363                // Thankfully, these symbols exist at runtime, so naming them as Extern here won't  
    364364                // affect runtime linking. 
    365                 debug debugLog("Cannot resolve segment address for public '%s'.",cast(char[])pub.name); 
     365                debug debugLog("Cannot resolve segment address for public '{0}'.",cast(char[])pub.name); 
    366366                sym.isExternal = true; 
    367367                sym.type = SymbolType.Unresolved; // doesn't exist here 
    …… 
    471471                if(idx == 0) continue; 
    472472                char[] name = binary.names[binary.segments[idx].nameIndex]; 
    473                 result ~= sprint("  %d: %s %d bytes [%0.8X]\n",idx,name,seg.data.length,seg.data.ptr); 
     473                result ~= sprint("  {0}: {1} {2} bytes [{3:8X}]\n",idx,name,seg.data.length,seg.data.ptr); 
    474474            } 
    475475        } 
    …… 
    478478        foreach(idx,sym; symbols){ 
    479479            char[] ext = sym.isExternal ? "external" : "local"; 
    480             result ~= sprint("  %d: [%0.8X] %s %s %s\n",idx,cast(uint)sym.address,sym.getTypeName(),ext,sym.name); 
    481         } 
    482          
    483         result ~= sprint("Fixups (%d):\n",fixups.length); 
     480            result ~= sprint("  {0}: [{1:8X}] {2} {3} {4}\n",idx,cast(uint)sym.address,sym.getTypeName(),ext,sym.name); 
     481        } 
     482         
     483        result ~= sprint("Fixups ({0}):\n",fixups.length); 
    484484        if(fixups.length > 0){ 
    485485            foreach(idx,fix; fixups){ 
    …… 
    488488                    char[] ext = isExternStyleFixup ? "externStyle" : "segmentStyle"; 
    489489                             
    490                     result ~= sprint("  %d: %s %s",idx,rel,ext); 
     490                    result ~= sprint("  {0}: {1} {2}",idx,rel,ext); 
    491491 
    492492                    if(destSymbol){ 
    493                         result ~= sprint(" | %s [%0.8X]",destSymbol.name,cast(uint)destSymbol.address+destSymbolOffset); 
     493                        result ~= sprint(" | {0} [{1:8X}]",destSymbol.name,cast(uint)destSymbol.address+destSymbolOffset); 
    494494                    } 
    495495                    else{ 
    496                         result ~= sprint(" | [%0.8X]",cast(uint)destSegmentAddress); 
     496                        result ~= sprint(" | [{0:8X}]",cast(uint)destSegmentAddress); 
    497497                    }                    
    498498                         
    499499                    if(isExternStyleFixup){ 
    500                         result ~= sprint(" | %s [%0.8X]",targetSymbol.name,targetSymbol.address); 
     500                        result ~= sprint(" | {0} [{1:8X}]",targetSymbol.name,targetSymbol.address); 
    501501                    } 
    502502                    else{ 
    503                         result ~= sprint(" | segment #%d [%0.8X]",targetSegmentIndex,segmentImages[targetSegmentIndex].data.ptr); 
     503                        result ~= sprint(" | segment #{0} [{1:8X}]",targetSegmentIndex,segmentImages[targetSegmentIndex].data.ptr); 
    504504                    } 
    505505                    result ~= "\n"; 
    …… 
    511511        foreach(idx,segdef; segmentImages){ 
    512512            char[] buf2 = ""; 
    513             result ~= sprint("segment %d data (%d bytes): ",idx,segdef.data.length); 
     513            result ~= sprint("segment {0} data ({1} bytes): ",idx,segdef.data.length); 
    514514            foreach(byteidx,b; cast(ubyte[])(segdef.data)){ 
    515515                if(byteidx % 16 == 0){ 
    516                      result ~= sprint(" |  %s\n  [%0.8X] ",buf2,segdef.data.ptr+byteidx); 
     516                     result ~= sprint(" |  {0}\n  [{1:8X}] ",buf2,segdef.data.ptr+byteidx); 
    517517                     buf2 = ""; 
    518518                } 
    519519                if(b < 16) result ~= "0"; //HACK: sprint doesn't left-pad correctly 
    520                 result ~= sprint("%0.2X ",b); 
     520                result ~= sprint("{0:2X} ",b); 
    521521                if(b >= 32 && b <= 126){ 
    522522                    buf2 ~= cast(char)b;