| error=abort | |
| // NOTE: THIS MAY NEED TO BE ADJUSTED | |
| // change to reflect the total amount of ram in your system | |
| define /r GetMaxMem() | |
| { | |
| return 0x10000000; // 256 MB | |
| } | |
| . | |
| define /r GetWord(Addr) | |
| { | |
| unsigned long data; | |
| if( (Addr & 0x2) == 0 ) | |
| { | |
| data = dword(Addr); | |
| data = data & 0xffff; | |
| //$printf "getword data is %x\n", data$; | |
| return data; | |
| } | |
| else | |
| { | |
| data = dword(Addr & 0xfffffffc); | |
| //data = data >> 16; | |
| data = data / 0x10000; | |
| //$printf "getword data is %x (1)\n", data$; | |
| return data; | |
| } | |
| } | |
| . | |
| define /r ProcessPE32(imgstart) | |
| unsigned long imgstart; | |
| { | |
| unsigned long filehdrstart; | |
| unsigned long debugdirentryrva; | |
| unsigned long debugtype; | |
| unsigned long debugrva; | |
| unsigned long dwarfsig; | |
| unsigned long baseofcode; | |
| unsigned long baseofdata; | |
| unsigned long elfbase; | |
| char *elfpath; | |
| $printf "PE32 image found at %x",imgstart$; | |
| //$printf "PE file hdr offset %x",dword(imgstart+0x3C)$; | |
| // offset from dos hdr to PE file hdr | |
| filehdrstart = imgstart + dword(imgstart+0x3C); | |
| // offset to debug dir in PE hdrs | |
| //$printf "debug dir is at %x",(filehdrstart+0xA8)$; | |
| debugdirentryrva = dword(filehdrstart + 0xA8); | |
| if(debugdirentryrva == 0) | |
| { | |
| $printf "no debug dir for image at %x",imgstart$; | |
| return; | |
| } | |
| //$printf "debug dir entry rva is %x",debugdirentryrva$; | |
| debugtype = dword(imgstart + debugdirentryrva + 0xc); | |
| if( (debugtype != 0xdf) && (debugtype != 0x2) ) | |
| { | |
| $printf "debug type is not dwarf for image at %x",imgstart$; | |
| $printf "debug type is %x",debugtype$; | |
| return; | |
| } | |
| debugrva = dword(imgstart + debugdirentryrva + 0x14); | |
| dwarfsig = dword(imgstart + debugrva); | |
| if(dwarfsig != 0x66727764) | |
| { | |
| $printf "dwarf debug signature not found for image at %x",imgstart$; | |
| return; | |
| } | |
| elfpath = (char *)(imgstart + debugrva + 0xc); | |
| baseofcode = imgstart + dword(filehdrstart + 0x28); | |
| baseofdata = imgstart + dword(filehdrstart + 0x2c); | |
| if( (baseofcode < baseofdata) && (baseofcode != 0) ) | |
| { | |
| elfbase = baseofcode; | |
| } | |
| else | |
| { | |
| elfbase = baseofdata; | |
| } | |
| $printf "found path %s",elfpath$; | |
| $fprintf 50, "load /ni /np /a %s &0x%x\n",elfpath,elfbase$; | |
| } | |
| . | |
| define /r ProcessTE(imgstart) | |
| unsigned long imgstart; | |
| { | |
| unsigned long strippedsize; | |
| unsigned long debugdirentryrva; | |
| unsigned long debugtype; | |
| unsigned long debugrva; | |
| unsigned long dwarfsig; | |
| unsigned long elfbase; | |
| char *elfpath; | |
| $printf "TE image found at %x",imgstart$; | |
| // determine pe header bytes removed to account for in rva references | |
| //strippedsize = word(imgstart + 0x6); | |
| //strippedsize = (dword(imgstart + 0x4) & 0xffff0000) >> 16; | |
| strippedsize = (dword(imgstart + 0x4) & 0xffff0000) / 0x10000; | |
| strippedsize = strippedsize - 0x28; | |
| debugdirentryrva = dword(imgstart + 0x20); | |
| if(debugdirentryrva == 0) | |
| { | |
| $printf "no debug dir for image at %x",imgstart$; | |
| return; | |
| } | |
| debugdirentryrva = debugdirentryrva - strippedsize; | |
| //$printf "debug dir entry rva is %x",debugdirentryrva$; | |
| debugtype = dword(imgstart + debugdirentryrva + 0xc); | |
| if( (debugtype != 0xdf) && (debugtype != 0x2) ) | |
| { | |
| $printf "debug type is not dwarf for image at %x",imgstart$; | |
| $printf "debug type is %x",debugtype$; | |
| return; | |
| } | |
| debugrva = dword(imgstart + debugdirentryrva + 0x14); | |
| debugrva = debugrva - strippedsize; | |
| dwarfsig = dword(imgstart + debugrva); | |
| if( (dwarfsig != 0x66727764) && (dwarfsig != 0x3031424e) ) | |
| { | |
| $printf "dwarf debug signature not found for image at %x",imgstart$; | |
| $printf "found %x", dwarfsig$; | |
| return; | |
| } | |
| if( dwarfsig == 0x66727764 ) | |
| { | |
| elfpath = (char *)(imgstart + debugrva + 0xc); | |
| $printf "looking for elf path at 0x%x", elfpath$; | |
| } | |
| else | |
| { | |
| elfpath = (char *)(imgstart + debugrva + 0x10); | |
| $printf "looking for elf path at 0x%x", elfpath$; | |
| } | |
| // elf base is baseofcode (we hope that for TE images it's not baseofdata) | |
| elfbase = imgstart + dword(imgstart + 0xc) - strippedsize; | |
| $printf "found path %s",elfpath$; | |
| $fprintf 50, "load /ni /np /a %s &0x%x\n",elfpath,elfbase$; | |
| } | |
| . | |
| define /r ProcessFvSection(secstart) | |
| unsigned long secstart; | |
| { | |
| unsigned long sectionsize; | |
| unsigned char sectiontype; | |
| sectionsize = dword(secstart); | |
| //sectiontype = (sectionsize & 0xff000000) >> 24; | |
| sectiontype = (sectionsize & 0xff000000) / 0x1000000; | |
| sectionsize = sectionsize & 0x00ffffff; | |
| $printf "fv section at %x size %x type %x",secstart,sectionsize,sectiontype$; | |
| if(sectiontype == 0x10) // PE32 | |
| { | |
| ProcessPE32(secstart+0x4); | |
| } | |
| else if(sectiontype == 0x12) // TE | |
| { | |
| ProcessTE(secstart+0x4); | |
| } | |
| } | |
| . | |
| define /r ProcessFfsFile(ffsfilestart) | |
| unsigned long ffsfilestart; | |
| { | |
| unsigned long ffsfilesize; | |
| unsigned long ffsfiletype; | |
| unsigned long secoffset; | |
| unsigned long secsize; | |
| //ffsfiletype = byte(ffsfilestart + 0x12); | |
| ffsfilesize = dword(ffsfilestart + 0x14); | |
| //ffsfiletype = (ffsfilesize & 0xff000000) >> 24; | |
| ffsfiletype = (ffsfilesize & 0xff000000) / 0x1000000; | |
| ffsfilesize = ffsfilesize & 0x00ffffff; | |
| if(ffsfiletype == 0xff) return; | |
| $printf "ffs file at %x size %x type %x",ffsfilestart,ffsfilesize,ffsfiletype$; | |
| secoffset = ffsfilestart + 0x18; | |
| // loop through sections in file | |
| while(secoffset < (ffsfilestart + ffsfilesize)) | |
| { | |
| // process fv section and increment section offset by size | |
| secsize = dword(secoffset) & 0x00ffffff; | |
| ProcessFvSection(secoffset); | |
| secoffset = secoffset + secsize; | |
| // align to next 4 byte boundary | |
| if( (secoffset & 0x3) != 0 ) | |
| { | |
| secoffset = secoffset + (0x4 - (secoffset & 0x3)); | |
| } | |
| } // end section loop | |
| } | |
| . | |
| define /r LoadPeiSec() | |
| { | |
| unsigned long fvbase; | |
| unsigned long fvlen; | |
| unsigned long fvsig; | |
| unsigned long ffsoffset; | |
| unsigned long ffsfilesize; | |
| fvbase = FindFv(); | |
| $printf "fvbase %x",fvbase$; | |
| // get fv signature field | |
| fvsig = dword(fvbase + 0x28); | |
| if(fvsig != 0x4856465F) | |
| { | |
| $printf "FV does not have proper signature, exiting"$; | |
| return 0; | |
| } | |
| $printf "FV signature found"$; | |
| $fopen 50, 'C:\loadfiles.inc'$; | |
| fvlen = dword(fvbase + 0x20); | |
| // first ffs file is after fv header, use headerlength field | |
| //ffsoffset = (dword(fvbase + 0x30) & 0xffff0000) >> 16; | |
| ffsoffset = (dword(fvbase + 0x30) & 0xffff0000) / 0x10000; | |
| ffsoffset = fvbase + GetWord(fvbase + 0x30); | |
| // loop through ffs files | |
| while(ffsoffset < (fvbase+fvlen)) | |
| { | |
| // process ffs file and increment by ffs file size field | |
| ProcessFfsFile(ffsoffset); | |
| ffsfilesize = (dword(ffsoffset + 0x14) & 0x00ffffff); | |
| if(ffsfilesize == 0) | |
| { | |
| break; | |
| } | |
| ffsoffset = ffsoffset + ffsfilesize; | |
| // align to next 8 byte boundary | |
| if( (ffsoffset & 0x7) != 0 ) | |
| { | |
| ffsoffset = ffsoffset + (0x8 - (ffsoffset & 0x7)); | |
| } | |
| } // end fv ffs loop | |
| $vclose 50$; | |
| } | |
| . | |
| define /r FindSystemTable(TopOfRam) | |
| unsigned long TopOfRam; | |
| { | |
| unsigned long offset; | |
| $printf "FindSystemTable"$; | |
| $printf "top of mem is %x",TopOfRam$; | |
| offset = TopOfRam; | |
| // align to highest 4MB boundary | |
| offset = offset & 0xFFC00000; | |
| // start at top and look on 4MB boundaries for system table ptr structure | |
| while(offset > 0) | |
| { | |
| //$printf "checking %x",offset$; | |
| //$printf "value is %x",dword(offset)$; | |
| // low signature match | |
| if(dword(offset) == 0x20494249) | |
| { | |
| // high signature match | |
| if(dword(offset+4) == 0x54535953) | |
| { | |
| // less than 4GB? | |
| if(dword(offset+0x0c) == 0) | |
| { | |
| // less than top of ram? | |
| if(dword(offset+8) < TopOfRam) | |
| { | |
| return(dword(offset+8)); | |
| } | |
| } | |
| } | |
| } | |
| if(offset < 0x400000) break; | |
| offset = offset - 0x400000; | |
| } | |
| return 0; | |
| } | |
| . | |
| define /r ProcessImage(ImageBase) | |
| unsigned long ImageBase; | |
| { | |
| $printf "ProcessImage %x", ImageBase$; | |
| } | |
| . | |
| define /r FindDebugInfo(SystemTable) | |
| unsigned long SystemTable; | |
| { | |
| unsigned long CfgTableEntries; | |
| unsigned long ConfigTable; | |
| unsigned long i; | |
| unsigned long offset; | |
| unsigned long dbghdr; | |
| unsigned long dbgentries; | |
| unsigned long dbgptr; | |
| unsigned long dbginfo; | |
| unsigned long loadedimg; | |
| $printf "FindDebugInfo"$; | |
| dbgentries = 0; | |
| CfgTableEntries = dword(SystemTable + 0x40); | |
| ConfigTable = dword(SystemTable + 0x44); | |
| $printf "config table is at %x (%d entries)", ConfigTable, CfgTableEntries$; | |
| // now search for debug info entry with guid 49152E77-1ADA-4764-B7A2-7AFEFED95E8B | |
| // 0x49152E77 0x47641ADA 0xFE7AA2B7 0x8B5ED9FE | |
| for(i=0; i<CfgTableEntries; i++) | |
| { | |
| offset = ConfigTable + (i*0x14); | |
| if(dword(offset) == 0x49152E77) | |
| { | |
| if(dword(offset+4) == 0x47641ADA) | |
| { | |
| if(dword(offset+8) == 0xFE7AA2B7) | |
| { | |
| if(dword(offset+0xc) == 0x8B5ED9FE) | |
| { | |
| dbghdr = dword(offset+0x10); | |
| dbgentries = dword(dbghdr + 4); | |
| dbgptr = dword(dbghdr + 8); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if(dbgentries == 0) | |
| { | |
| $printf "no debug entries found"$; | |
| return; | |
| } | |
| $printf "debug table at %x (%d entries)", dbgptr, dbgentries$; | |
| for(i=0; i<dbgentries; i++) | |
| { | |
| dbginfo = dword(dbgptr + (i*4)); | |
| if(dbginfo != 0) | |
| { | |
| if(dword(dbginfo) == 1) // normal debug info type | |
| { | |
| loadedimg = dword(dbginfo + 4); | |
| ProcessPE32(dword(loadedimg + 0x20)); | |
| } | |
| } | |
| } | |
| } | |
| . | |
| define /r LoadDxe() | |
| { | |
| unsigned long maxmem; | |
| unsigned long systbl; | |
| $printf "LoadDxe"$; | |
| $fopen 50, 'C:\loadfiles.inc'$; | |
| maxmem = GetMaxMem(); | |
| systbl = FindSystemTable(maxmem); | |
| if(systbl != 0) | |
| { | |
| $printf "found system table at %x",systbl$; | |
| FindDebugInfo(systbl); | |
| } | |
| $vclose 50$; | |
| } | |
| . | |
| define /r LoadRuntimeDxe() | |
| { | |
| unsigned long maxmem; | |
| unsigned long SystemTable; | |
| unsigned long CfgTableEntries; | |
| unsigned long ConfigTable; | |
| unsigned long i; | |
| unsigned long offset; | |
| unsigned long numentries; | |
| unsigned long RuntimeDebugInfo; | |
| unsigned long DebugInfoOffset; | |
| unsigned long imgbase; | |
| $printf "LoadRuntimeDxe"$; | |
| $fopen 50, 'C:\loadfiles.inc'$; | |
| RuntimeDebugInfo = 0x80000010; | |
| if(RuntimeDebugInfo != 0) | |
| { | |
| numentries = dword(RuntimeDebugInfo); | |
| $printf "runtime debug info is at %x (%d entries)", RuntimeDebugInfo, numentries$; | |
| DebugInfoOffset = RuntimeDebugInfo + 0x4; | |
| for(i=0; i<numentries; i++) | |
| { | |
| imgbase = dword(DebugInfoOffset); | |
| if(imgbase != 0) | |
| { | |
| $printf "found image at %x",imgbase$; | |
| ProcessPE32(imgbase); | |
| } | |
| DebugInfoOffset = DebugInfoOffset + 0x4; | |
| } | |
| } | |
| $vclose 50$; | |
| } | |
| . |