disassembler_dex.cc 79 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892
  1. // Copyright 2018 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/zucchini/disassembler_dex.h"
  5. #include <stddef.h>
  6. #include <stdlib.h>
  7. #include <algorithm>
  8. #include <cctype>
  9. #include <cmath>
  10. #include <iterator>
  11. #include <set>
  12. #include <utility>
  13. #include "base/bind.h"
  14. #include "base/callback.h"
  15. #include "base/logging.h"
  16. #include "base/memory/raw_ptr.h"
  17. #include "base/numerics/checked_math.h"
  18. #include "base/numerics/safe_conversions.h"
  19. #include "base/strings/stringprintf.h"
  20. #include "components/zucchini/buffer_source.h"
  21. #include "components/zucchini/buffer_view.h"
  22. #include "components/zucchini/io_utils.h"
  23. #include "third_party/abseil-cpp/absl/types/optional.h"
  24. namespace zucchini {
  25. namespace {
  26. // A DEX item specified by an offset, if absent, has a sentinel value of 0 since
  27. // 0 is never a valid item offset (it points to magic at start of DEX).
  28. constexpr offset_t kDexSentinelOffset = 0U;
  29. // A DEX item specified by an index, if absent, has a sentinel value of
  30. // NO_INDEX = 0xFFFFFFFF. This is represented as an offset_t for uniformity.
  31. constexpr offset_t kDexSentinelIndexAsOffset = 0xFFFFFFFFU;
  32. static_assert(kDexSentinelIndexAsOffset != kInvalidOffset,
  33. "Sentinel should not be confused with invalid offset.");
  34. // Size of a Dalvik instruction unit. Need to cast to signed int because
  35. // sizeof() gives size_t, which dominates when operated on ptrdiff_t, then
  36. // wrecks havoc for base::checked_cast<int16_t>().
  37. constexpr int kInstrUnitSize = static_cast<int>(sizeof(uint16_t));
  38. // Checks if |offset| is byte aligned to 32 bits or 4 bytes.
  39. bool Is32BitAligned(offset_t offset) {
  40. return offset % 4 == 0;
  41. }
  42. // Returns a lower bound for the size of an item of type |type_item_code|.
  43. // - For fixed-length items (e.g., kTypeFieldIdItem) this is the exact size.
  44. // - For variant-length items (e.g., kTypeCodeItem), returns a value that is
  45. // known to be less than the item length (e.g., header size).
  46. // - For items not handled by this function, returns 1 for sanity check.
  47. size_t GetItemBaseSize(uint16_t type_item_code) {
  48. switch (type_item_code) {
  49. case dex::kTypeStringIdItem:
  50. return sizeof(dex::StringIdItem);
  51. case dex::kTypeTypeIdItem:
  52. return sizeof(dex::TypeIdItem);
  53. case dex::kTypeProtoIdItem:
  54. return sizeof(dex::ProtoIdItem);
  55. case dex::kTypeFieldIdItem:
  56. return sizeof(dex::FieldIdItem);
  57. case dex::kTypeMethodIdItem:
  58. return sizeof(dex::MethodIdItem);
  59. case dex::kTypeClassDefItem:
  60. return sizeof(dex::ClassDefItem);
  61. case dex::kTypeCallSiteIdItem:
  62. return sizeof(dex::CallSiteIdItem);
  63. case dex::kTypeMethodHandleItem:
  64. return sizeof(dex::MethodHandleItem);
  65. // No need to handle dex::kTypeMapList.
  66. case dex::kTypeTypeList:
  67. return sizeof(uint32_t); // Variable-length.
  68. case dex::kTypeAnnotationSetRefList:
  69. return sizeof(uint32_t); // Variable-length.
  70. case dex::kTypeAnnotationSetItem:
  71. return sizeof(uint32_t); // Variable-length.
  72. case dex::kTypeCodeItem:
  73. return sizeof(dex::CodeItem); // Variable-length.
  74. case dex::kTypeAnnotationsDirectoryItem:
  75. return sizeof(dex::AnnotationsDirectoryItem); // Variable-length.
  76. default:
  77. return 1U; // Unhandled item. For sanity check assume size >= 1.
  78. }
  79. }
  80. /******** CodeItemParser ********/
  81. // A parser to extract successive code items from a DEX image whose header has
  82. // been parsed.
  83. class CodeItemParser {
  84. public:
  85. using size_type = BufferSource::size_type;
  86. explicit CodeItemParser(ConstBufferView image) : image_(image) {}
  87. // Initializes the parser, returns true on success and false on error.
  88. bool Init(const dex::MapItem& code_map_item) {
  89. // Sanity check to quickly fail if |code_map_item.offset| or
  90. // |code_map_item.size| is too large. This is a heuristic because code item
  91. // sizes need to be parsed (sizeof(dex::CodeItem) is a lower bound).
  92. if (!image_.covers_array(code_map_item.offset, code_map_item.size,
  93. sizeof(dex::CodeItem))) {
  94. return false;
  95. }
  96. source_ = std::move(BufferSource(image_).Skip(code_map_item.offset));
  97. return true;
  98. }
  99. // Extracts the header of the next code item, and skips the variable-length
  100. // data. Returns the offset of the code item if successful. Otherwise returns
  101. // kInvalidOffset, and thereafter the parser becomes valid. For reference,
  102. // here's a pseudo-struct of a complete code item:
  103. //
  104. // struct code_item {
  105. // // 4-byte aligned here.
  106. // // 16-byte header defined (dex::CodeItem).
  107. // uint16_t registers_size;
  108. // uint16_t ins_size;
  109. // uint16_t outs_size;
  110. // uint16_t tries_size;
  111. // uint32_t debug_info_off;
  112. // uint32_t insns_size;
  113. //
  114. // // Variable-length data follow.
  115. // uint16_t insns[insns_size]; // Instruction bytes.
  116. // uint16_t padding[(tries_size > 0 && insns_size % 2 == 1) ? 1 : 0];
  117. //
  118. // if (tries_size > 0) {
  119. // // 4-byte aligned here.
  120. // struct try_item { // dex::TryItem.
  121. // uint32_t start_addr;
  122. // uint16_t insn_count;
  123. // uint16_t handler_off;
  124. // } tries[tries_size];
  125. //
  126. // struct encoded_catch_handler_list {
  127. // uleb128 handlers_size;
  128. // struct encoded_catch_handler {
  129. // sleb128 encoded_catch_handler_size;
  130. // struct encoded_type_addr_pair {
  131. // uleb128 type_idx;
  132. // uleb128 addr;
  133. // } handlers[abs(encoded_catch_handler_size)];
  134. // if (encoded_catch_handler_size <= 0) {
  135. // uleb128 catch_all_addr;
  136. // }
  137. // } handlers_list[handlers_size];
  138. // } handlers_group; // Confusingly called "handlers" in DEX doc.
  139. // }
  140. //
  141. // // Padding to 4-bytes align next code_item *only if more exist*.
  142. // }
  143. offset_t GetNext() {
  144. // Read header CodeItem.
  145. if (!source_.AlignOn(image_, 4U))
  146. return kInvalidOffset;
  147. const offset_t code_item_offset =
  148. base::checked_cast<offset_t>(source_.begin() - image_.begin());
  149. const auto* code_item = source_.GetPointer<const dex::CodeItem>();
  150. if (!code_item)
  151. return kInvalidOffset;
  152. DCHECK(Is32BitAligned(code_item_offset));
  153. // TODO(huangs): Fail if |code_item->insns_size == 0| (Constraint A1).
  154. // Skip instruction bytes.
  155. if (!source_.GetArray<uint16_t>(code_item->insns_size))
  156. return kInvalidOffset;
  157. // Skip padding if present.
  158. if (code_item->tries_size > 0 && !source_.AlignOn(image_, 4U))
  159. return kInvalidOffset;
  160. // Skip tries[] and handlers_group to arrive at the next code item. Parsing
  161. // is nontrivial due to use of uleb128 / sleb128.
  162. if (code_item->tries_size > 0) {
  163. // Skip (try_item) tries[].
  164. if (!source_.GetArray<dex::TryItem>(code_item->tries_size))
  165. return kInvalidOffset;
  166. // Skip handlers_group.
  167. uint32_t handlers_size = 0;
  168. if (!source_.GetUleb128(&handlers_size))
  169. return kInvalidOffset;
  170. // Sanity check to quickly reject excessively large |handlers_size|.
  171. if (source_.Remaining() < static_cast<size_type>(handlers_size))
  172. return kInvalidOffset;
  173. // Skip (encoded_catch_handler) handlers_list[].
  174. for (uint32_t k = 0; k < handlers_size; ++k) {
  175. int32_t encoded_catch_handler_size = 0;
  176. if (!source_.GetSleb128(&encoded_catch_handler_size))
  177. return kInvalidOffset;
  178. const size_type abs_size = std::abs(encoded_catch_handler_size);
  179. if (source_.Remaining() < abs_size) // Sanity check.
  180. return kInvalidOffset;
  181. // Skip (encoded_type_addr_pair) handlers[].
  182. for (size_type j = 0; j < abs_size; ++j) {
  183. if (!source_.SkipLeb128() || !source_.SkipLeb128())
  184. return kInvalidOffset;
  185. }
  186. // Skip catch_all_addr.
  187. if (encoded_catch_handler_size <= 0) {
  188. if (!source_.SkipLeb128())
  189. return kInvalidOffset;
  190. }
  191. }
  192. }
  193. // Success! |code_item->insns_size| is validated, but its content is still
  194. // considered unsafe and requires validation.
  195. return code_item_offset;
  196. }
  197. // Given |code_item_offset| that points to the start of a valid code item in
  198. // |image|, returns |insns| bytes as ConstBufferView.
  199. static ConstBufferView GetCodeItemInsns(ConstBufferView image,
  200. offset_t code_item_offset) {
  201. BufferSource source(BufferSource(image).Skip(code_item_offset));
  202. const auto* code_item = source.GetPointer<const dex::CodeItem>();
  203. DCHECK(code_item);
  204. BufferRegion insns{0, code_item->insns_size * kInstrUnitSize};
  205. DCHECK(source.covers(insns));
  206. return source[insns];
  207. }
  208. private:
  209. ConstBufferView image_;
  210. BufferSource source_;
  211. };
  212. /******** InstructionParser ********/
  213. // A class that successively reads |code_item| for Dalvik instructions, which
  214. // are found at |insns|, spanning |insns_size| uint16_t "units". These units
  215. // store instructions followed by optional non-instruction "payload". Finding
  216. // payload boundary requires parsing: On finding an instruction that uses (and
  217. // points to) payload, the boundary is updated.
  218. class InstructionParser {
  219. public:
  220. struct Value {
  221. offset_t instr_offset;
  222. raw_ptr<const dex::Instruction> instr =
  223. nullptr; // null for unknown instructions.
  224. };
  225. // Returns pointer to DEX Instruction data for |opcode|, or null if |opcode|
  226. // is unknown. An internal initialize-on-first-use table is used for fast
  227. // lookup.
  228. const dex::Instruction* FindDalvikInstruction(uint8_t opcode) {
  229. static bool is_init = false;
  230. static const dex::Instruction* instruction_table[256];
  231. if (!is_init) {
  232. is_init = true;
  233. std::fill(std::begin(instruction_table), std::end(instruction_table),
  234. nullptr);
  235. for (const dex::Instruction& instr : dex::kByteCode) {
  236. std::fill(instruction_table + instr.opcode,
  237. instruction_table + instr.opcode + instr.variant, &instr);
  238. }
  239. }
  240. return instruction_table[opcode];
  241. }
  242. InstructionParser() = default;
  243. InstructionParser(ConstBufferView image, offset_t base_offset)
  244. : image_begin_(image.begin()),
  245. insns_(CodeItemParser::GetCodeItemInsns(image, base_offset)),
  246. payload_boundary_(insns_.end()) {}
  247. // Reads the next instruction. On success, makes the data read available via
  248. // value() and returns true. Otherwise (done or found error) returns false.
  249. bool ReadNext() {
  250. // Do not scan past payload boundary.
  251. if (insns_.begin() >= payload_boundary_)
  252. return false;
  253. const offset_t instr_offset =
  254. base::checked_cast<offset_t>(insns_.begin() - image_begin_);
  255. const uint8_t op = insns_.read<uint8_t>(0);
  256. const dex::Instruction* instr = FindDalvikInstruction(op);
  257. // Stop on finding unknown instructions. ODEX files might trigger this.
  258. if (!instr) {
  259. LOG(WARNING) << "Unknown Dalvik instruction detected at "
  260. << AsHex<8>(instr_offset) << ".";
  261. return false;
  262. }
  263. const int instr_length_units = instr->layout;
  264. const size_t instr_length_bytes = instr_length_units * kInstrUnitSize;
  265. if (insns_.size() < instr_length_bytes)
  266. return false;
  267. // Handle instructions with variable-length data payload (31t).
  268. if (instr->opcode == 0x26 || // fill-array-data
  269. instr->opcode == 0x2B || // packed-switch
  270. instr->opcode == 0x2C) { // sparse-switch
  271. const int32_t unsafe_payload_rel_units = insns_.read<int32_t>(2);
  272. // Payload must be in current code item, after current instruction.
  273. if (unsafe_payload_rel_units < instr_length_units ||
  274. static_cast<uint32_t>(unsafe_payload_rel_units) >=
  275. insns_.size() / kInstrUnitSize) {
  276. LOG(WARNING) << "Invalid payload found.";
  277. return false;
  278. }
  279. // Update boundary between instructions and payload.
  280. const ConstBufferView::const_iterator payload_it =
  281. insns_.begin() + unsafe_payload_rel_units * kInstrUnitSize;
  282. payload_boundary_ = std::min(payload_boundary_, payload_it);
  283. }
  284. insns_.remove_prefix(instr_length_bytes);
  285. value_ = {instr_offset, instr};
  286. return true;
  287. }
  288. const Value& value() const { return value_; }
  289. private:
  290. ConstBufferView::const_iterator image_begin_;
  291. ConstBufferView insns_;
  292. ConstBufferView::const_iterator payload_boundary_;
  293. Value value_;
  294. };
  295. /******** InstructionReferenceReader ********/
  296. // A class to visit |code_items|, parse instructions, and emit embedded
  297. // References of a type determined by |filter_| and |mapper_|. Only References
  298. // located in |[lo, hi)| are emitted. |lo| and |hi| are assumed to never
  299. // straddle the body of a Reference.
  300. class InstructionReferenceReader : public ReferenceReader {
  301. public:
  302. // A function that takes a parsed Dalvik instruction and decides whether it
  303. // contains a specific type of Reference. If true, then returns the Reference
  304. // location. Otherwise returns kInvalidOffset.
  305. using Filter =
  306. base::RepeatingCallback<offset_t(const InstructionParser::Value&)>;
  307. // A function that takes Reference location from |filter_| to extract the
  308. // stored target. If valid, returns it. Otherwise returns kInvalidOffset.
  309. using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
  310. InstructionReferenceReader(ConstBufferView image,
  311. offset_t lo,
  312. offset_t hi,
  313. const std::vector<offset_t>& code_item_offsets,
  314. Filter&& filter,
  315. Mapper&& mapper)
  316. : image_(image),
  317. lo_(lo),
  318. hi_(hi),
  319. end_it_(code_item_offsets.end()),
  320. filter_(std::move(filter)),
  321. mapper_(std::move(mapper)) {
  322. const auto begin_it = code_item_offsets.begin();
  323. // Use binary search to find the code item that contains |lo_|.
  324. auto comp = [](offset_t test_offset, offset_t code_item_offset) {
  325. return test_offset < code_item_offset;
  326. };
  327. cur_it_ = std::upper_bound(begin_it, end_it_, lo_, comp);
  328. if (cur_it_ != begin_it)
  329. --cur_it_;
  330. parser_ = InstructionParser(image_, *cur_it_);
  331. }
  332. // ReferenceReader:
  333. absl::optional<Reference> GetNext() override {
  334. while (true) {
  335. while (parser_.ReadNext()) {
  336. const auto& v = parser_.value();
  337. DCHECK_NE(v.instr, nullptr);
  338. if (v.instr_offset >= hi_)
  339. return absl::nullopt;
  340. const offset_t location = filter_.Run(v);
  341. if (location == kInvalidOffset || location < lo_)
  342. continue;
  343. // The general check is |location + reference_width > hi_|. However, by
  344. // assumption |hi_| and |lo_| do not straddle the body of a Reference.
  345. // So |reference_width| is unneeded.
  346. if (location >= hi_)
  347. return absl::nullopt;
  348. offset_t target = mapper_.Run(location);
  349. if (target != kInvalidOffset)
  350. return Reference{location, target};
  351. else
  352. LOG(WARNING) << "Invalid target at " << AsHex<8>(location) << ".";
  353. }
  354. ++cur_it_;
  355. if (cur_it_ == end_it_)
  356. return absl::nullopt;
  357. parser_ = InstructionParser(image_, *cur_it_);
  358. }
  359. }
  360. private:
  361. const ConstBufferView image_;
  362. const offset_t lo_;
  363. const offset_t hi_;
  364. const std::vector<offset_t>::const_iterator end_it_;
  365. const Filter filter_;
  366. const Mapper mapper_;
  367. std::vector<offset_t>::const_iterator cur_it_;
  368. InstructionParser parser_;
  369. };
  370. /******** ItemReferenceReader ********/
  371. // A class to visit fixed-size item elements (determined by |item_size|) and
  372. // emit a "member variable of interest" (MVI, determined by |rel_location| and
  373. // |mapper|) as Reference. Only MVIs lying in |[lo, hi)| are emitted. |lo| and
  374. // |hi| are assumed to never straddle the body of a Reference.
  375. class ItemReferenceReader : public ReferenceReader {
  376. public:
  377. // A function that takes an MVI's location and emit its target offset.
  378. using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
  379. // |item_size| is the size of a fixed-size item. |rel_location| is the
  380. // relative location of MVI from the start of the item containing it.
  381. // |rel_item_offset| is the offset to use relative to |item_offset| in cases
  382. // where a value other than |rel_location| is required. For an example of this
  383. // see ReadMethodHandleFieldOrMethodId.
  384. ItemReferenceReader(offset_t lo,
  385. offset_t hi,
  386. const dex::MapItem& map_item,
  387. size_t item_size,
  388. size_t rel_location,
  389. Mapper&& mapper,
  390. bool mapper_wants_item = false)
  391. : hi_(hi),
  392. item_base_offset_(base::checked_cast<offset_t>(map_item.offset)),
  393. num_items_(base::checked_cast<uint32_t>(map_item.size)),
  394. item_size_(base::checked_cast<uint32_t>(item_size)),
  395. rel_location_(base::checked_cast<uint32_t>(rel_location)),
  396. mapper_input_delta_(
  397. mapper_wants_item ? 0 : base::checked_cast<uint32_t>(rel_location)),
  398. mapper_(std::move(mapper)) {
  399. static_assert(sizeof(decltype(map_item.offset)) <= sizeof(offset_t),
  400. "map_item.offset too large.");
  401. static_assert(sizeof(decltype(map_item.size)) <= sizeof(offset_t),
  402. "map_item.size too large.");
  403. if (!item_base_offset_) {
  404. // Empty item: Assign |cur_idx| to |num_items_| to skip everything.
  405. cur_idx_ = num_items_;
  406. } else if (lo < item_base_offset_) {
  407. cur_idx_ = 0;
  408. } else if (lo < OffsetOfIndex(num_items_)) {
  409. cur_idx_ = (lo - item_base_offset_) / item_size_;
  410. // Fine-tune: Advance if |lo| lies beyond the MVI.
  411. if (lo > OffsetOfIndex(cur_idx_) + rel_location_)
  412. ++cur_idx_;
  413. } else {
  414. cur_idx_ = num_items_;
  415. }
  416. }
  417. // ReferenceReader:
  418. absl::optional<Reference> GetNext() override {
  419. while (cur_idx_ < num_items_) {
  420. const offset_t item_offset = OffsetOfIndex(cur_idx_);
  421. const offset_t location = item_offset + rel_location_;
  422. // The general check is |location + reference_width > hi_|. However, by
  423. // assumption |hi_| and |lo_| do not straddle the body of a Reference. So
  424. // |reference_width| is unneeded.
  425. if (location >= hi_)
  426. break;
  427. // |location == item_offset + mapper_input_delta_| in the majority of
  428. // cases. The exception is when |mapper_| wants an item aligned location
  429. // instead e.g. ReadMethodHandleFieldOrMethodId.
  430. const offset_t target = mapper_.Run(item_offset + mapper_input_delta_);
  431. // kDexSentinelOffset (0) may appear for the following:
  432. // - ProtoIdItem: parameters_off.
  433. // - ClassDefItem: interfaces_off, annotations_off, class_data_off,
  434. // static_values_off.
  435. // - AnnotationsDirectoryItem: class_annotations_off.
  436. // - AnnotationSetRefItem: annotations_off.
  437. // kDexSentinelIndexAsOffset (0xFFFFFFFF) may appear for the following:
  438. // - ClassDefItem: superclass_idx, source_file_idx.
  439. // - MethodHandleItem: |mapper_| uses ReadMethodHandleFieldOrMethodId and
  440. // determines the item at |cur_idx_| is not of the required reference
  441. // type.
  442. if (target == kDexSentinelOffset || target == kDexSentinelIndexAsOffset) {
  443. ++cur_idx_;
  444. continue;
  445. }
  446. if (target == kInvalidOffset) {
  447. LOG(WARNING) << "Invalid item target at " << AsHex<8>(location) << ".";
  448. break;
  449. }
  450. ++cur_idx_;
  451. return Reference{location, target};
  452. }
  453. return absl::nullopt;
  454. }
  455. private:
  456. offset_t OffsetOfIndex(uint32_t idx) {
  457. return base::checked_cast<uint32_t>(item_base_offset_ + idx * item_size_);
  458. }
  459. const offset_t hi_;
  460. const offset_t item_base_offset_;
  461. const uint32_t num_items_;
  462. const uint32_t item_size_;
  463. const uint32_t rel_location_;
  464. const uint32_t mapper_input_delta_;
  465. const Mapper mapper_;
  466. offset_t cur_idx_ = 0;
  467. };
  468. // Parses a flattened jagged list of lists of items that looks like:
  469. // NTTT|NTT|NTTTT|N|NTT...
  470. // where |N| is an uint32_t representing the number of items in each sub-list,
  471. // and "T" is a fixed-size item (|item_width|) of type "T". On success, stores
  472. // the offset of each |T| into |item_offsets|, and returns true. Otherwise
  473. // (e.g., on finding any structural problem) returns false.
  474. bool ParseItemOffsets(ConstBufferView image,
  475. const dex::MapItem& map_item,
  476. size_t item_width,
  477. std::vector<offset_t>* item_offsets) {
  478. // Sanity check: |image| should at least fit |map_item.size| copies of "N".
  479. if (!image.covers_array(map_item.offset, map_item.size, sizeof(uint32_t)))
  480. return false;
  481. BufferSource source = std::move(BufferSource(image).Skip(map_item.offset));
  482. item_offsets->clear();
  483. for (uint32_t i = 0; i < map_item.size; ++i) {
  484. if (!source.AlignOn(image, 4U))
  485. return false;
  486. uint32_t unsafe_size;
  487. if (!source.GetValue<uint32_t>(&unsafe_size))
  488. return false;
  489. DCHECK(Is32BitAligned(
  490. base::checked_cast<offset_t>(source.begin() - image.begin())));
  491. if (!source.covers_array(0, unsafe_size, item_width))
  492. return false;
  493. for (uint32_t j = 0; j < unsafe_size; ++j) {
  494. item_offsets->push_back(
  495. base::checked_cast<offset_t>(source.begin() - image.begin()));
  496. source.Skip(item_width);
  497. }
  498. }
  499. return true;
  500. }
  501. // Parses AnnotationDirectoryItems of the format (using RegEx) "(AF*M*P*)*",
  502. // where:
  503. // A = AnnotationsDirectoryItem (contains class annotation),
  504. // F = FieldAnnotation,
  505. // M = MethodAnnotation,
  506. // P = ParameterAnnotation.
  507. // On success, stores the offsets of each class, field, method and parameter
  508. // annotation for each item into |*_annotation_offsets|. Otherwise on finding
  509. // structural issues returns false.
  510. bool ParseAnnotationsDirectoryItems(
  511. ConstBufferView image,
  512. const dex::MapItem& annotations_directory_map_item,
  513. std::vector<offset_t>* annotations_directory_item_offsets,
  514. std::vector<offset_t>* field_annotation_offsets,
  515. std::vector<offset_t>* method_annotation_offsets,
  516. std::vector<offset_t>* parameter_annotation_offsets) {
  517. // Sanity check: |image| should at least fit
  518. // |annotations_directory_map_item.size| copies of "A".
  519. if (!image.covers_array(annotations_directory_map_item.offset,
  520. annotations_directory_map_item.size,
  521. sizeof(dex::AnnotationsDirectoryItem))) {
  522. return false;
  523. }
  524. BufferSource source = std::move(
  525. BufferSource(image).Skip(annotations_directory_map_item.offset));
  526. annotations_directory_item_offsets->clear();
  527. field_annotation_offsets->clear();
  528. method_annotation_offsets->clear();
  529. parameter_annotation_offsets->clear();
  530. // Helper to process sublists.
  531. auto parse_list = [&source, image](uint32_t unsafe_size, size_t item_width,
  532. std::vector<offset_t>* item_offsets) {
  533. DCHECK(Is32BitAligned(
  534. base::checked_cast<offset_t>(source.begin() - image.begin())));
  535. if (!source.covers_array(0, unsafe_size, item_width))
  536. return false;
  537. item_offsets->reserve(item_offsets->size() + unsafe_size);
  538. for (uint32_t i = 0; i < unsafe_size; ++i) {
  539. item_offsets->push_back(
  540. base::checked_cast<offset_t>(source.begin() - image.begin()));
  541. source.Skip(item_width);
  542. }
  543. return true;
  544. };
  545. annotations_directory_item_offsets->reserve(
  546. annotations_directory_map_item.size);
  547. for (uint32_t i = 0; i < annotations_directory_map_item.size; ++i) {
  548. if (!source.AlignOn(image, 4U))
  549. return false;
  550. // Parse header.
  551. annotations_directory_item_offsets->push_back(
  552. base::checked_cast<offset_t>(source.begin() - image.begin()));
  553. dex::AnnotationsDirectoryItem unsafe_annotations_directory_item;
  554. if (!source.GetValue(&unsafe_annotations_directory_item))
  555. return false;
  556. // Parse sublists.
  557. if (!(parse_list(unsafe_annotations_directory_item.fields_size,
  558. sizeof(dex::FieldAnnotation), field_annotation_offsets) &&
  559. parse_list(unsafe_annotations_directory_item.annotated_methods_size,
  560. sizeof(dex::MethodAnnotation),
  561. method_annotation_offsets) &&
  562. parse_list(
  563. unsafe_annotations_directory_item.annotated_parameters_size,
  564. sizeof(dex::ParameterAnnotation),
  565. parameter_annotation_offsets))) {
  566. return false;
  567. }
  568. }
  569. return true;
  570. }
  571. /******** CachedItemListReferenceReader ********/
  572. // A class that takes sorted |item_offsets|, and emits all member variable of
  573. // interest (MVIs) that fall inside |[lo, hi)|. The MVI of each item has
  574. // location of |rel_location| from item offset, and has target extracted with
  575. // |mapper| (which performs validation). By the "atomicity assumption",
  576. // [|lo, hi)| never cut across an MVI.
  577. class CachedItemListReferenceReader : public ReferenceReader {
  578. public:
  579. // A function that takes an MVI's location and emit its target offset.
  580. using Mapper = base::RepeatingCallback<offset_t(offset_t)>;
  581. CachedItemListReferenceReader(offset_t lo,
  582. offset_t hi,
  583. uint32_t rel_location,
  584. const std::vector<offset_t>& item_offsets,
  585. Mapper&& mapper)
  586. : hi_(hi),
  587. rel_location_(rel_location),
  588. end_it_(item_offsets.cend()),
  589. mapper_(mapper) {
  590. cur_it_ = std::upper_bound(item_offsets.cbegin(), item_offsets.cend(), lo);
  591. // Adding |rel_location_| is necessary as references can be offset from the
  592. // start of the item.
  593. if (cur_it_ != item_offsets.begin() && *(cur_it_ - 1) + rel_location_ >= lo)
  594. --cur_it_;
  595. }
  596. CachedItemListReferenceReader(const CachedItemListReferenceReader&) = delete;
  597. const CachedItemListReferenceReader& operator=(
  598. const CachedItemListReferenceReader&) = delete;
  599. // ReferenceReader:
  600. absl::optional<Reference> GetNext() override {
  601. while (cur_it_ < end_it_) {
  602. const offset_t location = *cur_it_ + rel_location_;
  603. if (location >= hi_) // Check is simplified by atomicity assumption.
  604. break;
  605. const offset_t target = mapper_.Run(location);
  606. if (target == kInvalidOffset) {
  607. LOG(WARNING) << "Invalid item target at " << AsHex<8>(location) << ".";
  608. break;
  609. }
  610. ++cur_it_;
  611. // kDexSentinelOffset is a sentinel for;
  612. // - AnnotationsDirectoryItem: class_annotations_off
  613. if (target == kDexSentinelOffset)
  614. continue;
  615. return Reference{location, target};
  616. }
  617. return absl::nullopt;
  618. }
  619. private:
  620. const offset_t hi_;
  621. const uint32_t rel_location_;
  622. const std::vector<offset_t>::const_iterator end_it_;
  623. const Mapper mapper_;
  624. std::vector<offset_t>::const_iterator cur_it_;
  625. };
  626. // Reads an INT index at |location| in |image| and translates the index to the
  627. // offset of a fixed-size item specified by |target_map_item| and
  628. // |target_item_size|. Returns the target offset if valid, or kInvalidOffset
  629. // otherwise. This is compatible with
  630. // CachedReferenceListReferenceReader::Mapper,
  631. // InstructionReferenceReader::Mapper, and ItemReferenceReader::Mapper.
  632. template <typename INT>
  633. static offset_t ReadTargetIndex(ConstBufferView image,
  634. const dex::MapItem& target_map_item,
  635. size_t target_item_size,
  636. offset_t location) {
  637. static_assert(sizeof(INT) <= sizeof(offset_t),
  638. "INT may not fit into offset_t.");
  639. const offset_t unsafe_idx = image.read<INT>(location);
  640. // kDexSentinalIndexAsOffset (0xFFFFFFFF) is a sentinel for
  641. // - ClassDefItem: superclass_idx, source_file_idx.
  642. if (unsafe_idx == kDexSentinelIndexAsOffset)
  643. return unsafe_idx;
  644. if (unsafe_idx >= target_map_item.size)
  645. return kInvalidOffset;
  646. return target_map_item.offset +
  647. base::checked_cast<offset_t>(unsafe_idx * target_item_size);
  648. }
  649. // Reads a field or method index of the MethodHandleItem located at |location|
  650. // in |image| and translates |method_handle_item.field_or_method_id| to the
  651. // offset of a fixed-size item specified by |target_map_item| and
  652. // |target_item_size|. The index is deemed to be of the correct target type if
  653. // |method_handle_item.method_handle_type| falls within the range [|min_type|,
  654. // |max_type|]. If the target type is correct ReadTargetIndex is called.
  655. // Returns the target offset if valid, or kDexSentinelIndexAsOffset if
  656. // |method_handle_item.method_handle_type| is of the wrong type, or
  657. // kInvalidOffset otherwise.
  658. //
  659. // As of DEX version 39 MethodHandleType values for FieldId and MethodId each
  660. // form one consecutive block of values. If this changes, then the interface to
  661. // this function will need to be redesigned.
  662. static offset_t ReadMethodHandleFieldOrMethodId(
  663. ConstBufferView image,
  664. const dex::MapItem& target_map_item,
  665. size_t target_item_size,
  666. dex::MethodHandleType min_type,
  667. dex::MethodHandleType max_type,
  668. offset_t location) {
  669. dex::MethodHandleItem method_handle_item =
  670. image.read<dex::MethodHandleItem>(location);
  671. // Cannot use base::checked_cast as dex::MethodHandleType is an enum class so
  672. // static_assert on the size instead.
  673. static_assert(sizeof(decltype(dex::MethodHandleItem::method_handle_type)) <=
  674. sizeof(dex::MethodHandleType),
  675. "dex::MethodHandleItem::method_handle_type may not fit into "
  676. "dex::MethodHandleType.");
  677. dex::MethodHandleType method_handle_type =
  678. static_cast<dex::MethodHandleType>(method_handle_item.method_handle_type);
  679. if (method_handle_type >= dex::MethodHandleType::kMaxMethodHandleType) {
  680. return kInvalidOffset;
  681. }
  682. // Use DexSentinelIndexAsOffset to skip the item as it isn't of the
  683. // corresponding method handle type.
  684. if (method_handle_type < min_type || method_handle_type > max_type) {
  685. return kDexSentinelIndexAsOffset;
  686. }
  687. return ReadTargetIndex<decltype(dex::MethodHandleItem::field_or_method_id)>(
  688. image, target_map_item, target_item_size,
  689. location + offsetof(dex::MethodHandleItem, field_or_method_id));
  690. }
  691. // Reads uint32_t value in |image| at (valid) |location| and checks whether it
  692. // is a safe offset of a fixed-size item. Returns the target offset (possibly a
  693. // sentinel) if valid, or kInvalidOffset otherwise. This is compatible with
  694. // CachedReferenceListReferenceReader::Mapper,
  695. // InstructionReferenceReader::Mapper, and ItemReferenceReader::Mapper.
  696. static offset_t ReadTargetOffset32(ConstBufferView image, offset_t location) {
  697. const offset_t unsafe_target =
  698. static_cast<offset_t>(image.read<uint32_t>(location));
  699. // Skip and don't validate kDexSentinelOffset as it is indicative of an
  700. // empty reference.
  701. if (unsafe_target == kDexSentinelOffset)
  702. return unsafe_target;
  703. // TODO(huangs): Check that |unsafe_target| is within the correct data
  704. // section.
  705. if (unsafe_target >= image.size())
  706. return kInvalidOffset;
  707. return unsafe_target;
  708. }
  709. /******** ReferenceWriterAdaptor ********/
  710. // A ReferenceWriter that adapts a callback that performs type-specific
  711. // Reference writes.
  712. class ReferenceWriterAdaptor : public ReferenceWriter {
  713. public:
  714. using Writer = base::RepeatingCallback<void(Reference, MutableBufferView)>;
  715. ReferenceWriterAdaptor(MutableBufferView image, Writer&& writer)
  716. : image_(image), writer_(std::move(writer)) {}
  717. // ReferenceWriter:
  718. void PutNext(Reference ref) override { writer_.Run(ref, image_); }
  719. private:
  720. MutableBufferView image_;
  721. Writer writer_;
  722. };
  723. // Helper that's compatible with ReferenceWriterAdaptor::Writer.
  724. // Given that |ref.target| points to the start of a fixed size DEX item (e.g.,
  725. // FieldIdItem), translates |ref.target| to item index, and writes the result to
  726. // |ref.location| as |INT|.
  727. template <typename INT>
  728. static void WriteTargetIndex(const dex::MapItem& target_map_item,
  729. size_t target_item_size,
  730. Reference ref,
  731. MutableBufferView image) {
  732. const size_t unsafe_idx =
  733. (ref.target - target_map_item.offset) / target_item_size;
  734. // Verify that index is within bound.
  735. if (unsafe_idx >= target_map_item.size) {
  736. LOG(ERROR) << "Target index out of bounds at: " << AsHex<8>(ref.location)
  737. << ".";
  738. return;
  739. }
  740. // Verify that |ref.target| points to start of item.
  741. DCHECK_EQ(ref.target, target_map_item.offset + unsafe_idx * target_item_size);
  742. image.write<INT>(ref.location, base::checked_cast<INT>(unsafe_idx));
  743. }
  744. // Buffer for ReadDexHeader() to optionally return results.
  745. struct ReadDexHeaderResults {
  746. BufferSource source;
  747. raw_ptr<const dex::HeaderItem> header;
  748. int dex_version;
  749. };
  750. // Returns whether |image| points to a DEX file. If this is a possibility and
  751. // |opt_results| is not null, then uses it to pass extracted data to enable
  752. // further parsing.
  753. bool ReadDexHeader(ConstBufferView image, ReadDexHeaderResults* opt_results) {
  754. // This part needs to be fairly efficient since it may be called many times.
  755. BufferSource source(image);
  756. const dex::HeaderItem* header = source.GetPointer<dex::HeaderItem>();
  757. if (!header)
  758. return false;
  759. if (header->magic[0] != 'd' || header->magic[1] != 'e' ||
  760. header->magic[2] != 'x' || header->magic[3] != '\n' ||
  761. header->magic[7] != '\0') {
  762. return false;
  763. }
  764. // Magic matches: More detailed tests can be conducted.
  765. int dex_version = 0;
  766. for (int i = 4; i < 7; ++i) {
  767. if (!isdigit(header->magic[i]))
  768. return false;
  769. dex_version = dex_version * 10 + (header->magic[i] - '0');
  770. }
  771. // Only support DEX versions 35, 37, 38, and 39
  772. if (dex_version != 35 && dex_version != 37 && dex_version != 38 &&
  773. dex_version != 39) {
  774. return false;
  775. }
  776. if (header->file_size > image.size() ||
  777. header->file_size < sizeof(dex::HeaderItem) ||
  778. header->map_off < sizeof(dex::HeaderItem)) {
  779. return false;
  780. }
  781. if (opt_results)
  782. *opt_results = {source, header, dex_version};
  783. return true;
  784. }
  785. } // namespace
  786. /******** DisassemblerDex ********/
  787. DisassemblerDex::DisassemblerDex() : Disassembler(4) {}
  788. DisassemblerDex::~DisassemblerDex() = default;
  789. // static.
  790. bool DisassemblerDex::QuickDetect(ConstBufferView image) {
  791. return ReadDexHeader(image, nullptr);
  792. }
  793. ExecutableType DisassemblerDex::GetExeType() const {
  794. return kExeTypeDex;
  795. }
  796. std::string DisassemblerDex::GetExeTypeString() const {
  797. return base::StringPrintf("DEX (version %d)", dex_version_);
  798. }
  799. std::vector<ReferenceGroup> DisassemblerDex::MakeReferenceGroups() const {
  800. // Must follow DisassemblerDex::ReferenceType order. Initialized on first use.
  801. return {
  802. {{4, TypeTag(kTypeIdToDescriptorStringId), PoolTag(kStringId)},
  803. &DisassemblerDex::MakeReadTypeIdToDescriptorStringId32,
  804. &DisassemblerDex::MakeWriteStringId32},
  805. {{4, TypeTag(kProtoIdToShortyStringId), PoolTag(kStringId)},
  806. &DisassemblerDex::MakeReadProtoIdToShortyStringId32,
  807. &DisassemblerDex::MakeWriteStringId32},
  808. {{4, TypeTag(kFieldIdToNameStringId), PoolTag(kStringId)},
  809. &DisassemblerDex::MakeReadFieldToNameStringId32,
  810. &DisassemblerDex::MakeWriteStringId32},
  811. {{4, TypeTag(kMethodIdToNameStringId), PoolTag(kStringId)},
  812. &DisassemblerDex::MakeReadMethodIdToNameStringId32,
  813. &DisassemblerDex::MakeWriteStringId32},
  814. {{4, TypeTag(kClassDefToSourceFileStringId), PoolTag(kStringId)},
  815. &DisassemblerDex::MakeReadClassDefToSourceFileStringId32,
  816. &DisassemblerDex::MakeWriteStringId32},
  817. {{2, TypeTag(kCodeToStringId16), PoolTag(kStringId)},
  818. &DisassemblerDex::MakeReadCodeToStringId16,
  819. &DisassemblerDex::MakeWriteStringId16},
  820. {{4, TypeTag(kCodeToStringId32), PoolTag(kStringId)},
  821. &DisassemblerDex::MakeReadCodeToStringId32,
  822. &DisassemblerDex::MakeWriteStringId32},
  823. {{4, TypeTag(kProtoIdToReturnTypeId), PoolTag(kTypeId)},
  824. &DisassemblerDex::MakeReadProtoIdToReturnTypeId32,
  825. &DisassemblerDex::MakeWriteTypeId32},
  826. {{2, TypeTag(kFieldIdToClassTypeId), PoolTag(kTypeId)},
  827. &DisassemblerDex::MakeReadFieldToClassTypeId16,
  828. &DisassemblerDex::MakeWriteTypeId16},
  829. {{2, TypeTag(kFieldIdToTypeId), PoolTag(kTypeId)},
  830. &DisassemblerDex::MakeReadFieldToTypeId16,
  831. &DisassemblerDex::MakeWriteTypeId16},
  832. {{2, TypeTag(kMethodIdToClassTypeId), PoolTag(kTypeId)},
  833. &DisassemblerDex::MakeReadMethodIdToClassTypeId16,
  834. &DisassemblerDex::MakeWriteTypeId16},
  835. {{4, TypeTag(kClassDefToClassTypeId), PoolTag(kTypeId)},
  836. &DisassemblerDex::MakeReadClassDefToClassTypeId32,
  837. &DisassemblerDex::MakeWriteTypeId32},
  838. {{4, TypeTag(kClassDefToSuperClassTypeId), PoolTag(kTypeId)},
  839. &DisassemblerDex::MakeReadClassDefToSuperClassTypeId32,
  840. &DisassemblerDex::MakeWriteTypeId32},
  841. {{2, TypeTag(kTypeListToTypeId), PoolTag(kTypeId)},
  842. &DisassemblerDex::MakeReadTypeListToTypeId16,
  843. &DisassemblerDex::MakeWriteTypeId16},
  844. {{2, TypeTag(kCodeToTypeId), PoolTag(kTypeId)},
  845. &DisassemblerDex::MakeReadCodeToTypeId16,
  846. &DisassemblerDex::MakeWriteTypeId16},
  847. {{2, TypeTag(kCodeToProtoId), PoolTag(kProtoId)},
  848. &DisassemblerDex::MakeReadCodeToProtoId16,
  849. &DisassemblerDex::MakeWriteProtoId16},
  850. {{2, TypeTag(kMethodIdToProtoId), PoolTag(kProtoId)},
  851. &DisassemblerDex::MakeReadMethodIdToProtoId16,
  852. &DisassemblerDex::MakeWriteProtoId16},
  853. {{2, TypeTag(kCodeToFieldId), PoolTag(kFieldId)},
  854. &DisassemblerDex::MakeReadCodeToFieldId16,
  855. &DisassemblerDex::MakeWriteFieldId16},
  856. {{2, TypeTag(kMethodHandleToFieldId), PoolTag(kFieldId)},
  857. &DisassemblerDex::MakeReadMethodHandleToFieldId16,
  858. &DisassemblerDex::MakeWriteFieldId16},
  859. {{4, TypeTag(kAnnotationsDirectoryToFieldId), PoolTag(kFieldId)},
  860. &DisassemblerDex::MakeReadAnnotationsDirectoryToFieldId32,
  861. &DisassemblerDex::MakeWriteFieldId32},
  862. {{2, TypeTag(kCodeToMethodId), PoolTag(kMethodId)},
  863. &DisassemblerDex::MakeReadCodeToMethodId16,
  864. &DisassemblerDex::MakeWriteMethodId16},
  865. {{2, TypeTag(kMethodHandleToMethodId), PoolTag(kMethodId)},
  866. &DisassemblerDex::MakeReadMethodHandleToMethodId16,
  867. &DisassemblerDex::MakeWriteMethodId16},
  868. {{4, TypeTag(kAnnotationsDirectoryToMethodId), PoolTag(kMethodId)},
  869. &DisassemblerDex::MakeReadAnnotationsDirectoryToMethodId32,
  870. &DisassemblerDex::MakeWriteMethodId32},
  871. {{4, TypeTag(kAnnotationsDirectoryToParameterMethodId),
  872. PoolTag(kMethodId)},
  873. &DisassemblerDex::MakeReadAnnotationsDirectoryToParameterMethodId32,
  874. &DisassemblerDex::MakeWriteMethodId32},
  875. {{2, TypeTag(kCodeToCallSiteId), PoolTag(kCallSiteId)},
  876. &DisassemblerDex::MakeReadCodeToCallSiteId16,
  877. &DisassemblerDex::MakeWriteCallSiteId16},
  878. {{2, TypeTag(kCodeToMethodHandle), PoolTag(kMethodHandle)},
  879. &DisassemblerDex::MakeReadCodeToMethodHandle16,
  880. &DisassemblerDex::MakeWriteMethodHandle16},
  881. {{4, TypeTag(kProtoIdToParametersTypeList), PoolTag(kTypeList)},
  882. &DisassemblerDex::MakeReadProtoIdToParametersTypeList,
  883. &DisassemblerDex::MakeWriteAbs32},
  884. {{4, TypeTag(kClassDefToInterfacesTypeList), PoolTag(kTypeList)},
  885. &DisassemblerDex::MakeReadClassDefToInterfacesTypeList,
  886. &DisassemblerDex::MakeWriteAbs32},
  887. {{4, TypeTag(kAnnotationsDirectoryToParameterAnnotationSetRef),
  888. PoolTag(kAnnotationSetRefList)},
  889. &DisassemblerDex::
  890. MakeReadAnnotationsDirectoryToParameterAnnotationSetRef,
  891. &DisassemblerDex::MakeWriteAbs32},
  892. {{4, TypeTag(kAnnotationSetRefListToAnnotationSet),
  893. PoolTag(kAnnotionSet)},
  894. &DisassemblerDex::MakeReadAnnotationSetRefListToAnnotationSet,
  895. &DisassemblerDex::MakeWriteAbs32},
  896. {{4, TypeTag(kAnnotationsDirectoryToClassAnnotationSet),
  897. PoolTag(kAnnotionSet)},
  898. &DisassemblerDex::MakeReadAnnotationsDirectoryToClassAnnotationSet,
  899. &DisassemblerDex::MakeWriteAbs32},
  900. {{4, TypeTag(kAnnotationsDirectoryToFieldAnnotationSet),
  901. PoolTag(kAnnotionSet)},
  902. &DisassemblerDex::MakeReadAnnotationsDirectoryToFieldAnnotationSet,
  903. &DisassemblerDex::MakeWriteAbs32},
  904. {{4, TypeTag(kAnnotationsDirectoryToMethodAnnotationSet),
  905. PoolTag(kAnnotionSet)},
  906. &DisassemblerDex::MakeReadAnnotationsDirectoryToMethodAnnotationSet,
  907. &DisassemblerDex::MakeWriteAbs32},
  908. {{4, TypeTag(kClassDefToClassData), PoolTag(kClassData)},
  909. &DisassemblerDex::MakeReadClassDefToClassData,
  910. &DisassemblerDex::MakeWriteAbs32},
  911. {{1, TypeTag(kCodeToRelCode8), PoolTag(kCode)},
  912. &DisassemblerDex::MakeReadCodeToRelCode8,
  913. &DisassemblerDex::MakeWriteRelCode8},
  914. {{2, TypeTag(kCodeToRelCode16), PoolTag(kCode)},
  915. &DisassemblerDex::MakeReadCodeToRelCode16,
  916. &DisassemblerDex::MakeWriteRelCode16},
  917. {{4, TypeTag(kCodeToRelCode32), PoolTag(kCode)},
  918. &DisassemblerDex::MakeReadCodeToRelCode32,
  919. &DisassemblerDex::MakeWriteRelCode32},
  920. {{4, TypeTag(kStringIdToStringData), PoolTag(kStringData)},
  921. &DisassemblerDex::MakeReadStringIdToStringData,
  922. &DisassemblerDex::MakeWriteAbs32},
  923. {{4, TypeTag(kAnnotationSetToAnnotation), PoolTag(kAnnotation)},
  924. &DisassemblerDex::MakeReadAnnotationSetToAnnotation,
  925. &DisassemblerDex::MakeWriteAbs32},
  926. {{4, TypeTag(kClassDefToStaticValuesEncodedArray),
  927. PoolTag(kEncodedArray)},
  928. &DisassemblerDex::MakeReadClassDefToStaticValuesEncodedArray,
  929. &DisassemblerDex::MakeWriteAbs32},
  930. {{4, TypeTag(kClassDefToAnnotationDirectory),
  931. PoolTag(kAnnotationsDirectory)},
  932. &DisassemblerDex::MakeReadClassDefToAnnotationDirectory,
  933. &DisassemblerDex::MakeWriteAbs32},
  934. {{4, TypeTag(kCallSiteIdToCallSite), PoolTag(kCallSite)},
  935. &DisassemblerDex::MakeReadCallSiteIdToCallSite32,
  936. &DisassemblerDex::MakeWriteAbs32},
  937. };
  938. }
  939. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadStringIdToStringData(
  940. offset_t lo,
  941. offset_t hi) {
  942. // dex::StringIdItem::string_data_off mapper.
  943. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  944. return std::make_unique<ItemReferenceReader>(
  945. lo, hi, string_map_item_, sizeof(dex::StringIdItem),
  946. offsetof(dex::StringIdItem, string_data_off), std::move(mapper));
  947. }
  948. std::unique_ptr<ReferenceReader>
  949. DisassemblerDex::MakeReadTypeIdToDescriptorStringId32(offset_t lo,
  950. offset_t hi) {
  951. auto mapper = base::BindRepeating(
  952. ReadTargetIndex<decltype(dex::TypeIdItem::descriptor_idx)>, image_,
  953. string_map_item_, sizeof(dex::StringIdItem));
  954. return std::make_unique<ItemReferenceReader>(
  955. lo, hi, type_map_item_, sizeof(dex::TypeIdItem),
  956. offsetof(dex::TypeIdItem, descriptor_idx), std::move(mapper));
  957. }
  958. std::unique_ptr<ReferenceReader>
  959. DisassemblerDex::MakeReadProtoIdToShortyStringId32(offset_t lo, offset_t hi) {
  960. auto mapper = base::BindRepeating(
  961. ReadTargetIndex<decltype(dex::ProtoIdItem::shorty_idx)>, image_,
  962. string_map_item_, sizeof(dex::StringIdItem));
  963. return std::make_unique<ItemReferenceReader>(
  964. lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
  965. offsetof(dex::ProtoIdItem, shorty_idx), std::move(mapper));
  966. }
  967. std::unique_ptr<ReferenceReader>
  968. DisassemblerDex::MakeReadProtoIdToReturnTypeId32(offset_t lo, offset_t hi) {
  969. auto mapper = base::BindRepeating(
  970. ReadTargetIndex<decltype(dex::ProtoIdItem::return_type_idx)>, image_,
  971. type_map_item_, sizeof(dex::TypeIdItem));
  972. return std::make_unique<ItemReferenceReader>(
  973. lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
  974. offsetof(dex::ProtoIdItem, return_type_idx), std::move(mapper));
  975. }
  976. std::unique_ptr<ReferenceReader>
  977. DisassemblerDex::MakeReadProtoIdToParametersTypeList(offset_t lo, offset_t hi) {
  978. // dex::ProtoIdItem::parameters_off mapper.
  979. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  980. return std::make_unique<ItemReferenceReader>(
  981. lo, hi, proto_map_item_, sizeof(dex::ProtoIdItem),
  982. offsetof(dex::ProtoIdItem, parameters_off), std::move(mapper));
  983. }
  984. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToClassTypeId16(
  985. offset_t lo,
  986. offset_t hi) {
  987. auto mapper = base::BindRepeating(
  988. ReadTargetIndex<decltype(dex::FieldIdItem::class_idx)>, image_,
  989. type_map_item_, sizeof(dex::TypeIdItem));
  990. return std::make_unique<ItemReferenceReader>(
  991. lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
  992. offsetof(dex::FieldIdItem, class_idx), std::move(mapper));
  993. }
  994. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToTypeId16(
  995. offset_t lo,
  996. offset_t hi) {
  997. auto mapper =
  998. base::BindRepeating(ReadTargetIndex<decltype(dex::FieldIdItem::type_idx)>,
  999. image_, type_map_item_, sizeof(dex::TypeIdItem));
  1000. return std::make_unique<ItemReferenceReader>(
  1001. lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
  1002. offsetof(dex::FieldIdItem, type_idx), std::move(mapper));
  1003. }
  1004. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadFieldToNameStringId32(
  1005. offset_t lo,
  1006. offset_t hi) {
  1007. auto mapper =
  1008. base::BindRepeating(ReadTargetIndex<decltype(dex::FieldIdItem::name_idx)>,
  1009. image_, string_map_item_, sizeof(dex::StringIdItem));
  1010. return std::make_unique<ItemReferenceReader>(
  1011. lo, hi, field_map_item_, sizeof(dex::FieldIdItem),
  1012. offsetof(dex::FieldIdItem, name_idx), std::move(mapper));
  1013. }
  1014. std::unique_ptr<ReferenceReader>
  1015. DisassemblerDex::MakeReadMethodIdToClassTypeId16(offset_t lo, offset_t hi) {
  1016. auto mapper = base::BindRepeating(
  1017. ReadTargetIndex<decltype(dex::MethodIdItem::class_idx)>, image_,
  1018. type_map_item_, sizeof(dex::TypeIdItem));
  1019. return std::make_unique<ItemReferenceReader>(
  1020. lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
  1021. offsetof(dex::MethodIdItem, class_idx), std::move(mapper));
  1022. }
  1023. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadMethodIdToProtoId16(
  1024. offset_t lo,
  1025. offset_t hi) {
  1026. auto mapper = base::BindRepeating(
  1027. ReadTargetIndex<decltype(dex::MethodIdItem::proto_idx)>, image_,
  1028. proto_map_item_, sizeof(dex::ProtoIdItem));
  1029. return std::make_unique<ItemReferenceReader>(
  1030. lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
  1031. offsetof(dex::MethodIdItem, proto_idx), std::move(mapper));
  1032. }
  1033. std::unique_ptr<ReferenceReader>
  1034. DisassemblerDex::MakeReadMethodIdToNameStringId32(offset_t lo, offset_t hi) {
  1035. auto mapper = base::BindRepeating(
  1036. ReadTargetIndex<decltype(dex::MethodIdItem::name_idx)>, image_,
  1037. string_map_item_, sizeof(dex::StringIdItem));
  1038. return std::make_unique<ItemReferenceReader>(
  1039. lo, hi, method_map_item_, sizeof(dex::MethodIdItem),
  1040. offsetof(dex::MethodIdItem, name_idx), std::move(mapper));
  1041. }
  1042. std::unique_ptr<ReferenceReader>
  1043. DisassemblerDex::MakeReadClassDefToClassTypeId32(offset_t lo, offset_t hi) {
  1044. auto mapper = base::BindRepeating(
  1045. ReadTargetIndex<decltype(dex::ClassDefItem::superclass_idx)>, image_,
  1046. type_map_item_, sizeof(dex::TypeIdItem));
  1047. return std::make_unique<ItemReferenceReader>(
  1048. lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
  1049. offsetof(dex::ClassDefItem, class_idx), std::move(mapper));
  1050. }
  1051. std::unique_ptr<ReferenceReader>
  1052. DisassemblerDex::MakeReadClassDefToSuperClassTypeId32(offset_t lo,
  1053. offset_t hi) {
  1054. auto mapper = base::BindRepeating(
  1055. ReadTargetIndex<decltype(dex::ClassDefItem::superclass_idx)>, image_,
  1056. type_map_item_, sizeof(dex::TypeIdItem));
  1057. return std::make_unique<ItemReferenceReader>(
  1058. lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
  1059. offsetof(dex::ClassDefItem, superclass_idx), std::move(mapper));
  1060. }
  1061. std::unique_ptr<ReferenceReader>
  1062. DisassemblerDex::MakeReadClassDefToInterfacesTypeList(offset_t lo,
  1063. offset_t hi) {
  1064. // dex::ClassDefItem::interfaces_off mapper.
  1065. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1066. return std::make_unique<ItemReferenceReader>(
  1067. lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
  1068. offsetof(dex::ClassDefItem, interfaces_off), std::move(mapper));
  1069. }
  1070. std::unique_ptr<ReferenceReader>
  1071. DisassemblerDex::MakeReadClassDefToSourceFileStringId32(offset_t lo,
  1072. offset_t hi) {
  1073. auto mapper = base::BindRepeating(
  1074. ReadTargetIndex<decltype(dex::ClassDefItem::source_file_idx)>, image_,
  1075. string_map_item_, sizeof(dex::StringIdItem));
  1076. return std::make_unique<ItemReferenceReader>(
  1077. lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
  1078. offsetof(dex::ClassDefItem, source_file_idx), std::move(mapper));
  1079. }
  1080. std::unique_ptr<ReferenceReader>
  1081. DisassemblerDex::MakeReadClassDefToAnnotationDirectory(offset_t lo,
  1082. offset_t hi) {
  1083. // dex::ClassDefItem::annotations_off mapper.
  1084. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1085. return std::make_unique<ItemReferenceReader>(
  1086. lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
  1087. offsetof(dex::ClassDefItem, annotations_off), std::move(mapper));
  1088. }
  1089. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadClassDefToClassData(
  1090. offset_t lo,
  1091. offset_t hi) {
  1092. // dex::ClassDefItem::class_data_off mapper.
  1093. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1094. return std::make_unique<ItemReferenceReader>(
  1095. lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
  1096. offsetof(dex::ClassDefItem, class_data_off), std::move(mapper));
  1097. }
  1098. std::unique_ptr<ReferenceReader>
  1099. DisassemblerDex::MakeReadClassDefToStaticValuesEncodedArray(offset_t lo,
  1100. offset_t hi) {
  1101. // dex::ClassDefItem::static_values_off mapper.
  1102. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1103. return std::make_unique<ItemReferenceReader>(
  1104. lo, hi, class_def_map_item_, sizeof(dex::ClassDefItem),
  1105. offsetof(dex::ClassDefItem, static_values_off), std::move(mapper));
  1106. }
  1107. std::unique_ptr<ReferenceReader>
  1108. DisassemblerDex::MakeReadCallSiteIdToCallSite32(offset_t lo, offset_t hi) {
  1109. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1110. return std::make_unique<ItemReferenceReader>(
  1111. lo, hi, call_site_map_item_, sizeof(dex::CallSiteIdItem),
  1112. offsetof(dex::CallSiteIdItem, call_site_off), std::move(mapper));
  1113. }
  1114. std::unique_ptr<ReferenceReader>
  1115. DisassemblerDex::MakeReadMethodHandleToFieldId16(offset_t lo, offset_t hi) {
  1116. auto mapper = base::BindRepeating(ReadMethodHandleFieldOrMethodId, image_,
  1117. field_map_item_, sizeof(dex::FieldIdItem),
  1118. dex::MethodHandleType::kStaticPut,
  1119. dex::MethodHandleType::kInstanceGet);
  1120. // Use |mapper_wants_item == true| for ItemReferenceReader such that
  1121. // |location| is aligned with MethodHandleItem when passed to |mapper|. This
  1122. // allows ReadMethodHandleFieldOrMethodId to safely determine whether the
  1123. // reference in the MethodHandleItem is of the correct type to be emitted.
  1124. return std::make_unique<ItemReferenceReader>(
  1125. lo, hi, method_handle_map_item_, sizeof(dex::MethodHandleItem),
  1126. offsetof(dex::MethodHandleItem, field_or_method_id), std::move(mapper),
  1127. /*mapper_wants_item=*/true);
  1128. }
  1129. std::unique_ptr<ReferenceReader>
  1130. DisassemblerDex::MakeReadMethodHandleToMethodId16(offset_t lo, offset_t hi) {
  1131. auto mapper = base::BindRepeating(ReadMethodHandleFieldOrMethodId, image_,
  1132. method_map_item_, sizeof(dex::MethodIdItem),
  1133. dex::MethodHandleType::kInvokeStatic,
  1134. dex::MethodHandleType::kInvokeInterface);
  1135. // Use |mapper_wants_item == true| for ItemReferenceReader such that
  1136. // |location| is aligned with MethodHandleItem when passed to |mapper|. This
  1137. // allows ReadMethodHandleFieldOrMethodId to safely determine whether the
  1138. // reference in the MethodHandleItem is of the correct type to be emitted.
  1139. return std::make_unique<ItemReferenceReader>(
  1140. lo, hi, method_handle_map_item_, sizeof(dex::MethodHandleItem),
  1141. offsetof(dex::MethodHandleItem, field_or_method_id), std::move(mapper),
  1142. /*mapper_wants_item=*/true);
  1143. }
  1144. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadTypeListToTypeId16(
  1145. offset_t lo,
  1146. offset_t hi) {
  1147. auto mapper =
  1148. base::BindRepeating(ReadTargetIndex<decltype(dex::TypeItem::type_idx)>,
  1149. image_, type_map_item_, sizeof(dex::TypeIdItem));
  1150. return std::make_unique<CachedItemListReferenceReader>(
  1151. lo, hi, offsetof(dex::TypeItem, type_idx), type_list_offsets_,
  1152. std::move(mapper));
  1153. }
  1154. std::unique_ptr<ReferenceReader>
  1155. DisassemblerDex::MakeReadAnnotationSetToAnnotation(offset_t lo, offset_t hi) {
  1156. // dex::AnnotationOffItem::annotation_off mapper.
  1157. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1158. return std::make_unique<CachedItemListReferenceReader>(
  1159. lo, hi, offsetof(dex::AnnotationOffItem, annotation_off),
  1160. annotation_set_offsets_, std::move(mapper));
  1161. }
  1162. std::unique_ptr<ReferenceReader>
  1163. DisassemblerDex::MakeReadAnnotationSetRefListToAnnotationSet(offset_t lo,
  1164. offset_t hi) {
  1165. // dex::AnnotationSetRefItem::annotations_off mapper.
  1166. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1167. return std::make_unique<CachedItemListReferenceReader>(
  1168. lo, hi, offsetof(dex::AnnotationSetRefItem, annotations_off),
  1169. annotation_set_ref_list_offsets_, std::move(mapper));
  1170. }
  1171. std::unique_ptr<ReferenceReader>
  1172. DisassemblerDex::MakeReadAnnotationsDirectoryToClassAnnotationSet(offset_t lo,
  1173. offset_t hi) {
  1174. // dex::AnnotationsDirectoryItem::class_annotations_off mapper.
  1175. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1176. return std::make_unique<CachedItemListReferenceReader>(
  1177. lo, hi, offsetof(dex::AnnotationsDirectoryItem, class_annotations_off),
  1178. annotations_directory_item_offsets_, std::move(mapper));
  1179. }
  1180. std::unique_ptr<ReferenceReader>
  1181. DisassemblerDex::MakeReadAnnotationsDirectoryToFieldId32(offset_t lo,
  1182. offset_t hi) {
  1183. auto mapper = base::BindRepeating(
  1184. ReadTargetIndex<decltype(dex::FieldAnnotation::field_idx)>, image_,
  1185. field_map_item_, sizeof(dex::FieldIdItem));
  1186. return std::make_unique<CachedItemListReferenceReader>(
  1187. lo, hi, offsetof(dex::FieldAnnotation, field_idx),
  1188. annotations_directory_item_field_annotation_offsets_, std::move(mapper));
  1189. }
  1190. std::unique_ptr<ReferenceReader>
  1191. DisassemblerDex::MakeReadAnnotationsDirectoryToFieldAnnotationSet(offset_t lo,
  1192. offset_t hi) {
  1193. // dex::FieldAnnotation::annotations_off mapper.
  1194. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1195. return std::make_unique<CachedItemListReferenceReader>(
  1196. lo, hi, offsetof(dex::FieldAnnotation, annotations_off),
  1197. annotations_directory_item_field_annotation_offsets_, std::move(mapper));
  1198. }
  1199. std::unique_ptr<ReferenceReader>
  1200. DisassemblerDex::MakeReadAnnotationsDirectoryToMethodId32(offset_t lo,
  1201. offset_t hi) {
  1202. auto mapper = base::BindRepeating(
  1203. ReadTargetIndex<decltype(dex::MethodAnnotation::method_idx)>, image_,
  1204. method_map_item_, sizeof(dex::MethodIdItem));
  1205. return std::make_unique<CachedItemListReferenceReader>(
  1206. lo, hi, offsetof(dex::MethodAnnotation, method_idx),
  1207. annotations_directory_item_method_annotation_offsets_, std::move(mapper));
  1208. }
  1209. std::unique_ptr<ReferenceReader>
  1210. DisassemblerDex::MakeReadAnnotationsDirectoryToMethodAnnotationSet(
  1211. offset_t lo,
  1212. offset_t hi) {
  1213. // dex::MethodAnnotation::annotations_off mapper.
  1214. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1215. return std::make_unique<CachedItemListReferenceReader>(
  1216. lo, hi, offsetof(dex::MethodAnnotation, annotations_off),
  1217. annotations_directory_item_method_annotation_offsets_, std::move(mapper));
  1218. }
  1219. std::unique_ptr<ReferenceReader>
  1220. DisassemblerDex::MakeReadAnnotationsDirectoryToParameterMethodId32(
  1221. offset_t lo,
  1222. offset_t hi) {
  1223. auto mapper = base::BindRepeating(
  1224. ReadTargetIndex<decltype(dex::ParameterAnnotation::method_idx)>, image_,
  1225. method_map_item_, sizeof(dex::MethodIdItem));
  1226. return std::make_unique<CachedItemListReferenceReader>(
  1227. lo, hi, offsetof(dex::ParameterAnnotation, method_idx),
  1228. annotations_directory_item_parameter_annotation_offsets_,
  1229. std::move(mapper));
  1230. }
  1231. std::unique_ptr<ReferenceReader>
  1232. DisassemblerDex::MakeReadAnnotationsDirectoryToParameterAnnotationSetRef(
  1233. offset_t lo,
  1234. offset_t hi) {
  1235. // dex::ParameterAnnotation::annotations_off mapper.
  1236. auto mapper = base::BindRepeating(ReadTargetOffset32, image_);
  1237. return std::make_unique<CachedItemListReferenceReader>(
  1238. lo, hi, offsetof(dex::ParameterAnnotation, annotations_off),
  1239. annotations_directory_item_parameter_annotation_offsets_,
  1240. std::move(mapper));
  1241. }
  1242. // MakeReadCode* readers use offset relative to the instruction beginning based
  1243. // on the instruction format ID.
  1244. // See https://source.android.com/devices/tech/dalvik/instruction-formats
  1245. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToStringId16(
  1246. offset_t lo,
  1247. offset_t hi) {
  1248. auto filter = base::BindRepeating(
  1249. [](const InstructionParser::Value& value) -> offset_t {
  1250. if (value.instr->format == dex::FormatId::c &&
  1251. (value.instr->opcode == 0x1A)) { // const-string
  1252. // BBBB from e.g., const-string vAA, string@BBBB.
  1253. return value.instr_offset + 2;
  1254. }
  1255. return kInvalidOffset;
  1256. });
  1257. auto mapper =
  1258. base::BindRepeating(ReadTargetIndex<uint16_t>, image_, string_map_item_,
  1259. sizeof(dex::StringIdItem));
  1260. return std::make_unique<InstructionReferenceReader>(
  1261. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1262. }
  1263. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToStringId32(
  1264. offset_t lo,
  1265. offset_t hi) {
  1266. auto filter = base::BindRepeating(
  1267. [](const InstructionParser::Value& value) -> offset_t {
  1268. if (value.instr->format == dex::FormatId::c &&
  1269. (value.instr->opcode == 0x1B)) { // const-string/jumbo
  1270. // BBBBBBBB from e.g., const-string/jumbo vAA, string@BBBBBBBB.
  1271. return value.instr_offset + 2;
  1272. }
  1273. return kInvalidOffset;
  1274. });
  1275. auto mapper =
  1276. base::BindRepeating(ReadTargetIndex<uint32_t>, image_, string_map_item_,
  1277. sizeof(dex::StringIdItem));
  1278. return std::make_unique<InstructionReferenceReader>(
  1279. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1280. }
  1281. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToTypeId16(
  1282. offset_t lo,
  1283. offset_t hi) {
  1284. auto filter = base::BindRepeating(
  1285. [](const InstructionParser::Value& value) -> offset_t {
  1286. if (value.instr->format == dex::FormatId::c &&
  1287. (value.instr->opcode == 0x1C || // const-class
  1288. value.instr->opcode == 0x1F || // check-cast
  1289. value.instr->opcode == 0x20 || // instance-of
  1290. value.instr->opcode == 0x22 || // new-instance
  1291. value.instr->opcode == 0x23 || // new-array
  1292. value.instr->opcode == 0x24 || // filled-new-array
  1293. value.instr->opcode == 0x25)) { // filled-new-array/range
  1294. // BBBB from e.g., const-class vAA, type@BBBB.
  1295. return value.instr_offset + 2;
  1296. }
  1297. return kInvalidOffset;
  1298. });
  1299. auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
  1300. type_map_item_, sizeof(dex::TypeIdItem));
  1301. return std::make_unique<InstructionReferenceReader>(
  1302. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1303. }
  1304. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToProtoId16(
  1305. offset_t lo,
  1306. offset_t hi) {
  1307. auto filter = base::BindRepeating(
  1308. [](const InstructionParser::Value& value) -> offset_t {
  1309. if (value.instr->format == dex::FormatId::c) {
  1310. if (value.instr->opcode == 0xFA || // invoke-polymorphic
  1311. value.instr->opcode == 0xFB) { // invoke-polymorphic/range
  1312. // HHHH from e.g, invoke-polymorphic {vC, vD, vE, vF, vG},
  1313. // meth@BBBB, proto@HHHH
  1314. return value.instr_offset + 6;
  1315. }
  1316. if (value.instr->opcode == 0xFF) { // const-method-type
  1317. // BBBB from e.g., const-method-type vAA, proto@BBBB
  1318. return value.instr_offset + 2;
  1319. }
  1320. }
  1321. return kInvalidOffset;
  1322. });
  1323. auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
  1324. proto_map_item_, sizeof(dex::ProtoIdItem));
  1325. return std::make_unique<InstructionReferenceReader>(
  1326. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1327. }
  1328. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToCallSiteId16(
  1329. offset_t lo,
  1330. offset_t hi) {
  1331. auto filter = base::BindRepeating(
  1332. [](const InstructionParser::Value& value) -> offset_t {
  1333. if (value.instr->format == dex::FormatId::c &&
  1334. (value.instr->opcode == 0xFC || // invoke-custom
  1335. value.instr->opcode == 0xFD)) { // invoke-custom/range
  1336. // BBBB from e.g, invoke-custom {vC, vD, vE, vF, vG},
  1337. // call_site@BBBB
  1338. return value.instr_offset + 2;
  1339. }
  1340. return kInvalidOffset;
  1341. });
  1342. auto mapper =
  1343. base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
  1344. call_site_map_item_, sizeof(dex::CallSiteIdItem));
  1345. return std::make_unique<InstructionReferenceReader>(
  1346. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1347. }
  1348. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToMethodHandle16(
  1349. offset_t lo,
  1350. offset_t hi) {
  1351. auto filter = base::BindRepeating(
  1352. [](const InstructionParser::Value& value) -> offset_t {
  1353. if (value.instr->format == dex::FormatId::c &&
  1354. value.instr->opcode == 0xFE) { // const-method-handle
  1355. // BBBB from e.g, const-method-handle vAA, method_handle@BBBB
  1356. return value.instr_offset + 2;
  1357. }
  1358. return kInvalidOffset;
  1359. });
  1360. auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
  1361. method_handle_map_item_,
  1362. sizeof(dex::MethodHandleItem));
  1363. return std::make_unique<InstructionReferenceReader>(
  1364. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1365. }
  1366. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToFieldId16(
  1367. offset_t lo,
  1368. offset_t hi) {
  1369. auto filter = base::BindRepeating(
  1370. [](const InstructionParser::Value& value) -> offset_t {
  1371. if (value.instr->format == dex::FormatId::c &&
  1372. (value.instr->opcode == 0x52 || // iinstanceop (iget-*, iput-*)
  1373. value.instr->opcode == 0x60)) { // sstaticop (sget-*, sput-*)
  1374. // CCCC from e.g., iget vA, vB, field@CCCC.
  1375. return value.instr_offset + 2;
  1376. }
  1377. return kInvalidOffset;
  1378. });
  1379. auto mapper = base::BindRepeating(ReadTargetIndex<uint16_t>, image_,
  1380. field_map_item_, sizeof(dex::FieldIdItem));
  1381. return std::make_unique<InstructionReferenceReader>(
  1382. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1383. }
  1384. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToMethodId16(
  1385. offset_t lo,
  1386. offset_t hi) {
  1387. auto filter = base::BindRepeating(
  1388. [](const InstructionParser::Value& value) -> offset_t {
  1389. if (value.instr->format == dex::FormatId::c &&
  1390. (value.instr->opcode == 0x6E || // invoke-kind
  1391. value.instr->opcode == 0x74 || // invoke-kind/range
  1392. value.instr->opcode == 0xFA || // invoke-polymorphic
  1393. value.instr->opcode == 0xFB)) { // invoke-polymorphic/range
  1394. // BBBB from e.g., invoke-virtual {vC, vD, vE, vF, vG}, meth@BBBB.
  1395. return value.instr_offset + 2;
  1396. }
  1397. return kInvalidOffset;
  1398. });
  1399. auto mapper =
  1400. base::BindRepeating(ReadTargetIndex<uint16_t>, image_, method_map_item_,
  1401. sizeof(dex::MethodIdItem));
  1402. return std::make_unique<InstructionReferenceReader>(
  1403. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1404. }
  1405. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode8(
  1406. offset_t lo,
  1407. offset_t hi) {
  1408. auto filter = base::BindRepeating(
  1409. [](const InstructionParser::Value& value) -> offset_t {
  1410. if (value.instr->format == dex::FormatId::t &&
  1411. value.instr->opcode == 0x28) { // goto
  1412. // +AA from e.g., goto +AA.
  1413. return value.instr_offset + 1;
  1414. }
  1415. return kInvalidOffset;
  1416. });
  1417. auto mapper = base::BindRepeating(
  1418. [](DisassemblerDex* dis, offset_t location) {
  1419. // Address is relative to the current instruction, which begins 1 unit
  1420. // before |location|. This needs to be subtracted out. Also, store as
  1421. // int32_t so |unsafe_delta - 1| won't underflow!
  1422. int32_t unsafe_delta = dis->image_.read<int8_t>(location);
  1423. offset_t unsafe_target = static_cast<offset_t>(
  1424. location + (unsafe_delta - 1) * kInstrUnitSize);
  1425. // TODO(huangs): Check that |unsafe_target| stays within code item.
  1426. return unsafe_target;
  1427. },
  1428. base::Unretained(this));
  1429. return std::make_unique<InstructionReferenceReader>(
  1430. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1431. }
  1432. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode16(
  1433. offset_t lo,
  1434. offset_t hi) {
  1435. auto filter = base::BindRepeating(
  1436. [](const InstructionParser::Value& value) -> offset_t {
  1437. if (value.instr->format == dex::FormatId::t &&
  1438. (value.instr->opcode == 0x29 || // goto/16
  1439. value.instr->opcode == 0x32 || // if-test
  1440. value.instr->opcode == 0x38)) { // if-testz
  1441. // +AAAA from e.g., goto/16 +AAAA.
  1442. return value.instr_offset + 2;
  1443. }
  1444. return kInvalidOffset;
  1445. });
  1446. auto mapper = base::BindRepeating(
  1447. [](DisassemblerDex* dis, offset_t location) {
  1448. // Address is relative to the current instruction, which begins 1 unit
  1449. // before |location|. This needs to be subtracted out. Also, store as
  1450. // int32_t so |unsafe_delta - 1| won't underflow!
  1451. int32_t unsafe_delta = dis->image_.read<int16_t>(location);
  1452. offset_t unsafe_target = static_cast<offset_t>(
  1453. location + (unsafe_delta - 1) * kInstrUnitSize);
  1454. // TODO(huangs): Check that |unsafe_target| stays within code item.
  1455. return unsafe_target;
  1456. },
  1457. base::Unretained(this));
  1458. return std::make_unique<InstructionReferenceReader>(
  1459. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1460. }
  1461. std::unique_ptr<ReferenceReader> DisassemblerDex::MakeReadCodeToRelCode32(
  1462. offset_t lo,
  1463. offset_t hi) {
  1464. auto filter = base::BindRepeating(
  1465. [](const InstructionParser::Value& value) -> offset_t {
  1466. if (value.instr->format == dex::FormatId::t &&
  1467. (value.instr->opcode == 0x26 || // fill-array-data
  1468. value.instr->opcode == 0x2A || // goto/32
  1469. value.instr->opcode == 0x2B || // packed-switch
  1470. value.instr->opcode == 0x2C)) { // sparse-switch
  1471. // +BBBBBBBB from e.g., fill-array-data vAA, +BBBBBBBB.
  1472. // +AAAAAAAA from e.g., goto/32 +AAAAAAAA.
  1473. return value.instr_offset + 2;
  1474. }
  1475. return kInvalidOffset;
  1476. });
  1477. auto mapper = base::BindRepeating(
  1478. [](DisassemblerDex* dis, offset_t location) {
  1479. // Address is relative to the current instruction, which begins 1 unit
  1480. // before |location|. This needs to be subtracted out. Use int64_t to
  1481. // avoid underflow and overflow.
  1482. int64_t unsafe_delta = dis->image_.read<int32_t>(location);
  1483. int64_t unsafe_target = location + (unsafe_delta - 1) * kInstrUnitSize;
  1484. // TODO(huangs): Check that |unsafe_target| stays within code item.
  1485. offset_t checked_unsafe_target =
  1486. static_cast<offset_t>(base::CheckedNumeric<offset_t>(unsafe_target)
  1487. .ValueOrDefault(kInvalidOffset));
  1488. return checked_unsafe_target < kOffsetBound ? checked_unsafe_target
  1489. : kInvalidOffset;
  1490. },
  1491. base::Unretained(this));
  1492. return std::make_unique<InstructionReferenceReader>(
  1493. image_, lo, hi, code_item_offsets_, std::move(filter), std::move(mapper));
  1494. }
  1495. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteStringId16(
  1496. MutableBufferView image) {
  1497. auto writer = base::BindRepeating(
  1498. WriteTargetIndex<uint16_t>, string_map_item_, sizeof(dex::StringIdItem));
  1499. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1500. }
  1501. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteStringId32(
  1502. MutableBufferView image) {
  1503. auto writer = base::BindRepeating(
  1504. WriteTargetIndex<uint32_t>, string_map_item_, sizeof(dex::StringIdItem));
  1505. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1506. }
  1507. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteTypeId16(
  1508. MutableBufferView image) {
  1509. auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, type_map_item_,
  1510. sizeof(dex::TypeIdItem));
  1511. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1512. }
  1513. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteTypeId32(
  1514. MutableBufferView image) {
  1515. auto writer = base::BindRepeating(WriteTargetIndex<uint32_t>, type_map_item_,
  1516. sizeof(dex::TypeIdItem));
  1517. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1518. }
  1519. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteProtoId16(
  1520. MutableBufferView image) {
  1521. auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, proto_map_item_,
  1522. sizeof(dex::ProtoIdItem));
  1523. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1524. }
  1525. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteFieldId16(
  1526. MutableBufferView image) {
  1527. auto writer = base::BindRepeating(WriteTargetIndex<uint16_t>, field_map_item_,
  1528. sizeof(dex::FieldIdItem));
  1529. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1530. }
  1531. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteFieldId32(
  1532. MutableBufferView image) {
  1533. auto writer = base::BindRepeating(WriteTargetIndex<uint32_t>, field_map_item_,
  1534. sizeof(dex::FieldIdItem));
  1535. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1536. }
  1537. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodId16(
  1538. MutableBufferView image) {
  1539. auto writer = base::BindRepeating(
  1540. WriteTargetIndex<uint16_t>, method_map_item_, sizeof(dex::MethodIdItem));
  1541. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1542. }
  1543. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodId32(
  1544. MutableBufferView image) {
  1545. auto writer = base::BindRepeating(
  1546. WriteTargetIndex<uint32_t>, method_map_item_, sizeof(dex::MethodIdItem));
  1547. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1548. }
  1549. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteCallSiteId16(
  1550. MutableBufferView image) {
  1551. auto writer =
  1552. base::BindRepeating(WriteTargetIndex<uint16_t>, call_site_map_item_,
  1553. sizeof(dex::CallSiteIdItem));
  1554. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1555. }
  1556. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteMethodHandle16(
  1557. MutableBufferView image) {
  1558. auto writer =
  1559. base::BindRepeating(WriteTargetIndex<uint16_t>, method_handle_map_item_,
  1560. sizeof(dex::MethodHandleItem));
  1561. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1562. }
  1563. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode8(
  1564. MutableBufferView image) {
  1565. auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
  1566. ptrdiff_t unsafe_byte_diff =
  1567. static_cast<ptrdiff_t>(ref.target) - ref.location;
  1568. DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
  1569. // |delta| is relative to start of instruction, which is 1 unit before
  1570. // |ref.location|. The subtraction above removed too much, so +1 to fix.
  1571. base::CheckedNumeric<int8_t> delta((unsafe_byte_diff / kInstrUnitSize) + 1);
  1572. if (!delta.IsValid()) {
  1573. LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
  1574. return;
  1575. }
  1576. image.write<int8_t>(ref.location, delta.ValueOrDie());
  1577. });
  1578. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1579. }
  1580. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode16(
  1581. MutableBufferView image) {
  1582. auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
  1583. ptrdiff_t unsafe_byte_diff =
  1584. static_cast<ptrdiff_t>(ref.target) - ref.location;
  1585. DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
  1586. // |delta| is relative to start of instruction, which is 1 unit before
  1587. // |ref.location|. The subtraction above removed too much, so +1 to fix.
  1588. base::CheckedNumeric<int16_t> delta((unsafe_byte_diff / kInstrUnitSize) +
  1589. 1);
  1590. if (!delta.IsValid()) {
  1591. LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
  1592. return;
  1593. }
  1594. image.write<int16_t>(ref.location, delta.ValueOrDie());
  1595. });
  1596. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1597. }
  1598. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteRelCode32(
  1599. MutableBufferView image) {
  1600. auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
  1601. ptrdiff_t unsafe_byte_diff =
  1602. static_cast<ptrdiff_t>(ref.target) - ref.location;
  1603. DCHECK_EQ(0, unsafe_byte_diff % kInstrUnitSize);
  1604. // |delta| is relative to start of instruction, which is 1 unit before
  1605. // |ref.location|. The subtraction above removed too much, so +1 to fix.
  1606. base::CheckedNumeric<int32_t> delta((unsafe_byte_diff / kInstrUnitSize) +
  1607. 1);
  1608. if (!delta.IsValid()) {
  1609. LOG(ERROR) << "Invalid reference at: " << AsHex<8>(ref.location) << ".";
  1610. return;
  1611. }
  1612. image.write<int32_t>(ref.location, delta.ValueOrDie());
  1613. });
  1614. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1615. }
  1616. std::unique_ptr<ReferenceWriter> DisassemblerDex::MakeWriteAbs32(
  1617. MutableBufferView image) {
  1618. auto writer = base::BindRepeating([](Reference ref, MutableBufferView image) {
  1619. image.write<uint32_t>(ref.location, ref.target);
  1620. });
  1621. return std::make_unique<ReferenceWriterAdaptor>(image, std::move(writer));
  1622. }
  1623. bool DisassemblerDex::Parse(ConstBufferView image) {
  1624. image_ = image;
  1625. return ParseHeader();
  1626. }
  1627. bool DisassemblerDex::ParseHeader() {
  1628. ReadDexHeaderResults results;
  1629. if (!ReadDexHeader(image_, &results))
  1630. return false;
  1631. header_ = results.header;
  1632. dex_version_ = results.dex_version;
  1633. BufferSource source = results.source;
  1634. // DEX header contains file size, so use it to resize |image_| right away.
  1635. image_.shrink(header_->file_size);
  1636. // Read map list. This is not a fixed-size array, so instead of reading
  1637. // MapList directly, read |MapList::size| first, then visit elements in
  1638. // |MapList::list|.
  1639. static_assert(
  1640. offsetof(dex::MapList, list) == sizeof(decltype(dex::MapList::size)),
  1641. "MapList size error.");
  1642. source = std::move(BufferSource(image_).Skip(header_->map_off));
  1643. decltype(dex::MapList::size) list_size = 0;
  1644. if (!source.GetValue(&list_size) || list_size > dex::kMaxItemListSize)
  1645. return false;
  1646. const auto* item_list = source.GetArray<const dex::MapItem>(list_size);
  1647. if (!item_list)
  1648. return false;
  1649. // Read and validate map list, ensuring that required item types are present.
  1650. // GetItemBaseSize() should have an entry for each item.
  1651. for (offset_t i = 0; i < list_size; ++i) {
  1652. const dex::MapItem* item = &item_list[i];
  1653. // Reject unreasonably large |item->size|.
  1654. size_t item_size = GetItemBaseSize(item->type);
  1655. // Confusing name: |item->size| is actually the number of items.
  1656. if (!image_.covers_array(item->offset, item->size, item_size))
  1657. return false;
  1658. if (!map_item_map_.insert(std::make_pair(item->type, item)).second)
  1659. return false; // A given type must appear at most once.
  1660. }
  1661. // Make local copies of main map items.
  1662. if (map_item_map_.count(dex::kTypeStringIdItem)) {
  1663. string_map_item_ = *map_item_map_[dex::kTypeStringIdItem];
  1664. }
  1665. if (map_item_map_.count(dex::kTypeTypeIdItem)) {
  1666. type_map_item_ = *map_item_map_[dex::kTypeTypeIdItem];
  1667. }
  1668. if (map_item_map_.count(dex::kTypeProtoIdItem)) {
  1669. proto_map_item_ = *map_item_map_[dex::kTypeProtoIdItem];
  1670. }
  1671. if (map_item_map_.count(dex::kTypeFieldIdItem)) {
  1672. field_map_item_ = *map_item_map_[dex::kTypeFieldIdItem];
  1673. }
  1674. if (map_item_map_.count(dex::kTypeMethodIdItem)) {
  1675. method_map_item_ = *map_item_map_[dex::kTypeMethodIdItem];
  1676. }
  1677. if (map_item_map_.count(dex::kTypeClassDefItem)) {
  1678. class_def_map_item_ = *map_item_map_[dex::kTypeClassDefItem];
  1679. }
  1680. if (map_item_map_.count(dex::kTypeCallSiteIdItem)) {
  1681. call_site_map_item_ = *map_item_map_[dex::kTypeCallSiteIdItem];
  1682. }
  1683. if (map_item_map_.count(dex::kTypeMethodHandleItem)) {
  1684. method_handle_map_item_ = *map_item_map_[dex::kTypeMethodHandleItem];
  1685. }
  1686. if (map_item_map_.count(dex::kTypeTypeList)) {
  1687. type_list_map_item_ = *map_item_map_[dex::kTypeTypeList];
  1688. }
  1689. if (map_item_map_.count(dex::kTypeAnnotationSetRefList)) {
  1690. annotation_set_ref_list_map_item_ =
  1691. *map_item_map_[dex::kTypeAnnotationSetRefList];
  1692. }
  1693. if (map_item_map_.count(dex::kTypeAnnotationSetItem)) {
  1694. annotation_set_map_item_ = *map_item_map_[dex::kTypeAnnotationSetItem];
  1695. }
  1696. if (map_item_map_.count(dex::kTypeCodeItem)) {
  1697. code_map_item_ = *map_item_map_[dex::kTypeCodeItem];
  1698. }
  1699. if (map_item_map_.count(dex::kTypeAnnotationsDirectoryItem)) {
  1700. annotations_directory_map_item_ =
  1701. *map_item_map_[dex::kTypeAnnotationsDirectoryItem];
  1702. }
  1703. // Iteratively parse variable length lists, annotations directory items, and
  1704. // code items blocks. Any failure would indicate invalid DEX. Success
  1705. // indicates that no structural problem is found. However, contained
  1706. // references data read from parsed items still require validation.
  1707. if (!(ParseItemOffsets(image_, type_list_map_item_, sizeof(dex::TypeItem),
  1708. &type_list_offsets_) &&
  1709. ParseItemOffsets(image_, annotation_set_ref_list_map_item_,
  1710. sizeof(dex::AnnotationSetRefItem),
  1711. &annotation_set_ref_list_offsets_) &&
  1712. ParseItemOffsets(image_, annotation_set_map_item_,
  1713. sizeof(dex::AnnotationOffItem),
  1714. &annotation_set_offsets_) &&
  1715. ParseAnnotationsDirectoryItems(
  1716. image_, annotations_directory_map_item_,
  1717. &annotations_directory_item_offsets_,
  1718. &annotations_directory_item_field_annotation_offsets_,
  1719. &annotations_directory_item_method_annotation_offsets_,
  1720. &annotations_directory_item_parameter_annotation_offsets_))) {
  1721. return false;
  1722. }
  1723. CodeItemParser code_item_parser(image_);
  1724. if (!code_item_parser.Init(code_map_item_))
  1725. return false;
  1726. code_item_offsets_.resize(code_map_item_.size);
  1727. for (size_t i = 0; i < code_map_item_.size; ++i) {
  1728. const offset_t code_item_offset = code_item_parser.GetNext();
  1729. if (code_item_offset == kInvalidOffset)
  1730. return false;
  1731. code_item_offsets_[i] = code_item_offset;
  1732. }
  1733. // DEX files are required to have parsable code items.
  1734. return !code_item_offsets_.empty();
  1735. }
  1736. } // namespace zucchini