[Zucchini] Add DEX Reference read / write for basic types.

(Committing on behalf of etiennep@).

This CL adds DEX References read / write for 11 basic types. Details:
- Add InstructionParser to visit DEX instructions in the insns member
  of a CodeItem, taking care to skip non-instruction "payloads".
- Add InstructionReferenceReader to visit CodeItem References found in
  |[lo, hi)|, using provided callbacks to apply type filters and
  extract targets.
- Add ItemReferenceReader to visit fixed-sized items to extract
  Referenes from a "member variable of interest", using a callback
  to extract targets.
- DisassemblerDex: Add MakeRead*() and MakeWrite*() to return a visitor
  to read / write supported DEX References.
- Add DEX unit test to audit the error-prone look-up table from
  DisassemblerDex::MakeReferenceGroups().

Change-Id: Ice12a867aab4fdcb4a152bb1946ea7515ad426ef
Reviewed-on: https://chromium-review.googlesource.com/994066
Reviewed-by: Samuel Huang <huangs@chromium.org>
Reviewed-by: Yaron Friedman <yfriedman@chromium.org>
Commit-Queue: Samuel Huang <huangs@chromium.org>
Cr-Commit-Position: refs/heads/master@{#549178}
NOKEYCHECK=True
GitOrigin-RevId: 7b249ec48aa0f1058496a1b7f095b0f126011bf6

1 files changed, 88 insertions, 0 deletions

diff --git a/disassembler_dex.h b/disassembler_dex.h
index 7bbe5d1..3032d14 100644
--- a/disassembler_dex.h
+++ b/disassembler_dex.h
@@ -8,6 +8,7 @@
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -24,6 +25,56 @@ namespace zucchini {
 
 class DisassemblerDex : public Disassembler {
  public:
+  // Pools follow canonical order.
+  enum ReferencePool : uint8_t {
+    kStringId,
+    kTypeId,
+    kProtoId,
+    kFieldId,
+    kMethodId,
+    kClassDef,
+    kTypeList,
+    kCode,
+    kStringData,
+    kNumPools
+  };
+
+  // Types are grouped and ordered by target ReferencePool. This is required by
+  // Zucchini-apply, which visits references by type order and sequentially
+  // handles pools in the same order. Type-pool association is established in
+  // MakeReferenceGroups(), and verified by a unit test.
+  enum ReferenceType : uint8_t {
+    kFieldIdToNameStringId,  // kStringId
+    kCodeToStringId16,
+    kCodeToStringId32,
+
+    kFieldIdToClassTypeId,  // kTypeId
+    kFieldIdToTypeId,
+    kCodeToTypeId,
+
+    kCodeToFieldId,  // kFieldId
+
+    kCodeToMethodId,  // kMethodId
+
+    kCodeToRelCode16,  // kCode
+    kCodeToRelCode32,
+
+    kStringIdToStringData,  // kStringData
+
+    // TODO(ckitagawa): Extract the following kinds of pointers.
+    // kProtoToShortyStringId,
+    // kProtoToReturnTypeId,
+    // kProtoToParamsTypeList,
+    // kMethodToClassTypeId,
+    // kMethodToProtoId,
+    // kMethodToNameStringId,
+    // kTypeListToTypeId,
+    // kClassDefToClassTypeId,
+    // kClassDefToSuperclassTypeId,
+    // kClassDefToInterfaceTypeList,
+    kNumTypes
+  };
+
   DisassemblerDex();
   ~DisassemblerDex() override;
 
@@ -36,6 +87,43 @@ class DisassemblerDex : public Disassembler {
   std::string GetExeTypeString() const override;
   std::vector<ReferenceGroup> MakeReferenceGroups() const override;
 
+  // Functions that return reference readers. These follow canonical order of
+  // *locations* (unlike targets for ReferenceType). This allows functions with
+  // similar parsing logic to appear togeter.
+  std::unique_ptr<ReferenceReader> MakeReadStringIdToStringData(offset_t lo,
+                                                                offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadFieldToClassTypeId16(offset_t lo,
+                                                                offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadFieldToTypeId16(offset_t lo,
+                                                           offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadFieldToNameStringId32(offset_t lo,
+                                                                 offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToStringId16(offset_t lo,
+                                                            offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToStringId32(offset_t lo,
+                                                            offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToTypeId16(offset_t lo,
+                                                          offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToFieldId16(offset_t lo,
+                                                           offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToMethodId16(offset_t lo,
+                                                            offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode16(offset_t lo,
+                                                           offset_t hi);
+  std::unique_ptr<ReferenceReader> MakeReadCodeToRelCode32(offset_t lo,
+                                                           offset_t hi);
+
+  // Functions that return reference writers. Different readers may share a
+  // common writer. Therefore these loosely follow canonical order of locations,
+  std::unique_ptr<ReferenceWriter> MakeWriteStringId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteStringId32(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteTypeId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteFieldId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteMethodId16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteRelCode16(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteRelCode32(MutableBufferView image);
+  std::unique_ptr<ReferenceWriter> MakeWriteAbs32(MutableBufferView image);
+
  private:
   friend Disassembler;
   using MapItemMap = std::map<uint16_t, const dex::MapItem*>;