dexdump/DexDump.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * The "dexdump" tool is intended to mimic "objdump".  When possible, use
  19  * similar command-line arguments.
  20  *
  21  * TODO: rework the "plain" output format to be more regexp-friendly
  22  *
  23  * Differences between XML output and the "current.xml" file:
  24  * - classes in same package are not all grouped together; generally speaking
  25  *   nothing is sorted
  26  * - no "deprecated" on fields and methods
  27  * - no "value" on fields
  28  * - no parameter names
  29  * - no generic signatures on parameters, e.g. type="java.lang.Class&lt;?&gt;"
  30  * - class shows declared fields and methods; does not show inherited fields
  31  */
  32
  33 #include "libdex/DexFile.h"
  34
  35 #include "libdex/CmdUtils.h"
  36 #include "libdex/DexCatch.h"
  37 #include "libdex/DexClass.h"
  38 #include "libdex/DexDebugInfo.h"
  39 #include "libdex/DexOpcodes.h"
  40 #include "libdex/DexProto.h"
  41 #include "libdex/InstrUtils.h"
  42 #include "libdex/SysUtil.h"
  43
  44 #include <stdlib.h>
  45 #include <stdio.h>
  46 #include <fcntl.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49 #include <getopt.h>
  50 #include <errno.h>
  51 #include <assert.h>
  52
  53 static const char* gProgName = "dexdump";
  54
  55 enum OutputFormat {
  56     OUTPUT_PLAIN = 0,               /* default */
  57     OUTPUT_XML,                     /* fancy */
  58 };
  59
  60 /* command-line options */
  61 struct Options {
  62     bool checksumOnly;
  63     bool disassemble;
  64     bool showFileHeaders;
  65     bool showSectionHeaders;
  66     bool ignoreBadChecksum;
  67     bool dumpRegisterMaps;
  68     OutputFormat outputFormat;
  69     const char* tempFileName;
  70     bool exportsOnly;
  71     bool verbose;
  72 };
  73
  74 struct Options gOptions;
  75
  76 /* basic info about a field or method */
  77 struct FieldMethodInfo {
  78     const char* classDescriptor;
  79     const char* name;
  80     const char* signature;
  81 };
  82
  83 /*
  84  * Get 2 little-endian bytes.
  85  */
  86 static inline u2 get2LE(unsigned char const* pSrc)
  87 {
  88     return pSrc[0] | (pSrc[1] << 8);
  89 }
  90
  91 /*
  92  * Get 4 little-endian bytes.
  93  */
  94 static inline u4 get4LE(unsigned char const* pSrc)
  95 {
  96     return pSrc[0] | (pSrc[1] << 8) | (pSrc[2] << 16) | (pSrc[3] << 24);
  97 }
  98
  99 /*
 100  * Converts a single-character primitive type into its human-readable
 101  * equivalent.
 102  */
 103 static const char* primitiveTypeLabel(char typeChar)
 104 {
 105     switch (typeChar) {
 106     case 'B':   return "byte";
 107     case 'C':   return "char";
 108     case 'D':   return "double";
 109     case 'F':   return "float";
 110     case 'I':   return "int";
 111     case 'J':   return "long";
 112     case 'S':   return "short";
 113     case 'V':   return "void";
 114     case 'Z':   return "boolean";
 115     default:
 116                 return "UNKNOWN";
 117     }
 118 }
 119
 120 /*
 121  * Converts a type descriptor to human-readable "dotted" form.  For
 122  * example, "Ljava/lang/String;" becomes "java.lang.String", and
 123  * "[I" becomes "int[]".  Also converts '$' to '.', which means this
 124  * form can't be converted back to a descriptor.
 125  */
 126 static char* descriptorToDot(const char* str)
 127 {
 128     int targetLen = strlen(str);
 129     int offset = 0;
 130     int arrayDepth = 0;
 131     char* newStr;
 132
 133     /* strip leading [s; will be added to end */
 134     while (targetLen > 1 && str[offset] == '[') {
 135         offset++;
 136         targetLen--;
 137     }
 138     arrayDepth = offset;
 139
 140     if (targetLen == 1) {
 141         /* primitive type */
 142         str = primitiveTypeLabel(str[offset]);
 143         offset = 0;
 144         targetLen = strlen(str);
 145     } else {
 146         /* account for leading 'L' and trailing ';' */
 147         if (targetLen >= 2 && str[offset] == 'L' &&
 148             str[offset+targetLen-1] == ';')
 149         {
 150             targetLen -= 2;
 151             offset++;
 152         }
 153     }
 154
 155     newStr = (char*)malloc(targetLen + arrayDepth * 2 +1);
 156
 157     /* copy class name over */
 158     int i;
 159     for (i = 0; i < targetLen; i++) {
 160         char ch = str[offset + i];
 161         newStr[i] = (ch == '/' || ch == '$') ? '.' : ch;
 162     }
 163
 164     /* add the appropriate number of brackets for arrays */
 165     while (arrayDepth-- > 0) {
 166         newStr[i++] = '[';
 167         newStr[i++] = ']';
 168     }
 169     newStr[i] = '\0';
 170     assert(i == targetLen + arrayDepth * 2);
 171
 172     return newStr;
 173 }
 174
 175 /*
 176  * Converts the class name portion of a type descriptor to human-readable
 177  * "dotted" form.
 178  *
 179  * Returns a newly-allocated string.
 180  */
 181 static char* descriptorClassToDot(const char* str)
 182 {
 183     const char* lastSlash;
 184     char* newStr;
 185     char* cp;
 186
 187     /* reduce to just the class name, trimming trailing ';' */
 188     lastSlash = strrchr(str, '/');
 189     if (lastSlash == NULL)
 190         lastSlash = str + 1;        /* start past 'L' */
 191     else
 192         lastSlash++;                /* start past '/' */
 193
 194     newStr = strdup(lastSlash);
 195     newStr[strlen(lastSlash)-1] = '\0';
 196     for (cp = newStr; *cp != '\0'; cp++) {
 197         if (*cp == '$')
 198             *cp = '.';
 199     }
 200
 201     return newStr;
 202 }
 203
 204 /*
 205  * Returns a quoted string representing the boolean value.
 206  */
 207 static const char* quotedBool(bool val)
 208 {
 209     if (val)
 210         return "\"true\"";
 211     else
 212         return "\"false\"";
 213 }
 214
 215 static const char* quotedVisibility(u4 accessFlags)
 216 {
 217     if ((accessFlags & ACC_PUBLIC) != 0)
 218         return "\"public\"";
 219     else if ((accessFlags & ACC_PROTECTED) != 0)
 220         return "\"protected\"";
 221     else if ((accessFlags & ACC_PRIVATE) != 0)
 222         return "\"private\"";
 223     else
 224         return "\"package\"";
 225 }
 226
 227 /*
 228  * Count the number of '1' bits in a word.
 229  */
 230 static int countOnes(u4 val)
 231 {
 232     int count = 0;
 233
 234     val = val - ((val >> 1) & 0x55555555);
 235     val = (val & 0x33333333) + ((val >> 2) & 0x33333333);
 236     count = (((val + (val >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
 237
 238     return count;
 239 }
 240
 241 /*
 242  * Flag for use with createAccessFlagStr().
 243  */
 244 enum AccessFor {
 245     kAccessForClass = 0, kAccessForMethod = 1, kAccessForField = 2,
 246     kAccessForMAX
 247 };
 248
 249 /*
 250  * Create a new string with human-readable access flags.
 251  *
 252  * In the base language the access_flags fields are type u2; in Dalvik
 253  * they're u4.
 254  */
 255 static char* createAccessFlagStr(u4 flags, AccessFor forWhat)
 256 {
 257 #define NUM_FLAGS   18
 258     static const char* kAccessStrings[kAccessForMAX][NUM_FLAGS] = {
 259         {
 260             /* class, inner class */
 261             "PUBLIC",           /* 0x0001 */
 262             "PRIVATE",          /* 0x0002 */
 263             "PROTECTED",        /* 0x0004 */
 264             "STATIC",           /* 0x0008 */
 265             "FINAL",            /* 0x0010 */
 266             "?",                /* 0x0020 */
 267             "?",                /* 0x0040 */
 268             "?",                /* 0x0080 */
 269             "?",                /* 0x0100 */
 270             "INTERFACE",        /* 0x0200 */
 271             "ABSTRACT",         /* 0x0400 */
 272             "?",                /* 0x0800 */
 273             "SYNTHETIC",        /* 0x1000 */
 274             "ANNOTATION",       /* 0x2000 */
 275             "ENUM",             /* 0x4000 */
 276             "?",                /* 0x8000 */
 277             "VERIFIED",         /* 0x10000 */
 278             "OPTIMIZED",        /* 0x20000 */
 279         },
 280         {
 281             /* method */
 282             "PUBLIC",           /* 0x0001 */
 283             "PRIVATE",          /* 0x0002 */
 284             "PROTECTED",        /* 0x0004 */
 285             "STATIC",           /* 0x0008 */
 286             "FINAL",            /* 0x0010 */
 287             "SYNCHRONIZED",     /* 0x0020 */
 288             "BRIDGE",           /* 0x0040 */
 289             "VARARGS",          /* 0x0080 */
 290             "NATIVE",           /* 0x0100 */
 291             "?",                /* 0x0200 */
 292             "ABSTRACT",         /* 0x0400 */
 293             "STRICT",           /* 0x0800 */
 294             "SYNTHETIC",        /* 0x1000 */
 295             "?",                /* 0x2000 */
 296             "?",                /* 0x4000 */
 297             "MIRANDA",          /* 0x8000 */
 298             "CONSTRUCTOR",      /* 0x10000 */
 299             "DECLARED_SYNCHRONIZED", /* 0x20000 */
 300         },
 301         {
 302             /* field */
 303             "PUBLIC",           /* 0x0001 */
 304             "PRIVATE",          /* 0x0002 */
 305             "PROTECTED",        /* 0x0004 */
 306             "STATIC",           /* 0x0008 */
 307             "FINAL",            /* 0x0010 */
 308             "?",                /* 0x0020 */
 309             "VOLATILE",         /* 0x0040 */
 310             "TRANSIENT",        /* 0x0080 */
 311             "?",                /* 0x0100 */
 312             "?",                /* 0x0200 */
 313             "?",                /* 0x0400 */
 314             "?",                /* 0x0800 */
 315             "SYNTHETIC",        /* 0x1000 */
 316             "?",                /* 0x2000 */
 317             "ENUM",             /* 0x4000 */
 318             "?",                /* 0x8000 */
 319             "?",                /* 0x10000 */
 320             "?",                /* 0x20000 */
 321         },
 322     };
 323     const int kLongest = 21;        /* strlen of longest string above */
 324     int i, count;
 325     char* str;
 326     char* cp;
 327
 328     /*
 329      * Allocate enough storage to hold the expected number of strings,
 330      * plus a space between each.  We over-allocate, using the longest
 331      * string above as the base metric.
 332      */
 333     count = countOnes(flags);
 334     cp = str = (char*) malloc(count * (kLongest+1) +1);
 335
 336     for (i = 0; i < NUM_FLAGS; i++) {
 337         if (flags & 0x01) {
 338             const char* accessStr = kAccessStrings[forWhat][i];
 339             int len = strlen(accessStr);
 340             if (cp != str)
 341                 *cp++ = ' ';
 342
 343             memcpy(cp, accessStr, len);
 344             cp += len;
 345         }
 346         flags >>= 1;
 347     }
 348     *cp = '\0';
 349
 350     return str;
 351 }
 352
 353
 354 /*
 355  * Copy character data from "data" to "out", converting non-ASCII values
 356  * to printf format chars or an ASCII filler ('.' or '?').
 357  *
 358  * The output buffer must be able to hold (2*len)+1 bytes.  The result is
 359  * NUL-terminated.
 360  */
 361 static void asciify(char* out, const unsigned char* data, size_t len)
 362 {
 363     while (len--) {
 364         if (*data < 0x20) {
 365             /* could do more here, but we don't need them yet */
 366             switch (*data) {
 367             case '\0':
 368                 *out++ = '\\';
 369                 *out++ = '0';
 370                 break;
 371             case '\n':
 372                 *out++ = '\\';
 373                 *out++ = 'n';
 374                 break;
 375             default:
 376                 *out++ = '.';
 377                 break;
 378             }
 379         } else if (*data >= 0x80) {
 380             *out++ = '?';
 381         } else {
 382             *out++ = *data;
 383         }
 384         data++;
 385     }
 386     *out = '\0';
 387 }
 388
 389 /*
 390  * Dump the file header.
 391  */
 392 void dumpFileHeader(const DexFile* pDexFile)
 393 {
 394     const DexOptHeader* pOptHeader = pDexFile->pOptHeader;
 395     const DexHeader* pHeader = pDexFile->pHeader;
 396     char sanitized[sizeof(pHeader->magic)*2 +1];
 397
 398     assert(sizeof(pHeader->magic) == sizeof(pOptHeader->magic));
 399
 400     if (pOptHeader != NULL) {
 401         printf("Optimized DEX file header:\n");
 402
 403         asciify(sanitized, pOptHeader->magic, sizeof(pOptHeader->magic));
 404         printf("magic               : '%s'\n", sanitized);
 405         printf("dex_offset          : %d (0x%06x)\n",
 406             pOptHeader->dexOffset, pOptHeader->dexOffset);
 407         printf("dex_length          : %d\n", pOptHeader->dexLength);
 408         printf("deps_offset         : %d (0x%06x)\n",
 409             pOptHeader->depsOffset, pOptHeader->depsOffset);
 410         printf("deps_length         : %d\n", pOptHeader->depsLength);
 411         printf("opt_offset          : %d (0x%06x)\n",
 412             pOptHeader->optOffset, pOptHeader->optOffset);
 413         printf("opt_length          : %d\n", pOptHeader->optLength);
 414         printf("flags               : %08x\n", pOptHeader->flags);
 415         printf("checksum            : %08x\n", pOptHeader->checksum);
 416         printf("\n");
 417     }
 418
 419     printf("DEX file header:\n");
 420     asciify(sanitized, pHeader->magic, sizeof(pHeader->magic));
 421     printf("magic               : '%s'\n", sanitized);
 422     printf("checksum            : %08x\n", pHeader->checksum);
 423     printf("signature           : %02x%02x...%02x%02x\n",
 424         pHeader->signature[0], pHeader->signature[1],
 425         pHeader->signature[kSHA1DigestLen-2],
 426         pHeader->signature[kSHA1DigestLen-1]);
 427     printf("file_size           : %d\n", pHeader->fileSize);
 428     printf("header_size         : %d\n", pHeader->headerSize);
 429     printf("link_size           : %d\n", pHeader->linkSize);
 430     printf("link_off            : %d (0x%06x)\n",
 431         pHeader->linkOff, pHeader->linkOff);
 432     printf("string_ids_size     : %d\n", pHeader->stringIdsSize);
 433     printf("string_ids_off      : %d (0x%06x)\n",
 434         pHeader->stringIdsOff, pHeader->stringIdsOff);
 435     printf("type_ids_size       : %d\n", pHeader->typeIdsSize);
 436     printf("type_ids_off        : %d (0x%06x)\n",
 437         pHeader->typeIdsOff, pHeader->typeIdsOff);
 438     printf("proto_ids_size       : %d\n", pHeader->protoIdsSize);
 439     printf("proto_ids_off        : %d (0x%06x)\n",
 440         pHeader->protoIdsOff, pHeader->protoIdsOff);
 441     printf("field_ids_size      : %d\n", pHeader->fieldIdsSize);
 442     printf("field_ids_off       : %d (0x%06x)\n",
 443         pHeader->fieldIdsOff, pHeader->fieldIdsOff);
 444     printf("method_ids_size     : %d\n", pHeader->methodIdsSize);
 445     printf("method_ids_off      : %d (0x%06x)\n",
 446         pHeader->methodIdsOff, pHeader->methodIdsOff);
 447     printf("class_defs_size     : %d\n", pHeader->classDefsSize);
 448     printf("class_defs_off      : %d (0x%06x)\n",
 449         pHeader->classDefsOff, pHeader->classDefsOff);
 450     printf("data_size           : %d\n", pHeader->dataSize);
 451     printf("data_off            : %d (0x%06x)\n",
 452         pHeader->dataOff, pHeader->dataOff);
 453     printf("\n");
 454 }
 455
 456 /*
 457  * Dump the "table of contents" for the opt area.
 458  */
 459 void dumpOptDirectory(const DexFile* pDexFile)
 460 {
 461     const DexOptHeader* pOptHeader = pDexFile->pOptHeader;
 462     if (pOptHeader == NULL)
 463         return;
 464
 465     printf("OPT section contents:\n");
 466
 467     const u4* pOpt = (const u4*) ((u1*) pOptHeader + pOptHeader->optOffset);
 468
 469     if (*pOpt == 0) {
 470         printf("(1.0 format, only class lookup table is present)\n\n");
 471         return;
 472     }
 473
 474     /*
 475      * The "opt" section is in "chunk" format: a 32-bit identifier, a 32-bit
 476      * length, then the data.  Chunks start on 64-bit boundaries.
 477      */
 478     while (*pOpt != kDexChunkEnd) {
 479         const char* verboseStr;
 480
 481         u4 size = *(pOpt+1);
 482
 483         switch (*pOpt) {
 484         case kDexChunkClassLookup:
 485             verboseStr = "class lookup hash table";
 486             break;
 487         case kDexChunkRegisterMaps:
 488             verboseStr = "register maps";
 489             break;
 490         default:
 491             verboseStr = "(unknown chunk type)";
 492             break;
 493         }
 494
 495         printf("Chunk %08x (%c%c%c%c) - %s (%d bytes)\n", *pOpt,
 496             *pOpt >> 24, (char)(*pOpt >> 16), (char)(*pOpt >> 8), (char)*pOpt,
 497             verboseStr, size);
 498
 499         size = (size + 8 + 7) & ~7;
 500         pOpt += size / sizeof(u4);
 501     }
 502     printf("\n");
 503 }
 504
 505 /*
 506  * Dump a class_def_item.
 507  */
 508 void dumpClassDef(DexFile* pDexFile, int idx)
 509 {
 510     const DexClassDef* pClassDef;
 511     const u1* pEncodedData;
 512     DexClassData* pClassData;
 513
 514     pClassDef = dexGetClassDef(pDexFile, idx);
 515     pEncodedData = dexGetClassData(pDexFile, pClassDef);
 516     pClassData = dexReadAndVerifyClassData(&pEncodedData, NULL);
 517
 518     if (pClassData == NULL) {
 519         fprintf(stderr, "Trouble reading class data\n");
 520         return;
 521     }
 522
 523     printf("Class #%d header:\n", idx);
 524     printf("class_idx           : %d\n", pClassDef->classIdx);
 525     printf("access_flags        : %d (0x%04x)\n",
 526         pClassDef->accessFlags, pClassDef->accessFlags);
 527     printf("superclass_idx      : %d\n", pClassDef->superclassIdx);
 528     printf("interfaces_off      : %d (0x%06x)\n",
 529         pClassDef->interfacesOff, pClassDef->interfacesOff);
 530     printf("source_file_idx     : %d\n", pClassDef->sourceFileIdx);
 531     printf("annotations_off     : %d (0x%06x)\n",
 532         pClassDef->annotationsOff, pClassDef->annotationsOff);
 533     printf("class_data_off      : %d (0x%06x)\n",
 534         pClassDef->classDataOff, pClassDef->classDataOff);
 535     printf("static_fields_size  : %d\n", pClassData->header.staticFieldsSize);
 536     printf("instance_fields_size: %d\n",
 537             pClassData->header.instanceFieldsSize);
 538     printf("direct_methods_size : %d\n", pClassData->header.directMethodsSize);
 539     printf("virtual_methods_size: %d\n",
 540             pClassData->header.virtualMethodsSize);
 541     printf("\n");
 542
 543     free(pClassData);
 544 }
 545
 546 /*
 547  * Dump an interface that a class declares to implement.
 548  */
 549 void dumpInterface(const DexFile* pDexFile, const DexTypeItem* pTypeItem,
 550     int i)
 551 {
 552     const char* interfaceName =
 553         dexStringByTypeIdx(pDexFile, pTypeItem->typeIdx);
 554
 555     if (gOptions.outputFormat == OUTPUT_PLAIN) {
 556         printf("    #%d              : '%s'\n", i, interfaceName);
 557     } else {
 558         char* dotted = descriptorToDot(interfaceName);
 559         printf("<implements name=\"%s\">\n</implements>\n", dotted);
 560         free(dotted);
 561     }
 562 }
 563
 564 /*
 565  * Dump the catches table associated with the code.
 566  */
 567 void dumpCatches(DexFile* pDexFile, const DexCode* pCode)
 568 {
 569     u4 triesSize = pCode->triesSize;
 570
 571     if (triesSize == 0) {
 572         printf("      catches       : (none)\n");
 573         return;
 574     }
 575
 576     printf("      catches       : %d\n", triesSize);
 577
 578     const DexTry* pTries = dexGetTries(pCode);
 579     u4 i;
 580
 581     for (i = 0; i < triesSize; i++) {
 582         const DexTry* pTry = &pTries[i];
 583         u4 start = pTry->startAddr;
 584         u4 end = start + pTry->insnCount;
 585         DexCatchIterator iterator;
 586
 587         printf("        0x%04x - 0x%04x\n", start, end);
 588
 589         dexCatchIteratorInit(&iterator, pCode, pTry->handlerOff);
 590
 591         for (;;) {
 592             DexCatchHandler* handler = dexCatchIteratorNext(&iterator);
 593             const char* descriptor;
 594
 595             if (handler == NULL) {
 596                 break;
 597             }
 598
 599             descriptor = (handler->typeIdx == kDexNoIndex) ? "<any>" :
 600                 dexStringByTypeIdx(pDexFile, handler->typeIdx);
 601
 602             printf("          %s -> 0x%04x\n", descriptor,
 603                     handler->address);
 604         }
 605     }
 606 }
 607
 608 static int dumpPositionsCb(void *cnxt, u4 address, u4 lineNum)
 609 {
 610     printf("        0x%04x line=%d\n", address, lineNum);
 611     return 0;
 612 }
 613
 614 /*
 615  * Dump the positions list.
 616  */
 617 void dumpPositions(DexFile* pDexFile, const DexCode* pCode,
 618         const DexMethod *pDexMethod)
 619 {
 620     printf("      positions     : \n");
 621     const DexMethodId *pMethodId
 622             = dexGetMethodId(pDexFile, pDexMethod->methodIdx);
 623     const char *classDescriptor
 624             = dexStringByTypeIdx(pDexFile, pMethodId->classIdx);
 625
 626     dexDecodeDebugInfo(pDexFile, pCode, classDescriptor, pMethodId->protoIdx,
 627             pDexMethod->accessFlags, dumpPositionsCb, NULL, NULL);
 628 }
 629
 630 static void dumpLocalsCb(void *cnxt, u2 reg, u4 startAddress,
 631         u4 endAddress, const char *name, const char *descriptor,
 632         const char *signature)
 633 {
 634     printf("        0x%04x - 0x%04x reg=%d %s %s %s\n",
 635             startAddress, endAddress, reg, name, descriptor,
 636             signature);
 637 }
 638
 639 /*
 640  * Dump the locals list.
 641  */
 642 void dumpLocals(DexFile* pDexFile, const DexCode* pCode,
 643         const DexMethod *pDexMethod)
 644 {
 645     printf("      locals        : \n");
 646
 647     const DexMethodId *pMethodId
 648             = dexGetMethodId(pDexFile, pDexMethod->methodIdx);
 649     const char *classDescriptor
 650             = dexStringByTypeIdx(pDexFile, pMethodId->classIdx);
 651
 652     dexDecodeDebugInfo(pDexFile, pCode, classDescriptor, pMethodId->protoIdx,
 653             pDexMethod->accessFlags, NULL, dumpLocalsCb, NULL);
 654 }
 655
 656 /*
 657  * Get information about a method.
 658  */
 659 bool getMethodInfo(DexFile* pDexFile, u4 methodIdx, FieldMethodInfo* pMethInfo)
 660 {
 661     const DexMethodId* pMethodId;
 662
 663     if (methodIdx >= pDexFile->pHeader->methodIdsSize)
 664         return false;
 665
 666     pMethodId = dexGetMethodId(pDexFile, methodIdx);
 667     pMethInfo->name = dexStringById(pDexFile, pMethodId->nameIdx);
 668     pMethInfo->signature = dexCopyDescriptorFromMethodId(pDexFile, pMethodId);
 669
 670     pMethInfo->classDescriptor =
 671             dexStringByTypeIdx(pDexFile, pMethodId->classIdx);
 672     return true;
 673 }
 674
 675 /*
 676  * Get information about a field.
 677  */
 678 bool getFieldInfo(DexFile* pDexFile, u4 fieldIdx, FieldMethodInfo* pFieldInfo)
 679 {
 680     const DexFieldId* pFieldId;
 681
 682     if (fieldIdx >= pDexFile->pHeader->fieldIdsSize)
 683         return false;
 684
 685     pFieldId = dexGetFieldId(pDexFile, fieldIdx);
 686     pFieldInfo->name = dexStringById(pDexFile, pFieldId->nameIdx);
 687     pFieldInfo->signature = dexStringByTypeIdx(pDexFile, pFieldId->typeIdx);
 688     pFieldInfo->classDescriptor =
 689         dexStringByTypeIdx(pDexFile, pFieldId->classIdx);
 690     return true;
 691 }
 692
 693
 694 /*
 695  * Look up a class' descriptor.
 696  */
 697 const char* getClassDescriptor(DexFile* pDexFile, u4 classIdx)
 698 {
 699     return dexStringByTypeIdx(pDexFile, classIdx);
 700 }
 701
 702 /*
 703  * Helper for dumpInstruction(), which builds the string
 704  * representation for the index in the given instruction. This will
 705  * first try to use the given buffer, but if the result won't fit,
 706  * then this will allocate a new buffer to hold the result. A pointer
 707  * to the buffer which holds the full result is always returned, and
 708  * this can be compared with the one passed in, to see if the result
 709  * needs to be free()d.
 710  */
 711 static char* indexString(DexFile* pDexFile,
 712     const DecodedInstruction* pDecInsn, char* buf, size_t bufSize)
 713 {
 714     int outSize;
 715     u4 index;
 716     u4 width;
 717
 718     /* TODO: Make the index *always* be in field B, to simplify this code. */
 719     switch (dexGetFormatFromOpcode(pDecInsn->opcode)) {
 720     case kFmt20bc:
 721     case kFmt21c:
 722     case kFmt35c:
 723     case kFmt35ms:
 724     case kFmt3rc:
 725     case kFmt3rms:
 726     case kFmt35mi:
 727     case kFmt3rmi:
 728         index = pDecInsn->vB;
 729         width = 4;
 730         break;
 731     case kFmt31c:
 732         index = pDecInsn->vB;
 733         width = 8;
 734         break;
 735     case kFmt22c:
 736     case kFmt22cs:
 737         index = pDecInsn->vC;
 738         width = 4;
 739         break;
 740     default:
 741         index = 0;
 742         width = 4;
 743         break;
 744     }
 745
 746     switch (pDecInsn->indexType) {
 747     case kIndexUnknown:
 748         /*
 749          * This function shouldn't ever get called for this type, but do
 750          * something sensible here, just to help with debugging.
 751          */
 752         outSize = snprintf(buf, bufSize, "<unknown-index>");
 753         break;
 754     case kIndexNone:
 755         /*
 756          * This function shouldn't ever get called for this type, but do
 757          * something sensible here, just to help with debugging.
 758          */
 759         outSize = snprintf(buf, bufSize, "<no-index>");
 760         break;
 761     case kIndexVaries:
 762         /*
 763          * This one should never show up in a dexdump, so no need to try
 764          * to get fancy here.
 765          */
 766         outSize = snprintf(buf, bufSize, "<index-varies> // thing@%0*x",
 767                 width, index);
 768         break;
 769     case kIndexTypeRef:
 770         if (index < pDexFile->pHeader->typeIdsSize) {
 771             outSize = snprintf(buf, bufSize, "%s // type@%0*x",
 772                                getClassDescriptor(pDexFile, index), width, index);
 773         } else {
 774             outSize = snprintf(buf, bufSize, "<type?> // type@%0*x", width, index);
 775         }
 776         break;
 777     case kIndexStringRef:
 778         if (index < pDexFile->pHeader->stringIdsSize) {
 779             outSize = snprintf(buf, bufSize, "\"%s\" // string@%0*x",
 780                                dexStringById(pDexFile, index), width, index);
 781         } else {
 782             outSize = snprintf(buf, bufSize, "<string?> // string@%0*x",
 783                                width, index);
 784         }
 785         break;
 786     case kIndexMethodRef:
 787         {
 788             FieldMethodInfo methInfo;
 789             if (getMethodInfo(pDexFile, index, &methInfo)) {
 790                 outSize = snprintf(buf, bufSize, "%s.%s:%s // method@%0*x",
 791                         methInfo.classDescriptor, methInfo.name,
 792                         methInfo.signature, width, index);
 793                 free((void *) methInfo.signature);
 794             } else {
 795                 outSize = snprintf(buf, bufSize, "<method?> // method@%0*x",
 796                         width, index);
 797             }
 798         }
 799         break;
 800     case kIndexFieldRef:
 801         {
 802             FieldMethodInfo fieldInfo;
 803             if (getFieldInfo(pDexFile, index, &fieldInfo)) {
 804                 outSize = snprintf(buf, bufSize, "%s.%s:%s // field@%0*x",
 805                         fieldInfo.classDescriptor, fieldInfo.name,
 806                         fieldInfo.signature, width, index);
 807             } else {
 808                 outSize = snprintf(buf, bufSize, "<field?> // field@%0*x",
 809                         width, index);
 810             }
 811         }
 812         break;
 813     case kIndexInlineMethod:
 814         outSize = snprintf(buf, bufSize, "[%0*x] // inline #%0*x",
 815                 width, index, width, index);
 816         break;
 817     case kIndexVtableOffset:
 818         outSize = snprintf(buf, bufSize, "[%0*x] // vtable #%0*x",
 819                 width, index, width, index);
 820         break;
 821     case kIndexFieldOffset:
 822         outSize = snprintf(buf, bufSize, "[obj+%0*x]", width, index);
 823         break;
 824     default:
 825         outSize = snprintf(buf, bufSize, "<?>");
 826         break;
 827     }
 828
 829     if (outSize >= (int) bufSize) {
 830         /*
 831          * The buffer wasn't big enough; allocate and retry. Note:
 832          * snprintf() doesn't count the '\0' as part of its returned
 833          * size, so we add explicit space for it here.
 834          */
 835         outSize++;
 836         buf = (char*)malloc(outSize);
 837         if (buf == NULL) {
 838             return NULL;
 839         }
 840         return indexString(pDexFile, pDecInsn, buf, outSize);
 841     } else {
 842         return buf;
 843     }
 844 }
 845
 846 /*
 847  * Dump a single instruction.
 848  */
 849 void dumpInstruction(DexFile* pDexFile, const DexCode* pCode, int insnIdx,
 850     int insnWidth, const DecodedInstruction* pDecInsn)
 851 {
 852     char indexBufChars[200];
 853     char *indexBuf = indexBufChars;
 854     const u2* insns = pCode->insns;
 855     int i;
 856
 857     printf("%06x:", ((u1*)insns - pDexFile->baseAddr) + insnIdx*2);
 858     for (i = 0; i < 8; i++) {
 859         if (i < insnWidth) {
 860             if (i == 7) {
 861                 printf(" ... ");
 862             } else {
 863                 /* print 16-bit value in little-endian order */
 864                 const u1* bytePtr = (const u1*) &insns[insnIdx+i];
 865                 printf(" %02x%02x", bytePtr[0], bytePtr[1]);
 866             }
 867         } else {
 868             fputs("     ", stdout);
 869         }
 870     }
 871
 872     if (pDecInsn->opcode == OP_NOP) {
 873         u2 instr = get2LE((const u1*) &insns[insnIdx]);
 874         if (instr == kPackedSwitchSignature) {
 875             printf("|%04x: packed-switch-data (%d units)",
 876                 insnIdx, insnWidth);
 877         } else if (instr == kSparseSwitchSignature) {
 878             printf("|%04x: sparse-switch-data (%d units)",
 879                 insnIdx, insnWidth);
 880         } else if (instr == kArrayDataSignature) {
 881             printf("|%04x: array-data (%d units)",
 882                 insnIdx, insnWidth);
 883         } else {
 884             printf("|%04x: nop // spacer", insnIdx);
 885         }
 886     } else {
 887         printf("|%04x: %s", insnIdx, dexGetOpcodeName(pDecInsn->opcode));
 888     }
 889
 890     if (pDecInsn->indexType != kIndexNone) {
 891         indexBuf = indexString(pDexFile, pDecInsn,
 892                 indexBufChars, sizeof(indexBufChars));
 893     }
 894
 895     switch (dexGetFormatFromOpcode(pDecInsn->opcode)) {
 896     case kFmt10x:        // op
 897         break;
 898     case kFmt12x:        // op vA, vB
 899         printf(" v%d, v%d", pDecInsn->vA, pDecInsn->vB);
 900         break;
 901     case kFmt11n:        // op vA, #+B
 902         printf(" v%d, #int %d // #%x",
 903             pDecInsn->vA, (s4)pDecInsn->vB, (u1)pDecInsn->vB);
 904         break;
 905     case kFmt11x:        // op vAA
 906         printf(" v%d", pDecInsn->vA);
 907         break;
 908     case kFmt10t:        // op +AA
 909     case kFmt20t:        // op +AAAA
 910         {
 911             s4 targ = (s4) pDecInsn->vA;
 912             printf(" %04x // %c%04x",
 913                 insnIdx + targ,
 914                 (targ < 0) ? '-' : '+',
 915                 (targ < 0) ? -targ : targ);
 916         }
 917         break;
 918     case kFmt22x:        // op vAA, vBBBB
 919         printf(" v%d, v%d", pDecInsn->vA, pDecInsn->vB);
 920         break;
 921     case kFmt21t:        // op vAA, +BBBB
 922         {
 923             s4 targ = (s4) pDecInsn->vB;
 924             printf(" v%d, %04x // %c%04x", pDecInsn->vA,
 925                 insnIdx + targ,
 926                 (targ < 0) ? '-' : '+',
 927                 (targ < 0) ? -targ : targ);
 928         }
 929         break;
 930     case kFmt21s:        // op vAA, #+BBBB
 931         printf(" v%d, #int %d // #%x",
 932             pDecInsn->vA, (s4)pDecInsn->vB, (u2)pDecInsn->vB);
 933         break;
 934     case kFmt21h:        // op vAA, #+BBBB0000[00000000]
 935         // The printed format varies a bit based on the actual opcode.
 936         if (pDecInsn->opcode == OP_CONST_HIGH16) {
 937             s4 value = pDecInsn->vB << 16;
 938             printf(" v%d, #int %d // #%x",
 939                 pDecInsn->vA, value, (u2)pDecInsn->vB);
 940         } else {
 941             s8 value = ((s8) pDecInsn->vB) << 48;
 942             printf(" v%d, #long %lld // #%x",
 943                 pDecInsn->vA, value, (u2)pDecInsn->vB);
 944         }
 945         break;
 946     case kFmt21c:        // op vAA, thing@BBBB
 947     case kFmt31c:        // op vAA, thing@BBBBBBBB
 948         printf(" v%d, %s", pDecInsn->vA, indexBuf);
 949         break;
 950     case kFmt23x:        // op vAA, vBB, vCC
 951         printf(" v%d, v%d, v%d", pDecInsn->vA, pDecInsn->vB, pDecInsn->vC);
 952         break;
 953     case kFmt22b:        // op vAA, vBB, #+CC
 954         printf(" v%d, v%d, #int %d // #%02x",
 955             pDecInsn->vA, pDecInsn->vB, (s4)pDecInsn->vC, (u1)pDecInsn->vC);
 956         break;
 957     case kFmt22t:        // op vA, vB, +CCCC
 958         {
 959             s4 targ = (s4) pDecInsn->vC;
 960             printf(" v%d, v%d, %04x // %c%04x", pDecInsn->vA, pDecInsn->vB,
 961                 insnIdx + targ,
 962                 (targ < 0) ? '-' : '+',
 963                 (targ < 0) ? -targ : targ);
 964         }
 965         break;
 966     case kFmt22s:        // op vA, vB, #+CCCC
 967         printf(" v%d, v%d, #int %d // #%04x",
 968             pDecInsn->vA, pDecInsn->vB, (s4)pDecInsn->vC, (u2)pDecInsn->vC);
 969         break;
 970     case kFmt22c:        // op vA, vB, thing@CCCC
 971     case kFmt22cs:       // [opt] op vA, vB, field offset CCCC
 972         printf(" v%d, v%d, %s", pDecInsn->vA, pDecInsn->vB, indexBuf);
 973         break;
 974     case kFmt30t:
 975         printf(" #%08x", pDecInsn->vA);
 976         break;
 977     case kFmt31i:        // op vAA, #+BBBBBBBB
 978         {
 979             /* this is often, but not always, a float */
 980             union {
 981                 float f;
 982                 u4 i;
 983             } conv;
 984             conv.i = pDecInsn->vB;
 985             printf(" v%d, #float %f // #%08x",
 986                 pDecInsn->vA, conv.f, pDecInsn->vB);
 987         }
 988         break;
 989     case kFmt31t:       // op vAA, offset +BBBBBBBB
 990         printf(" v%d, %08x // +%08x",
 991             pDecInsn->vA, insnIdx + pDecInsn->vB, pDecInsn->vB);
 992         break;
 993     case kFmt32x:        // op vAAAA, vBBBB
 994         printf(" v%d, v%d", pDecInsn->vA, pDecInsn->vB);
 995         break;
 996     case kFmt35c:        // op {vC, vD, vE, vF, vG}, thing@BBBB
 997     case kFmt35ms:       // [opt] invoke-virtual+super
 998     case kFmt35mi:       // [opt] inline invoke
 999         {
1000             fputs(" {", stdout);
1001             for (i = 0; i < (int) pDecInsn->vA; i++) {
1002                 if (i == 0)
1003                     printf("v%d", pDecInsn->arg[i]);
1004                 else
1005                     printf(", v%d", pDecInsn->arg[i]);
1006             }
1007             printf("}, %s", indexBuf);
1008         }
1009         break;
1010     case kFmt3rc:        // op {vCCCC .. v(CCCC+AA-1)}, thing@BBBB
1011     case kFmt3rms:       // [opt] invoke-virtual+super/range
1012     case kFmt3rmi:       // [opt] execute-inline/range
1013         {
1014             /*
1015              * This doesn't match the "dx" output when some of the args are
1016              * 64-bit values -- dx only shows the first register.
1017              */
1018             fputs(" {", stdout);
1019             for (i = 0; i < (int) pDecInsn->vA; i++) {
1020                 if (i == 0)
1021                     printf("v%d", pDecInsn->vC + i);
1022                 else
1023                     printf(", v%d", pDecInsn->vC + i);
1024             }
1025             printf("}, %s", indexBuf);
1026         }
1027         break;
1028     case kFmt51l:        // op vAA, #+BBBBBBBBBBBBBBBB
1029         {
1030             /* this is often, but not always, a double */
1031             union {
1032                 double d;
1033                 u8 j;
1034             } conv;
1035             conv.j = pDecInsn->vB_wide;
1036             printf(" v%d, #double %f // #%016llx",
1037                 pDecInsn->vA, conv.d, pDecInsn->vB_wide);
1038         }
1039         break;
1040     case kFmt00x:        // unknown op or breakpoint
1041         break;
1042     default:
1043         printf(" ???");
1044         break;
1045     }
1046
1047     putchar('\n');
1048
1049     if (indexBuf != indexBufChars) {
1050         free(indexBuf);
1051     }
1052 }
1053
1054 /*
1055  * Dump a bytecode disassembly.
1056  */
1057 void dumpBytecodes(DexFile* pDexFile, const DexMethod* pDexMethod)
1058 {
1059     const DexCode* pCode = dexGetCode(pDexFile, pDexMethod);
1060     const u2* insns;
1061     int insnIdx;
1062     FieldMethodInfo methInfo;
1063     int startAddr;
1064     char* className = NULL;
1065
1066     assert(pCode->insnsSize > 0);
1067     insns = pCode->insns;
1068
1069     getMethodInfo(pDexFile, pDexMethod->methodIdx, &methInfo);
1070     startAddr = ((u1*)pCode - pDexFile->baseAddr);
1071     className = descriptorToDot(methInfo.classDescriptor);
1072
1073     printf("%06x:                                        |[%06x] %s.%s:%s\n",
1074         startAddr, startAddr,
1075         className, methInfo.name, methInfo.signature);
1076     free((void *) methInfo.signature);
1077
1078     insnIdx = 0;
1079     while (insnIdx < (int) pCode->insnsSize) {
1080         int insnWidth;
1081         DecodedInstruction decInsn;
1082         u2 instr;
1083
1084         /*
1085          * Note: This code parallels the function
1086          * dexGetWidthFromInstruction() in InstrUtils.c, but this version
1087          * can deal with data in either endianness.
1088          *
1089          * TODO: Figure out if this really matters, and possibly change
1090          * this to just use dexGetWidthFromInstruction().
1091          */
1092         instr = get2LE((const u1*)insns);
1093         if (instr == kPackedSwitchSignature) {
1094             insnWidth = 4 + get2LE((const u1*)(insns+1)) * 2;
1095         } else if (instr == kSparseSwitchSignature) {
1096             insnWidth = 2 + get2LE((const u1*)(insns+1)) * 4;
1097         } else if (instr == kArrayDataSignature) {
1098             int width = get2LE((const u1*)(insns+1));
1099             int size = get2LE((const u1*)(insns+2)) |
1100                        (get2LE((const u1*)(insns+3))<<16);
1101             // The plus 1 is to round up for odd size and width.
1102             insnWidth = 4 + ((size * width) + 1) / 2;
1103         } else {
1104             Opcode opcode = dexOpcodeFromCodeUnit(instr);
1105             insnWidth = dexGetWidthFromOpcode(opcode);
1106             if (insnWidth == 0) {
1107                 fprintf(stderr,
1108                     "GLITCH: zero-width instruction at idx=0x%04x\n", insnIdx);
1109                 break;
1110             }
1111         }
1112
1113         dexDecodeInstruction(insns, &decInsn);
1114         dumpInstruction(pDexFile, pCode, insnIdx, insnWidth, &decInsn);
1115
1116         insns += insnWidth;
1117         insnIdx += insnWidth;
1118     }
1119
1120     free(className);
1121 }
1122
1123 /*
1124  * Dump a "code" struct.
1125  */
1126 void dumpCode(DexFile* pDexFile, const DexMethod* pDexMethod)
1127 {
1128     const DexCode* pCode = dexGetCode(pDexFile, pDexMethod);
1129
1130     printf("      registers     : %d\n", pCode->registersSize);
1131     printf("      ins           : %d\n", pCode->insSize);
1132     printf("      outs          : %d\n", pCode->outsSize);
1133     printf("      insns size    : %d 16-bit code units\n", pCode->insnsSize);
1134
1135     if (gOptions.disassemble)
1136         dumpBytecodes(pDexFile, pDexMethod);
1137
1138     dumpCatches(pDexFile, pCode);
1139     /* both of these are encoded in debug info */
1140     dumpPositions(pDexFile, pCode, pDexMethod);
1141     dumpLocals(pDexFile, pCode, pDexMethod);
1142 }
1143
1144 /*
1145  * Dump a method.
1146  */
1147 void dumpMethod(DexFile* pDexFile, const DexMethod* pDexMethod, int i)
1148 {
1149     const DexMethodId* pMethodId;
1150     const char* backDescriptor;
1151     const char* name;
1152     char* typeDescriptor = NULL;
1153     char* accessStr = NULL;
1154
1155     if (gOptions.exportsOnly &&
1156         (pDexMethod->accessFlags & (ACC_PUBLIC | ACC_PROTECTED)) == 0)
1157     {
1158         return;
1159     }
1160
1161     pMethodId = dexGetMethodId(pDexFile, pDexMethod->methodIdx);
1162     name = dexStringById(pDexFile, pMethodId->nameIdx);
1163     typeDescriptor = dexCopyDescriptorFromMethodId(pDexFile, pMethodId);
1164
1165     backDescriptor = dexStringByTypeIdx(pDexFile, pMethodId->classIdx);
1166
1167     accessStr = createAccessFlagStr(pDexMethod->accessFlags,
1168                     kAccessForMethod);
1169
1170     if (gOptions.outputFormat == OUTPUT_PLAIN) {
1171         printf("    #%d              : (in %s)\n", i, backDescriptor);
1172         printf("      name          : '%s'\n", name);
1173         printf("      type          : '%s'\n", typeDescriptor);
1174         printf("      access        : 0x%04x (%s)\n",
1175             pDexMethod->accessFlags, accessStr);
1176
1177         if (pDexMethod->codeOff == 0) {
1178             printf("      code          : (none)\n");
1179         } else {
1180             printf("      code          -\n");
1181             dumpCode(pDexFile, pDexMethod);
1182         }
1183
1184         if (gOptions.disassemble)
1185             putchar('\n');
1186     } else if (gOptions.outputFormat == OUTPUT_XML) {
1187         bool constructor = (name[0] == '<');
1188
1189         if (constructor) {
1190             char* tmp;
1191
1192             tmp = descriptorClassToDot(backDescriptor);
1193             printf("<constructor name=\"%s\"\n", tmp);
1194             free(tmp);
1195
1196             tmp = descriptorToDot(backDescriptor);
1197             printf(" type=\"%s\"\n", tmp);
1198             free(tmp);
1199         } else {
1200             printf("<method name=\"%s\"\n", name);
1201
1202             const char* returnType = strrchr(typeDescriptor, ')');
1203             if (returnType == NULL) {
1204                 fprintf(stderr, "bad method type descriptor '%s'\n",
1205                     typeDescriptor);
1206                 goto bail;
1207             }
1208
1209             char* tmp = descriptorToDot(returnType+1);
1210             printf(" return=\"%s\"\n", tmp);
1211             free(tmp);
1212
1213             printf(" abstract=%s\n",
1214                 quotedBool((pDexMethod->accessFlags & ACC_ABSTRACT) != 0));
1215             printf(" native=%s\n",
1216                 quotedBool((pDexMethod->accessFlags & ACC_NATIVE) != 0));
1217
1218             bool isSync =
1219                 (pDexMethod->accessFlags & ACC_SYNCHRONIZED) != 0 ||
1220                 (pDexMethod->accessFlags & ACC_DECLARED_SYNCHRONIZED) != 0;
1221             printf(" synchronized=%s\n", quotedBool(isSync));
1222         }
1223
1224         printf(" static=%s\n",
1225             quotedBool((pDexMethod->accessFlags & ACC_STATIC) != 0));
1226         printf(" final=%s\n",
1227             quotedBool((pDexMethod->accessFlags & ACC_FINAL) != 0));
1228         // "deprecated=" not knowable w/o parsing annotations
1229         printf(" visibility=%s\n",
1230             quotedVisibility(pDexMethod->accessFlags));
1231
1232         printf(">\n");
1233
1234         /*
1235          * Parameters.
1236          */
1237         if (typeDescriptor[0] != '(') {
1238             fprintf(stderr, "ERROR: bad descriptor '%s'\n", typeDescriptor);
1239             goto bail;
1240         }
1241
1242         char tmpBuf[strlen(typeDescriptor)+1];      /* more than big enough */
1243         int argNum = 0;
1244
1245         const char* base = typeDescriptor+1;
1246
1247         while (*base != ')') {
1248             char* cp = tmpBuf;
1249
1250             while (*base == '[')
1251                 *cp++ = *base++;
1252
1253             if (*base == 'L') {
1254                 /* copy through ';' */
1255                 do {
1256                     *cp = *base++;
1257                 } while (*cp++ != ';');
1258             } else {
1259                 /* primitive char, copy it */
1260                 if (strchr("ZBCSIFJD", *base) == NULL) {
1261                     fprintf(stderr, "ERROR: bad method signature '%s'\n", base);
1262                     goto bail;
1263                 }
1264                 *cp++ = *base++;
1265             }
1266
1267             /* null terminate and display */
1268             *cp++ = '\0';
1269
1270             char* tmp = descriptorToDot(tmpBuf);
1271             printf("<parameter name=\"arg%d\" type=\"%s\">\n</parameter>\n",
1272                 argNum++, tmp);
1273             free(tmp);
1274         }
1275
1276         if (constructor)
1277             printf("</constructor>\n");
1278         else
1279             printf("</method>\n");
1280     }
1281
1282 bail:
1283     free(typeDescriptor);
1284     free(accessStr);
1285 }
1286
1287 /*
1288  * Dump a static (class) field.
1289  */
1290 void dumpSField(const DexFile* pDexFile, const DexField* pSField, int i)
1291 {
1292     const DexFieldId* pFieldId;
1293     const char* backDescriptor;
1294     const char* name;
1295     const char* typeDescriptor;
1296     char* accessStr;
1297
1298     if (gOptions.exportsOnly &&
1299         (pSField->accessFlags & (ACC_PUBLIC | ACC_PROTECTED)) == 0)
1300     {
1301         return;
1302     }
1303
1304     pFieldId = dexGetFieldId(pDexFile, pSField->fieldIdx);
1305     name = dexStringById(pDexFile, pFieldId->nameIdx);
1306     typeDescriptor = dexStringByTypeIdx(pDexFile, pFieldId->typeIdx);
1307     backDescriptor = dexStringByTypeIdx(pDexFile, pFieldId->classIdx);
1308
1309     accessStr = createAccessFlagStr(pSField->accessFlags, kAccessForField);
1310
1311     if (gOptions.outputFormat == OUTPUT_PLAIN) {
1312         printf("    #%d              : (in %s)\n", i, backDescriptor);
1313         printf("      name          : '%s'\n", name);
1314         printf("      type          : '%s'\n", typeDescriptor);
1315         printf("      access        : 0x%04x (%s)\n",
1316             pSField->accessFlags, accessStr);
1317     } else if (gOptions.outputFormat == OUTPUT_XML) {
1318         char* tmp;
1319
1320         printf("<field name=\"%s\"\n", name);
1321
1322         tmp = descriptorToDot(typeDescriptor);
1323         printf(" type=\"%s\"\n", tmp);
1324         free(tmp);
1325
1326         printf(" transient=%s\n",
1327             quotedBool((pSField->accessFlags & ACC_TRANSIENT) != 0));
1328         printf(" volatile=%s\n",
1329             quotedBool((pSField->accessFlags & ACC_VOLATILE) != 0));
1330         // "value=" not knowable w/o parsing annotations
1331         printf(" static=%s\n",
1332             quotedBool((pSField->accessFlags & ACC_STATIC) != 0));
1333         printf(" final=%s\n",
1334             quotedBool((pSField->accessFlags & ACC_FINAL) != 0));
1335         // "deprecated=" not knowable w/o parsing annotations
1336         printf(" visibility=%s\n",
1337             quotedVisibility(pSField->accessFlags));
1338         printf(">\n</field>\n");
1339     }
1340
1341     free(accessStr);
1342 }
1343
1344 /*
1345  * Dump an instance field.
1346  */
1347 void dumpIField(const DexFile* pDexFile, const DexField* pIField, int i)
1348 {
1349     dumpSField(pDexFile, pIField, i);
1350 }
1351
1352 /*
1353  * Dump the class.
1354  *
1355  * Note "idx" is a DexClassDef index, not a DexTypeId index.
1356  *
1357  * If "*pLastPackage" is NULL or does not match the current class' package,
1358  * the value will be replaced with a newly-allocated string.
1359  */
1360 void dumpClass(DexFile* pDexFile, int idx, char** pLastPackage)
1361 {
1362     const DexTypeList* pInterfaces;
1363     const DexClassDef* pClassDef;
1364     DexClassData* pClassData = NULL;
1365     const u1* pEncodedData;
1366     const char* fileName;
1367     const char* classDescriptor;
1368     const char* superclassDescriptor;
1369     char* accessStr = NULL;
1370     int i;
1371
1372     pClassDef = dexGetClassDef(pDexFile, idx);
1373
1374     if (gOptions.exportsOnly && (pClassDef->accessFlags & ACC_PUBLIC) == 0) {
1375         //printf("<!-- omitting non-public class %s -->\n",
1376         //    classDescriptor);
1377         goto bail;
1378     }
1379
1380     pEncodedData = dexGetClassData(pDexFile, pClassDef);
1381     pClassData = dexReadAndVerifyClassData(&pEncodedData, NULL);
1382
1383     if (pClassData == NULL) {
1384         printf("Trouble reading class data (#%d)\n", idx);
1385         goto bail;
1386     }
1387
1388     classDescriptor = dexStringByTypeIdx(pDexFile, pClassDef->classIdx);
1389
1390     /*
1391      * For the XML output, show the package name.  Ideally we'd gather
1392      * up the classes, sort them, and dump them alphabetically so the
1393      * package name wouldn't jump around, but that's not a great plan
1394      * for something that needs to run on the device.
1395      */
1396     if (!(classDescriptor[0] == 'L' &&
1397           classDescriptor[strlen(classDescriptor)-1] == ';'))
1398     {
1399         /* arrays and primitives should not be defined explicitly */
1400         fprintf(stderr, "Malformed class name '%s'\n", classDescriptor);
1401         /* keep going? */
1402     } else if (gOptions.outputFormat == OUTPUT_XML) {
1403         char* mangle;
1404         char* lastSlash;
1405         char* cp;
1406
1407         mangle = strdup(classDescriptor + 1);
1408         mangle[strlen(mangle)-1] = '\0';
1409
1410         /* reduce to just the package name */
1411         lastSlash = strrchr(mangle, '/');
1412         if (lastSlash != NULL) {
1413             *lastSlash = '\0';
1414         } else {
1415             *mangle = '\0';
1416         }
1417
1418         for (cp = mangle; *cp != '\0'; cp++) {
1419             if (*cp == '/')
1420                 *cp = '.';
1421         }
1422
1423         if (*pLastPackage == NULL || strcmp(mangle, *pLastPackage) != 0) {
1424             /* start of a new package */
1425             if (*pLastPackage != NULL)
1426                 printf("</package>\n");
1427             printf("<package name=\"%s\"\n>\n", mangle);
1428             free(*pLastPackage);
1429             *pLastPackage = mangle;
1430         } else {
1431             free(mangle);
1432         }
1433     }
1434
1435     accessStr = createAccessFlagStr(pClassDef->accessFlags, kAccessForClass);
1436
1437     if (pClassDef->superclassIdx == kDexNoIndex) {
1438         superclassDescriptor = NULL;
1439     } else {
1440         superclassDescriptor =
1441             dexStringByTypeIdx(pDexFile, pClassDef->superclassIdx);
1442     }
1443
1444     if (gOptions.outputFormat == OUTPUT_PLAIN) {
1445         printf("Class #%d            -\n", idx);
1446         printf("  Class descriptor  : '%s'\n", classDescriptor);
1447         printf("  Access flags      : 0x%04x (%s)\n",
1448             pClassDef->accessFlags, accessStr);
1449
1450         if (superclassDescriptor != NULL)
1451             printf("  Superclass        : '%s'\n", superclassDescriptor);
1452
1453         printf("  Interfaces        -\n");
1454     } else {
1455         char* tmp;
1456
1457         tmp = descriptorClassToDot(classDescriptor);
1458         printf("<class name=\"%s\"\n", tmp);
1459         free(tmp);
1460
1461         if (superclassDescriptor != NULL) {
1462             tmp = descriptorToDot(superclassDescriptor);
1463             printf(" extends=\"%s\"\n", tmp);
1464             free(tmp);
1465         }
1466         printf(" abstract=%s\n",
1467             quotedBool((pClassDef->accessFlags & ACC_ABSTRACT) != 0));
1468         printf(" static=%s\n",
1469             quotedBool((pClassDef->accessFlags & ACC_STATIC) != 0));
1470         printf(" final=%s\n",
1471             quotedBool((pClassDef->accessFlags & ACC_FINAL) != 0));
1472         // "deprecated=" not knowable w/o parsing annotations
1473         printf(" visibility=%s\n",
1474             quotedVisibility(pClassDef->accessFlags));
1475         printf(">\n");
1476     }
1477     pInterfaces = dexGetInterfacesList(pDexFile, pClassDef);
1478     if (pInterfaces != NULL) {
1479         for (i = 0; i < (int) pInterfaces->size; i++)
1480             dumpInterface(pDexFile, dexGetTypeItem(pInterfaces, i), i);
1481     }
1482
1483     if (gOptions.outputFormat == OUTPUT_PLAIN)
1484         printf("  Static fields     -\n");
1485     for (i = 0; i < (int) pClassData->header.staticFieldsSize; i++) {
1486         dumpSField(pDexFile, &pClassData->staticFields[i], i);
1487     }
1488
1489     if (gOptions.outputFormat == OUTPUT_PLAIN)
1490         printf("  Instance fields   -\n");
1491     for (i = 0; i < (int) pClassData->header.instanceFieldsSize; i++) {
1492         dumpIField(pDexFile, &pClassData->instanceFields[i], i);
1493     }
1494
1495     if (gOptions.outputFormat == OUTPUT_PLAIN)
1496         printf("  Direct methods    -\n");
1497     for (i = 0; i < (int) pClassData->header.directMethodsSize; i++) {
1498         dumpMethod(pDexFile, &pClassData->directMethods[i], i);
1499     }
1500
1501     if (gOptions.outputFormat == OUTPUT_PLAIN)
1502         printf("  Virtual methods   -\n");
1503     for (i = 0; i < (int) pClassData->header.virtualMethodsSize; i++) {
1504         dumpMethod(pDexFile, &pClassData->virtualMethods[i], i);
1505     }
1506
1507     // TODO: Annotations.
1508
1509     if (pClassDef->sourceFileIdx != kDexNoIndex)
1510         fileName = dexStringById(pDexFile, pClassDef->sourceFileIdx);
1511     else
1512         fileName = "unknown";
1513
1514     if (gOptions.outputFormat == OUTPUT_PLAIN) {
1515         printf("  source_file_idx   : %d (%s)\n",
1516             pClassDef->sourceFileIdx, fileName);
1517         printf("\n");
1518     }
1519
1520     if (gOptions.outputFormat == OUTPUT_XML) {
1521         printf("</class>\n");
1522     }
1523
1524 bail:
1525     free(pClassData);
1526     free(accessStr);
1527 }
1528
1529
1530 /*
1531  * Advance "ptr" to ensure 32-bit alignment.
1532  */
1533 static inline const u1* align32(const u1* ptr)
1534 {
1535     return (u1*) (((uintptr_t) ptr + 3) & ~0x03);
1536 }
1537
1538
1539 /*
1540  * Dump a map in the "differential" format.
1541  *
1542  * TODO: show a hex dump of the compressed data.  (We can show the
1543  * uncompressed data if we move the compression code to libdex; otherwise
1544  * it's too complex to merit a fast & fragile implementation here.)
1545  */
1546 void dumpDifferentialCompressedMap(const u1** pData)
1547 {
1548     const u1* data = *pData;
1549     const u1* dataStart = data -1;      // format byte already removed
1550     u1 regWidth;
1551     u2 numEntries;
1552
1553     /* standard header */
1554     regWidth = *data++;
1555     numEntries = *data++;
1556     numEntries |= (*data++) << 8;
1557
1558     /* compressed data begins with the compressed data length */
1559     int compressedLen = readUnsignedLeb128(&data);
1560     int addrWidth = 1;
1561     if ((*data & 0x80) != 0)
1562         addrWidth++;
1563
1564     int origLen = 4 + (addrWidth + regWidth) * numEntries;
1565     int compLen = (data - dataStart) + compressedLen;
1566
1567     printf("        (differential compression %d -> %d [%d -> %d])\n",
1568         origLen, compLen,
1569         (addrWidth + regWidth) * numEntries, compressedLen);
1570
1571     /* skip past end of entry */
1572     data += compressedLen;
1573
1574     *pData = data;
1575 }
1576
1577 /*
1578  * Dump register map contents of the current method.
1579  *
1580  * "*pData" should point to the start of the register map data.  Advances
1581  * "*pData" to the start of the next map.
1582  */
1583 void dumpMethodMap(DexFile* pDexFile, const DexMethod* pDexMethod, int idx,
1584     const u1** pData)
1585 {
1586     const u1* data = *pData;
1587     const DexMethodId* pMethodId;
1588     const char* name;
1589     int offset = data - (u1*) pDexFile->pOptHeader;
1590
1591     pMethodId = dexGetMethodId(pDexFile, pDexMethod->methodIdx);
1592     name = dexStringById(pDexFile, pMethodId->nameIdx);
1593     printf("      #%d: 0x%08x %s\n", idx, offset, name);
1594
1595     u1 format;
1596     int addrWidth;
1597
1598     format = *data++;
1599     if (format == 1) {              /* kRegMapFormatNone */
1600         /* no map */
1601         printf("        (no map)\n");
1602         addrWidth = 0;
1603     } else if (format == 2) {       /* kRegMapFormatCompact8 */
1604         addrWidth = 1;
1605     } else if (format == 3) {       /* kRegMapFormatCompact16 */
1606         addrWidth = 2;
1607     } else if (format == 4) {       /* kRegMapFormatDifferential */
1608         dumpDifferentialCompressedMap(&data);
1609         goto bail;
1610     } else {
1611         printf("        (unknown format %d!)\n", format);
1612         /* don't know how to skip data; failure will cascade to end of class */
1613         goto bail;
1614     }
1615
1616     if (addrWidth > 0) {
1617         u1 regWidth;
1618         u2 numEntries;
1619         int idx, addr, byte;
1620
1621         regWidth = *data++;
1622         numEntries = *data++;
1623         numEntries |= (*data++) << 8;
1624
1625         for (idx = 0; idx < numEntries; idx++) {
1626             addr = *data++;
1627             if (addrWidth > 1)
1628                 addr |= (*data++) << 8;
1629
1630             printf("        %4x:", addr);
1631             for (byte = 0; byte < regWidth; byte++) {
1632                 printf(" %02x", *data++);
1633             }
1634             printf("\n");
1635         }
1636     }
1637
1638 bail:
1639     //if (addrWidth >= 0)
1640     //    *pData = align32(data);
1641     *pData = data;
1642 }
1643
1644 /*
1645  * Dump the contents of the register map area.
1646  *
1647  * These are only present in optimized DEX files, and the structure is
1648  * not really exposed to other parts of the VM itself.  We're going to
1649  * dig through them here, but this is pretty fragile.  DO NOT rely on
1650  * this or derive other code from it.
1651  */
1652 void dumpRegisterMaps(DexFile* pDexFile)
1653 {
1654     const u1* pClassPool = (const u1*)pDexFile->pRegisterMapPool;
1655     const u4* classOffsets;
1656     const u1* ptr;
1657     u4 numClasses;
1658     int baseFileOffset = (u1*) pClassPool - (u1*) pDexFile->pOptHeader;
1659     int idx;
1660
1661     if (pClassPool == NULL) {
1662         printf("No register maps found\n");
1663         return;
1664     }
1665
1666     ptr = pClassPool;
1667     numClasses = get4LE(ptr);
1668     ptr += sizeof(u4);
1669     classOffsets = (const u4*) ptr;
1670
1671     printf("RMAP begins at offset 0x%07x\n", baseFileOffset);
1672     printf("Maps for %d classes\n", numClasses);
1673     for (idx = 0; idx < (int) numClasses; idx++) {
1674         const DexClassDef* pClassDef;
1675         const char* classDescriptor;
1676
1677         pClassDef = dexGetClassDef(pDexFile, idx);
1678         classDescriptor = dexStringByTypeIdx(pDexFile, pClassDef->classIdx);
1679
1680         printf("%4d: +%d (0x%08x) %s\n", idx, classOffsets[idx],
1681             baseFileOffset + classOffsets[idx], classDescriptor);
1682
1683         if (classOffsets[idx] == 0)
1684             continue;
1685
1686         /*
1687          * What follows is a series of RegisterMap entries, one for every
1688          * direct method, then one for every virtual method.
1689          */
1690         DexClassData* pClassData;
1691         const u1* pEncodedData;
1692         const u1* data = (u1*) pClassPool + classOffsets[idx];
1693         u2 methodCount;
1694         int i;
1695
1696         pEncodedData = dexGetClassData(pDexFile, pClassDef);
1697         pClassData = dexReadAndVerifyClassData(&pEncodedData, NULL);
1698         if (pClassData == NULL) {
1699             fprintf(stderr, "Trouble reading class data\n");
1700             continue;
1701         }
1702
1703         methodCount = *data++;
1704         methodCount |= (*data++) << 8;
1705         data += 2;      /* two pad bytes follow methodCount */
1706         if (methodCount != pClassData->header.directMethodsSize
1707                             + pClassData->header.virtualMethodsSize)
1708         {
1709             printf("NOTE: method count discrepancy (%d != %d + %d)\n",
1710                 methodCount, pClassData->header.directMethodsSize,
1711                 pClassData->header.virtualMethodsSize);
1712             /* this is bad, but keep going anyway */
1713         }
1714
1715         printf("    direct methods: %d\n",
1716             pClassData->header.directMethodsSize);
1717         for (i = 0; i < (int) pClassData->header.directMethodsSize; i++) {
1718             dumpMethodMap(pDexFile, &pClassData->directMethods[i], i, &data);
1719         }
1720
1721         printf("    virtual methods: %d\n",
1722             pClassData->header.virtualMethodsSize);
1723         for (i = 0; i < (int) pClassData->header.virtualMethodsSize; i++) {
1724             dumpMethodMap(pDexFile, &pClassData->virtualMethods[i], i, &data);
1725         }
1726
1727         free(pClassData);
1728     }
1729 }
1730
1731 /*
1732  * Dump the requested sections of the file.
1733  */
1734 void processDexFile(const char* fileName, DexFile* pDexFile)
1735 {
1736     char* package = NULL;
1737     int i;
1738
1739     if (gOptions.verbose) {
1740         printf("Opened '%s', DEX version '%.3s'\n", fileName,
1741             pDexFile->pHeader->magic +4);
1742     }
1743
1744     if (gOptions.dumpRegisterMaps) {
1745         dumpRegisterMaps(pDexFile);
1746         return;
1747     }
1748
1749     if (gOptions.showFileHeaders) {
1750         dumpFileHeader(pDexFile);
1751         dumpOptDirectory(pDexFile);
1752     }
1753
1754     if (gOptions.outputFormat == OUTPUT_XML)
1755         printf("<api>\n");
1756
1757     for (i = 0; i < (int) pDexFile->pHeader->classDefsSize; i++) {
1758         if (gOptions.showSectionHeaders)
1759             dumpClassDef(pDexFile, i);
1760
1761         dumpClass(pDexFile, i, &package);
1762     }
1763
1764     /* free the last one allocated */
1765     if (package != NULL) {
1766         printf("</package>\n");
1767         free(package);
1768     }
1769
1770     if (gOptions.outputFormat == OUTPUT_XML)
1771         printf("</api>\n");
1772 }
1773
1774
1775 /*
1776  * Process one file.
1777  */
1778 int process(const char* fileName)
1779 {
1780     DexFile* pDexFile = NULL;
1781     MemMapping map;
1782     bool mapped = false;
1783     int result = -1;
1784
1785     if (gOptions.verbose)
1786         printf("Processing '%s'...\n", fileName);
1787
1788     if (dexOpenAndMap(fileName, gOptions.tempFileName, &map, false) != 0) {
1789         return result;
1790     }
1791     mapped = true;
1792
1793     int flags = kDexParseVerifyChecksum;
1794     if (gOptions.ignoreBadChecksum)
1795         flags |= kDexParseContinueOnError;
1796
1797     pDexFile = dexFileParse((u1*)map.addr, map.length, flags);
1798     if (pDexFile == NULL) {
1799         fprintf(stderr, "ERROR: DEX parse failed\n");
1800         goto bail;
1801     }
1802
1803     if (gOptions.checksumOnly) {
1804         printf("Checksum verified\n");
1805     } else {
1806         processDexFile(fileName, pDexFile);
1807     }
1808
1809     result = 0;
1810
1811 bail:
1812     if (mapped)
1813         sysReleaseShmem(&map);
1814     if (pDexFile != NULL)
1815         dexFileFree(pDexFile);
1816     return result;
1817 }
1818
1819
1820 /*
1821  * Show usage.
1822  */
1823 void usage(void)
1824 {
1825     fprintf(stderr, "Copyright (C) 2007 The Android Open Source Project\n\n");
1826     fprintf(stderr,
1827         "%s: [-c] [-d] [-f] [-h] [-i] [-l layout] [-m] [-t tempfile] dexfile...\n",
1828         gProgName);
1829     fprintf(stderr, "\n");
1830     fprintf(stderr, " -c : verify checksum and exit\n");
1831     fprintf(stderr, " -d : disassemble code sections\n");
1832     fprintf(stderr, " -f : display summary information from file header\n");
1833     fprintf(stderr, " -h : display file header details\n");
1834     fprintf(stderr, " -i : ignore checksum failures\n");
1835     fprintf(stderr, " -l : output layout, either 'plain' or 'xml'\n");
1836     fprintf(stderr, " -m : dump register maps (and nothing else)\n");
1837     fprintf(stderr, " -t : temp file name (defaults to /sdcard/dex-temp-*)\n");
1838 }
1839
1840 /*
1841  * Parse args.
1842  *
1843  * I'm not using getopt_long() because we may not have it in libc.
1844  */
1845 int main(int argc, char* const argv[])
1846 {
1847     bool wantUsage = false;
1848     int ic;
1849
1850     memset(&gOptions, 0, sizeof(gOptions));
1851     gOptions.verbose = true;
1852
1853     while (1) {
1854         ic = getopt(argc, argv, "cdfhil:mt:");
1855         if (ic < 0)
1856             break;
1857
1858         switch (ic) {
1859         case 'c':       // verify the checksum then exit
1860             gOptions.checksumOnly = true;
1861             break;
1862         case 'd':       // disassemble Dalvik instructions
1863             gOptions.disassemble = true;
1864             break;
1865         case 'f':       // dump outer file header
1866             gOptions.showFileHeaders = true;
1867             break;
1868         case 'h':       // dump section headers, i.e. all meta-data
1869             gOptions.showSectionHeaders = true;
1870             break;
1871         case 'i':       // continue even if checksum is bad
1872             gOptions.ignoreBadChecksum = true;
1873             break;
1874         case 'l':       // layout
1875             if (strcmp(optarg, "plain") == 0) {
1876                 gOptions.outputFormat = OUTPUT_PLAIN;
1877             } else if (strcmp(optarg, "xml") == 0) {
1878                 gOptions.outputFormat = OUTPUT_XML;
1879                 gOptions.verbose = false;
1880                 gOptions.exportsOnly = true;
1881             } else {
1882                 wantUsage = true;
1883             }
1884             break;
1885         case 'm':       // dump register maps only
1886             gOptions.dumpRegisterMaps = true;
1887             break;
1888         case 't':       // temp file, used when opening compressed Jar
1889             gOptions.tempFileName = optarg;
1890             break;
1891         default:
1892             wantUsage = true;
1893             break;
1894         }
1895     }
1896
1897     if (optind == argc) {
1898         fprintf(stderr, "%s: no file specified\n", gProgName);
1899         wantUsage = true;
1900     }
1901
1902     if (gOptions.checksumOnly && gOptions.ignoreBadChecksum) {
1903         fprintf(stderr, "Can't specify both -c and -i\n");
1904         wantUsage = true;
1905     }
1906
1907     if (wantUsage) {
1908         usage();
1909         return 2;
1910     }
1911
1912     int result = 0;
1913     while (optind < argc) {
1914         result |= process(argv[optind++]);
1915     }
1916
1917     return (result != 0);
1918 }