Changeset 116

Show
Ignore:
Timestamp:
08/15/05 22:04:49 (3 years ago)
Author:
pragma
Message:

updates to omfloader

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/ddl/RecordCursor.d

    r112 r116  
    4242    public ubyte[] getData(){ 
    4343        return data; 
     44    } 
     45     
     46    public ubyte[] getCurrentData(){ 
     47        return data[position..$]; 
    4448    } 
    4549     

  • trunk/ddl/omfloader.d

    r114 r116  
    148148    public char[] toString(){ 
    149149        uint end = data.length < 8 ? data.length : 8; 
    150         return std.string.format("%s %s %d bytes %s",publicBase.name,publicName,data.length,data[0..end]); 
     150        return std.string.format("%s %s %d",publicBase.name,publicName,data.length); 
    151151    } 
    152152     
    …… 
    173173    bit isSegmentRelative; 
    174174    uint offset; 
     175     
    175176 
    176177    public this(){ 
    …… 
    568569    protected void parseFixupData(RecordCursor cursor){ 
    569570        // reset frameThreads 
    570         return; 
    571571        while(cursor.hasMore()){ 
    572572            ushort type = cursor.getByte(); 
    573                 debug writefln(""); 
    574573            // fixup record 
    575574            //SPEC:   FIXUPP records are used to fix references in the immediately 
    576575            //  preceding LEDATA, LIDATA, or COMDAT record. 
    577576             
     577            // thread subrecord 
     578            if((type & 0b10000000) == 0){ 
     579                FixupThread* fixupThread; 
     580                uint threadNumber = type & 0b00000011; 
     581                 
     582                ubyte method = (type & 0b00011100) >> 2; 
     583                 
     584                // frame thread 
     585                if(type & 0b01000000){ 
     586                    fixupThread = &(this.fixupFrames[threadNumber]);                 
     587     
     588                    if(fixupThread.method < 4){  
     589                        fixupThread.index = cursor.getIndex(); 
     590                    } 
     591                    else{ 
     592                        fixupThread.index = 0; 
     593                    } 
     594                } 
     595                // target thread 
     596                else{  
     597                    fixupThread = &(this.fixupTargets[threadNumber]); 
     598                    fixupThread.index = cursor.getIndex(); 
     599                } 
     600                 
     601                fixupThread.method = method; 
     602            }            
    578603            // Fixup Subrecord 
    579             if(type & 0b10000000){ 
    580                 debug writefln("fixup data %d of %d ",cursor.getPosition(),cursor.getData().length); 
    581                 // parse out the Locat 
    582                 ushort offset = cursor.getByte(); 
    583                 ubyte locat = cursor.getByte(); 
    584                  
    585                 bit isSegmentRelativeFixup = (locat & 0b01000000) != 0; 
    586                 ubyte location = (locat & 0b00111100) >> 2; 
    587                 offset |= (locat & 0b00000011) << 8; // get the high-order bits from the 'locat' 
    588                  
    589                 debug writefln("segment relative: %s | location: %0.10b | offset: %d",isSegmentRelativeFixup,location,offset); 
    590                  
     604            else{                
     605                ubyte offset = cursor.getByte();  
     606     
     607                bit isSegmentRelativeFixup = (type & 0b01000000) != 0; 
     608                ubyte location = (type & 0b00111100) >> 2; 
     609                offset |= offset | (type & 0b00000011) << 8; // get the high-order bits from the 'locat' 
     610                                             
    591611                // get the 'fix data' byte 
    592612                ubyte fixData = cursor.getByte(); 
    …… 
    595615                ushort frameDatum; 
    596616                 
    597                 debug writefln("getting frame"); 
     617                ubyte frame = (fixData & 0b01110000) >> 4; 
    598618                 
    599619                // don't use the frame thread 
    600620                if((fixData & 0b10000000) == 0){ 
    601                     frameMethod = (fixData & 0b01110000) >> 4; // get method directly  
    602                     frameDatum = cursor.getIndex(); // get the index to use 
     621                    frameMethod = frame; 
     622                    if(frame < 3){ 
     623                        frameDatum = cursor.getIndex(); // get the index to use 
     624                    } 
     625                    else frameDatum = 0; 
    603626                } 
    604627                // use frame thread 
    605                 else{ 
    606                     uint frame = (fixData & 0b01110000) >> 4; // get the thread number 
     628                else{                
    607629                    frameMethod = this.fixupFrames[frame].method; // get the method 
    608630                    frameDatum = this.fixupFrames[frame].index; // get the datum 
    …… 
    612634                ushort targetDatum; 
    613635                 
    614                 debug writefln("getting target"); 
    615                  
     636                uint target = (fixData & 0b00000011); 
     637                                
    616638                // don't use the target thread 
    617639                if((fixData & 0b00001000) == 0){ 
    618                     debug writefln("fixup target %d of %d ",cursor.getPosition(),cursor.getData().length); 
    619                     targetMethod = (fixData & 0b00000111); 
    620                     targetDatum = cursor.getIndex(); 
     640                    targetMethod = target; 
     641                    //if((target | (fixData & 0b00000100)) < 3){ 
     642                        targetDatum = cursor.getIndex(); 
     643                    //} 
    621644                } 
    622645                // use target thread 
    623646                else{ 
    624                     uint frame = (fixData & 0b00000011); 
    625                     targetMethod = this.fixupTargets[frame].method | (fixData & 0b00000100); 
    626                     targetDatum = this.fixupTargets[frame].index;  
    627                 } 
    628                  
    629                 debug writefln("getting displacement"); 
     647                    targetMethod = this.fixupTargets[target].method | (fixData & 0b00000100); 
     648                    targetDatum = this.fixupTargets[target].index;  
     649                } 
    630650                 
    631651                uint targetDisplacement = 0; 
    632652                if((fixData & 0b00000100) == 0){ 
    633                     debug writefln("fixup displacement %d of %d ",cursor.getPosition(),cursor.getData().length); 
    634653                    targetDisplacement = cursor.getVWord(); 
    635654                } 
    636655                 
    637                 debug writefln("fixup %0.8b remaining: %s",cursor.getData()[cursor.getPosition()],cursor.getData()[cursor.getPosition()..$]); 
    638                 //TODO: do something! 
    639                  
    640             } 
    641             // thread subrecord 
    642             else{ 
    643                 FixupThread* fixupThread; 
    644                 uint threadNumber = type & 0b00000011; 
    645                              
    646                 // frame thread 
    647                 if(type & 0b01000000){ 
    648                     debug writefln("fixup thread"); 
    649                     fixupThread = &(this.fixupFrames[threadNumber]);                 
    650                 } 
    651                 // target thread 
    652                 else{  
    653                     debug writefln("fixup frame"); 
    654                     fixupThread = &(this.fixupTargets[threadNumber]); 
    655                 } 
    656                              
    657                 fixupThread.method = (type & 0b00011100) >> 2; 
    658                  
    659                 debug writefln("thread before index (%0.8b) assigning thread #%d method: %d",type,threadNumber,fixupThread.method);                          
    660                  
    661                 if(fixupThread.method < 3){ 
    662                     fixupThread.index = cursor.getIndex(); 
    663                 } 
    664                  
    665                 debug writefln("thread after (%0.8b) remaining: %s",cursor.getData()[cursor.getPosition()],cursor.getData()[cursor.getPosition()..$]); 
     656                debug{ 
     657                    EnumDataRecord enumData = this.enumData[$-1]; 
     658                     
     659                    uint address = enumData.offset + offset; 
     660                     
     661                    writef("fixup - %s : %0.2X | offset: %0.4X | segrel: %s",enumData.base.name,enumData.offset,address,isSegmentRelativeFixup); 
     662                     
     663                    writef(" | frame: "); 
     664                    switch(frameMethod){ 
     665                    case 0: writef("segment %s",this.segments[frameDatum].name); break; 
     666                    case 1: writef("group %s",this.groups[frameDatum].name); break; 
     667                    case 2: writef("extern %s",this.externs[frameDatum].name); break; 
     668                    case 4: writef("segment %s",this.segments[$-1].name); break; 
     669                    case 5: writef("[target]"); break; 
     670                    case 3:  
     671                    default: 
     672                        writef("<invalid>"); 
     673                    } 
     674                     
     675                    writef(" | target: "); 
     676                    switch(targetMethod){ 
     677                     
     678                    case 0: writef("(displacment: %d) ",targetDisplacement); 
     679                    case 4: writef("segment %s",this.segments[targetDatum].name); break; 
     680                     
     681                    case 1: writef("(displacment: %d) ",targetDisplacement); 
     682                    case 5: writef("group %s",this.groups[targetDatum].name); break; 
     683                     
     684                    case 2: writef("(displacment: %d) ",targetDisplacement); 
     685                    case 6: writef("extern %s",this.externs[frameDatum].name); break; 
     686                     
     687                    default: 
     688                        writef("<invalid>"); 
     689                    } 
     690                     
     691                    writefln(""); 
     692                } 
    666693            } 
    667694        }