ArmPlatformPkg/ArmRealViewEbPkg/Debugger_scripts/EfiFuncs.inc

   1 error=abort
   2
   3 // NOTE: THIS MAY NEED TO BE ADJUSTED
   4 // change to reflect the total amount of ram in your system
   5 define /r GetMaxMem()
   6 {
   7   return 0x10000000; // 256 MB
   8 }
   9 .
  10
  11 define /r GetWord(Addr)
  12 {
  13   unsigned long data;
  14
  15   if( (Addr & 0x2) == 0 )
  16   {
  17     data = dword(Addr);
  18     data = data & 0xffff;
  19     //$printf "getword data is %x\n", data$;
  20     return data;
  21   }
  22   else
  23   {
  24     data = dword(Addr & 0xfffffffc);
  25     //data = data >> 16;
  26     data = data / 0x10000;
  27     //$printf "getword data is %x (1)\n", data$;
  28     return data;
  29   }
  30 }
  31 .
  32
  33 define /r ProcessPE32(imgstart)
  34 unsigned long imgstart;
  35 {
  36   unsigned long filehdrstart;
  37   unsigned long debugdirentryrva;
  38         unsigned long debugtype;
  39   unsigned long debugrva;
  40         unsigned long dwarfsig;
  41   unsigned long baseofcode;
  42   unsigned long baseofdata;
  43   unsigned long elfbase;
  44   char *elfpath;
  45
  46         $printf "PE32 image found at %x",imgstart$;
  47
  48         //$printf "PE file hdr offset %x",dword(imgstart+0x3C)$;
  49
  50   // offset from dos hdr to PE file hdr
  51   filehdrstart = imgstart + dword(imgstart+0x3C);
  52
  53   // offset to debug dir in PE hdrs
  54         //$printf "debug dir is at %x",(filehdrstart+0xA8)$;
  55         debugdirentryrva = dword(filehdrstart + 0xA8);
  56   if(debugdirentryrva == 0)
  57         {
  58                 $printf "no debug dir for image at %x",imgstart$;
  59           return;
  60         }
  61
  62         //$printf "debug dir entry rva is %x",debugdirentryrva$;
  63
  64         debugtype = dword(imgstart + debugdirentryrva + 0xc);
  65   if( (debugtype != 0xdf) && (debugtype != 0x2) )
  66         {
  67                 $printf "debug type is not dwarf for image at %x",imgstart$;
  68                 $printf "debug type is %x",debugtype$;
  69                 return;
  70         }
  71
  72         debugrva = dword(imgstart + debugdirentryrva + 0x14);
  73         dwarfsig = dword(imgstart + debugrva);
  74         if(dwarfsig != 0x66727764)
  75         {
  76                 $printf "dwarf debug signature not found for image at %x",imgstart$;
  77           return;
  78         }
  79
  80   elfpath = (char *)(imgstart + debugrva + 0xc);
  81
  82   baseofcode = imgstart + dword(filehdrstart + 0x28);
  83   baseofdata = imgstart + dword(filehdrstart + 0x2c);
  84
  85   if( (baseofcode < baseofdata) && (baseofcode != 0) )
  86   {
  87                 elfbase = baseofcode;
  88   }
  89   else
  90   {
  91     elfbase = baseofdata;
  92   }
  93
  94         $printf "found path %s",elfpath$;
  95         $fprintf 50, "load /ni /np /a %s &0x%x\n",elfpath,elfbase$;
  96 }
  97 .
  98
  99 define /r ProcessTE(imgstart)
 100 unsigned long imgstart;
 101 {
 102   unsigned long strippedsize;
 103         unsigned long debugdirentryrva;
 104         unsigned long debugtype;
 105   unsigned long debugrva;
 106         unsigned long dwarfsig;
 107   unsigned long elfbase;
 108   char *elfpath;
 109
 110         $printf "TE image found at %x",imgstart$;
 111
 112   // determine pe header bytes removed to account for in rva references
 113   //strippedsize = word(imgstart + 0x6);
 114   //strippedsize = (dword(imgstart + 0x4) & 0xffff0000) >> 16;
 115   strippedsize = (dword(imgstart + 0x4) & 0xffff0000) / 0x10000;
 116   strippedsize = strippedsize - 0x28;
 117
 118         debugdirentryrva = dword(imgstart + 0x20);
 119   if(debugdirentryrva == 0)
 120         {
 121                 $printf "no debug dir for image at %x",imgstart$;
 122           return;
 123         }
 124   debugdirentryrva = debugdirentryrva - strippedsize;
 125
 126         //$printf "debug dir entry rva is %x",debugdirentryrva$;
 127
 128         debugtype = dword(imgstart + debugdirentryrva + 0xc);
 129   if( (debugtype != 0xdf) && (debugtype != 0x2) )
 130         {
 131                 $printf "debug type is not dwarf for image at %x",imgstart$;
 132                 $printf "debug type is %x",debugtype$;
 133                 return;
 134         }
 135
 136         debugrva = dword(imgstart + debugdirentryrva + 0x14);
 137   debugrva = debugrva - strippedsize;
 138         dwarfsig = dword(imgstart + debugrva);
 139         if( (dwarfsig != 0x66727764) && (dwarfsig != 0x3031424e) )
 140         {
 141                 $printf "dwarf debug signature not found for image at %x",imgstart$;
 142                 $printf "found %x", dwarfsig$;
 143           return;
 144         }
 145
 146         if( dwarfsig == 0x66727764 )
 147         {
 148                 elfpath = (char *)(imgstart + debugrva + 0xc);
 149     $printf "looking for elf path at 0x%x", elfpath$;
 150   }
 151   else
 152   {
 153     elfpath = (char *)(imgstart + debugrva + 0x10);
 154     $printf "looking for elf path at 0x%x", elfpath$;
 155   }
 156
 157   // elf base is baseofcode (we hope that for TE images it's not baseofdata)
 158   elfbase = imgstart + dword(imgstart + 0xc) - strippedsize;
 159
 160         $printf "found path %s",elfpath$;
 161         $fprintf 50, "load /ni /np /a %s &0x%x\n",elfpath,elfbase$;
 162 }
 163 .
 164
 165 define /r ProcessFvSection(secstart)
 166 unsigned long secstart;
 167 {
 168   unsigned long sectionsize;
 169   unsigned char sectiontype;
 170
 171         sectionsize = dword(secstart);
 172   //sectiontype = (sectionsize & 0xff000000) >> 24;
 173   sectiontype = (sectionsize & 0xff000000) / 0x1000000;
 174   sectionsize = sectionsize & 0x00ffffff;
 175
 176         $printf "fv section at %x size %x type %x",secstart,sectionsize,sectiontype$;
 177
 178         if(sectiontype == 0x10) // PE32
 179   {
 180                 ProcessPE32(secstart+0x4);
 181         }
 182         else if(sectiontype == 0x12) // TE
 183         {
 184                 ProcessTE(secstart+0x4);
 185         }
 186 }
 187 .
 188
 189 define /r ProcessFfsFile(ffsfilestart)
 190 unsigned long ffsfilestart;
 191 {
 192   unsigned long ffsfilesize;
 193   unsigned long ffsfiletype;
 194   unsigned long secoffset;
 195   unsigned long secsize;
 196
 197   //ffsfiletype = byte(ffsfilestart + 0x12);
 198   ffsfilesize = dword(ffsfilestart + 0x14);
 199   //ffsfiletype = (ffsfilesize & 0xff000000) >> 24;
 200   ffsfiletype = (ffsfilesize & 0xff000000) / 0x1000000;
 201   ffsfilesize = ffsfilesize & 0x00ffffff;
 202
 203   if(ffsfiletype == 0xff) return;
 204
 205         $printf "ffs file at %x size %x type %x",ffsfilestart,ffsfilesize,ffsfiletype$;
 206
 207   secoffset = ffsfilestart + 0x18;
 208
 209   // loop through sections in file
 210   while(secoffset < (ffsfilestart + ffsfilesize))
 211         {
 212                 // process fv section and increment section offset by size
 213     secsize = dword(secoffset) & 0x00ffffff;
 214     ProcessFvSection(secoffset);
 215                 secoffset = secoffset + secsize;
 216
 217           // align to next 4 byte boundary
 218     if( (secoffset & 0x3) != 0 )
 219                 {
 220                         secoffset = secoffset + (0x4 - (secoffset & 0x3));
 221                 }
 222         } // end section loop
 223 }
 224 .
 225
 226 define /r LoadPeiSec()
 227 {
 228   unsigned long fvbase;
 229   unsigned long fvlen;
 230   unsigned long fvsig;
 231         unsigned long ffsoffset;
 232   unsigned long ffsfilesize;
 233
 234   fvbase = FindFv();
 235         $printf "fvbase %x",fvbase$;
 236
 237   // get fv signature field
 238   fvsig = dword(fvbase + 0x28);
 239   if(fvsig != 0x4856465F)
 240   {
 241                 $printf "FV does not have proper signature, exiting"$;
 242     return 0;
 243   }
 244
 245         $printf "FV signature found"$;
 246
 247   $fopen 50, 'C:\loadfiles.inc'$;
 248
 249   fvlen = dword(fvbase + 0x20);
 250
 251   // first ffs file is after fv header, use headerlength field
 252   //ffsoffset = (dword(fvbase + 0x30) & 0xffff0000) >> 16;
 253   ffsoffset = (dword(fvbase + 0x30) & 0xffff0000) / 0x10000;
 254   ffsoffset = fvbase + GetWord(fvbase + 0x30);
 255
 256   // loop through ffs files
 257   while(ffsoffset < (fvbase+fvlen))
 258         {
 259                 // process ffs file and increment by ffs file size field
 260                 ProcessFfsFile(ffsoffset);
 261                 ffsfilesize = (dword(ffsoffset + 0x14) & 0x00ffffff);
 262                 if(ffsfilesize == 0)
 263                 {
 264                   break;
 265                 }
 266                 ffsoffset = ffsoffset + ffsfilesize;
 267
 268
 269                 // align to next 8 byte boundary
 270     if( (ffsoffset & 0x7) != 0 )
 271                 {
 272                         ffsoffset = ffsoffset + (0x8 - (ffsoffset & 0x7));
 273                 }
 274
 275   } // end fv ffs loop
 276
 277         $vclose 50$;
 278
 279 }
 280 .
 281
 282 define /r FindSystemTable(TopOfRam)
 283 unsigned long TopOfRam;
 284 {
 285   unsigned long offset;
 286
 287   $printf "FindSystemTable"$;
 288   $printf "top of mem is %x",TopOfRam$;
 289
 290   offset = TopOfRam;
 291
 292   // align to highest 4MB boundary
 293   offset = offset & 0xFFC00000;
 294
 295   // start at top and look on 4MB boundaries for system table ptr structure
 296   while(offset > 0)
 297   {
 298     //$printf "checking %x",offset$;
 299     //$printf "value is %x",dword(offset)$;
 300
 301     // low signature match
 302     if(dword(offset) == 0x20494249)
 303     {
 304       // high signature match
 305       if(dword(offset+4) == 0x54535953)
 306       {
 307         // less than 4GB?
 308         if(dword(offset+0x0c) == 0)
 309         {
 310           // less than top of ram?
 311           if(dword(offset+8) < TopOfRam)
 312           {
 313             return(dword(offset+8));
 314           }
 315         }
 316       }
 317
 318     }
 319
 320     if(offset < 0x400000) break;
 321     offset = offset - 0x400000;
 322   }
 323
 324   return 0;
 325 }
 326 .
 327
 328 define /r ProcessImage(ImageBase)
 329 unsigned long ImageBase;
 330 {
 331   $printf "ProcessImage %x", ImageBase$;
 332 }
 333 .
 334
 335 define /r FindDebugInfo(SystemTable)
 336 unsigned long SystemTable;
 337 {
 338   unsigned long   CfgTableEntries;
 339   unsigned long   ConfigTable;
 340   unsigned long   i;
 341   unsigned long   offset;
 342   unsigned long   dbghdr;
 343   unsigned long   dbgentries;
 344   unsigned long   dbgptr;
 345   unsigned long   dbginfo;
 346   unsigned long   loadedimg;
 347
 348   $printf "FindDebugInfo"$;
 349
 350   dbgentries = 0;
 351   CfgTableEntries = dword(SystemTable + 0x40);
 352   ConfigTable = dword(SystemTable + 0x44);
 353
 354   $printf "config table is at %x (%d entries)", ConfigTable, CfgTableEntries$;
 355
 356   // now search for debug info entry with guid 49152E77-1ADA-4764-B7A2-7AFEFED95E8B
 357   //    0x49152E77      0x47641ADA      0xFE7AA2B7      0x8B5ED9FE
 358   for(i=0; i<CfgTableEntries; i++)
 359   {
 360     offset = ConfigTable + (i*0x14);
 361     if(dword(offset) == 0x49152E77)
 362     {
 363       if(dword(offset+4) == 0x47641ADA)
 364       {
 365         if(dword(offset+8) == 0xFE7AA2B7)
 366         {
 367           if(dword(offset+0xc) == 0x8B5ED9FE)
 368           {
 369             dbghdr = dword(offset+0x10);
 370             dbgentries = dword(dbghdr + 4);
 371             dbgptr = dword(dbghdr + 8);
 372           }
 373         }
 374       }
 375     }
 376   }
 377
 378   if(dbgentries == 0)
 379   {
 380     $printf "no debug entries found"$;
 381     return;
 382   }
 383
 384   $printf "debug table at %x (%d entries)", dbgptr, dbgentries$;
 385
 386   for(i=0; i<dbgentries; i++)
 387   {
 388     dbginfo = dword(dbgptr + (i*4));
 389     if(dbginfo != 0)
 390     {
 391       if(dword(dbginfo) == 1) // normal debug info type
 392       {
 393         loadedimg = dword(dbginfo + 4);
 394         ProcessPE32(dword(loadedimg + 0x20));
 395       }
 396     }
 397   }
 398 }
 399 .
 400
 401 define /r LoadDxe()
 402 {
 403   unsigned long     maxmem;
 404   unsigned long     systbl;
 405
 406   $printf "LoadDxe"$;
 407
 408   $fopen 50, 'C:\loadfiles.inc'$;
 409
 410   maxmem = GetMaxMem();
 411   systbl = FindSystemTable(maxmem);
 412   if(systbl != 0)
 413   {
 414     $printf "found system table at %x",systbl$;
 415     FindDebugInfo(systbl);
 416   }
 417
 418   $vclose 50$;
 419 }
 420 .
 421
 422 define /r LoadRuntimeDxe()
 423
 424 {
 425   unsigned long   maxmem;
 426   unsigned long   SystemTable;
 427   unsigned long   CfgTableEntries;
 428   unsigned long   ConfigTable;
 429   unsigned long   i;
 430   unsigned long   offset;
 431   unsigned long   numentries;
 432   unsigned long   RuntimeDebugInfo;
 433   unsigned long   DebugInfoOffset;
 434   unsigned long   imgbase;
 435
 436   $printf "LoadRuntimeDxe"$;
 437
 438   $fopen 50, 'C:\loadfiles.inc'$;
 439
 440   RuntimeDebugInfo = 0x80000010;
 441
 442   if(RuntimeDebugInfo != 0)
 443   {
 444     numentries = dword(RuntimeDebugInfo);
 445
 446     $printf "runtime debug info is at %x (%d entries)", RuntimeDebugInfo, numentries$;
 447
 448     DebugInfoOffset = RuntimeDebugInfo + 0x4;
 449     for(i=0; i<numentries; i++)
 450     {
 451       imgbase = dword(DebugInfoOffset);
 452       if(imgbase != 0)
 453       {
 454         $printf "found image at %x",imgbase$;
 455         ProcessPE32(imgbase);
 456       }
 457       DebugInfoOffset = DebugInfoOffset + 0x4;
 458     }
 459   }
 460
 461   $vclose 50$;
 462 }
 463 .