本文共 90536 字，大约阅读时间需要 301 分钟。

介绍

想要了解ART，必须先OAT文件格式,。

再描述一下OAT是由ART中的经过dex2oat生成的一个ELF格式的文件，名字却延续DVM中的命名方式，以.dex做扩展名。

虽然是ELF，在使用的过程中确不是直接运行，而是被Map到内存中调用，有点类式SO的使用过程

在系统源码中有代码注释为：

bool ElfWriterQuick::Write(OatWriter& oat_writer,                           const std::vector
   
    & dex_files_unused,                           const std::string& android_root_unused,                           bool is_host_unused) {  const bool debug = false;  // +-------------------------+  // | Elf32_Ehdr              |  // +-------------------------+  // | Elf32_Phdr PHDR         |  // | Elf32_Phdr LOAD R       | .dynsym .dynstr .hash .rodata  // | Elf32_Phdr LOAD R X     | .text  // | Elf32_Phdr LOAD RW      | .dynamic  // | Elf32_Phdr DYNAMIC      | .dynamic  // +-------------------------+  // | .dynsym                 |  // | Elf32_Sym  STN_UNDEF    |  // | Elf32_Sym  oatdata      |  // | Elf32_Sym  oatexec      |  // | Elf32_Sym  oatlastword  |  // +-------------------------+  // | .dynstr                 |  // | \0                      |  // | oatdata\0               |  // | oatexec\0               |  // | oatlastword\0           |  // | boot.oat\0              |  // +-------------------------+  // | .hash                   |  // | Elf32_Word nbucket = 1  |  // | Elf32_Word nchain  = 3  |  // | Elf32_Word bucket[0] = 0|  // | Elf32_Word chain[0]  = 1|  // | Elf32_Word chain[1]  = 2|  // | Elf32_Word chain[2]  = 3|  // +-------------------------+  // | .rodata                 |  // | oatdata..oatexec-4      |  // +-------------------------+  // | .text                   |  // | oatexec..oatlastword    |  // +-------------------------+  // | .dynamic                |  // | Elf32_Dyn DT_SONAME     |  // | Elf32_Dyn DT_HASH       |  // | Elf32_Dyn DT_SYMTAB     |  // | Elf32_Dyn DT_SYMENT     |  // | Elf32_Dyn DT_STRTAB     |  // | Elf32_Dyn DT_STRSZ      |  // | Elf32_Dyn DT_NULL       |  // +-------------------------+  // | .shstrtab               |  // | \0                      |  // | .dynamic\0              |  // | .dynsym\0               |  // | .dynstr\0               |  // | .hash\0                 |  // | .rodata\0               |  // | .text\0                 |  // | .shstrtab\0             |  // +-------------------------+  // | Elf32_Shdr NULL         |  // | Elf32_Shdr .dynsym      |  // | Elf32_Shdr .dynstr      |  // | Elf32_Shdr .hash        |  // | Elf32_Shdr .text        |  // | Elf32_Shdr .rodata      |  // | Elf32_Shdr .dynamic     |  // | Elf32_Shdr .shstrtab    |  // +-------------------------+  // phase 1: computing offsets  uint32_t expected_offset = 0;
   

从IDA打开后，确实看到exports：

实际除了ELF标准的一些信息外，对ART使用只关注这个导出符号的数据。

三个符号可以计算出二段数据

otadata 只读相间产

otaexec 把Dalvik的Bytecode编译生成的二进制可执行数据

oatlastword 用来确定结尾

注：oatdata 包括一段完整的DEX数据

oatdata 数据格式：

在源码中 art/compiler/oat_write.h 中有一段代码：

/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */#ifndef ART_COMPILER_OAT_WRITER_H_#define ART_COMPILER_OAT_WRITER_H_#include 
   
    #include 
    
     #include "driver/compiler_driver.h"#include "mem_map.h"#include "oat.h"#include "mirror/class.h"#include "safe_map.h"#include "UniquePtr.h"namespace art {class OutputStream;// OatHeader         variable length with count of D OatDexFiles//// OatDexFile[0]     one variable sized OatDexFile with offsets to Dex and OatClasses// OatDexFile[1]// ...// OatDexFile[D]//// Dex[0]            one variable sized DexFile for each OatDexFile.// Dex[1]            these are literal copies of the input .dex files.// ...// Dex[D]//// OatClass[0]       one variable sized OatClass for each of C DexFile::ClassDefs// OatClass[1]       contains OatClass entries with class status, offsets to code, etc.// ...// OatClass[C]//// padding           if necessary so that the following code will be page aligned//// CompiledMethod    one variable sized blob with the contents of each CompiledMethod// CompiledMethod// CompiledMethod// CompiledMethod// CompiledMethod// CompiledMethod// ...// CompiledMethod//class OatWriter {
    
   

大致能说明这段数组中的格式为：

OatHeader

OatDexFile 多个

Dex 多个

OatClass 多个

下面的 CompiledMethod，属于oatexec段的

oatexec 数据格式：

上面说到，有多个 CompiledMethod组成

每个CompiledMethod的格式初步解析是这样构成的：

1. 32位的thumb-2指令大小
2. thumb-2指令，共上面大小
3. mapping_table 数据
4. vmap_table 数据
5. gc_map 数据
6. 对齐8字节

下面的3-5数据具体作用还末分析

010模版编写

有了格式，最好就是弄一个二进制格式的分析，为以后留用，先上一张图，再分享模版文件

模版代码：

//-----------------------------------//--- 010 Editor v2.0 Binary Template//// File:     OATTemplate.bt// Author:   tomken// Revision: 1.0// Purpose:  Defines a template for//    parsing OAT files.//-----------------------------------LittleEndian();#define NO_INDEX (0xFFFFFFFF)typedef uint32 Elf32_Addr; // Program addresstypedef uint32 Elf32_Off;  // File offsettypedef uint16 Elf32_Half;typedef uint32 Elf32_Word;typedef int	Elf32_Sword;// Object file magic string.// static const char ElfMagic[] = { 0x7f, 'E', 'L', 'F', '\0' };// e_ident size and indices.typedef enum 
   
     {  EI_MAG0	   = 0,		  // File identification index.  EI_MAG1	   = 1,		  // File identification index.  EI_MAG2	   = 2,		  // File identification index.  EI_MAG3	   = 3,		  // File identification index.  EI_CLASS	  = 4,		  // File class.  EI_DATA	   = 5,		  // Data encoding.  EI_VERSION	= 6,		  // File version.  EI_OSABI	  = 7,		  // OS/ABI identification.  EI_ABIVERSION = 8,		  // ABI version.  EI_PAD		= 9,		  // Start of padding bytes.  EI_NIDENT	 = 16		  // Number of bytes in e_ident.} EI_Type;typedef struct {  unsigned char e_ident[EI_NIDENT]; // ELF Identification bytes  Elf32_Half	e_type;	  // Type of file (see ET_* below)  Elf32_Half	e_machine;   // Required architecture for this file (see EM_*)  Elf32_Word	e_version;   // Must be equal to 1  Elf32_Addr	e_entry;	 // Address to jump to in order to start program  Elf32_Off	 e_phoff;	 // Program header table's file offset, in bytes  Elf32_Off	 e_shoff;	 // Section header table's file offset, in bytes  Elf32_Word	e_flags;	 // Processor-specific flags  Elf32_Half	e_ehsize;	// Size of ELF header, in bytes  Elf32_Half	e_phentsize; // Size of an entry in the program header table  Elf32_Half	e_phnum;	 // Number of entries in the program header table  Elf32_Half	e_shentsize; // Size of an entry in the section header table  Elf32_Half	e_shnum;	 // Number of entries in the section header table  Elf32_Half	e_shstrndx;  // Sect hdr table index of sect name string table} Elf32_Ehdr;// Segment types.enum {  PT_NULL	= 0, // Unused segment.  PT_LOAD	= 1, // Loadable segment.  PT_DYNAMIC = 2, // Dynamic linking information.  PT_INTERP  = 3, // Interpreter pathname.  PT_NOTE	= 4, // Auxiliary information.  PT_SHLIB   = 5, // Reserved.  PT_PHDR	= 6, // The program header table itself.  PT_TLS	 = 7, // The thread-local storage template.  PT_LOOS	= 0x60000000, // Lowest operating system-specific pt entry type.  PT_HIOS	= 0x6fffffff, // Highest operating system-specific pt entry type.  PT_LOPROC  = 0x70000000, // Lowest processor-specific program hdr entry type.  PT_HIPROC  = 0x7fffffff, // Highest processor-specific program hdr entry type.  // x86-64 program header types.  // These all contain stack unwind tables.  PT_GNU_EH_FRAME  = 0x6474e550,  PT_SUNW_EH_FRAME = 0x6474e550,  PT_SUNW_UNWIND   = 0x6464e550,  PT_GNU_STACK  = 0x6474e551, // Indicates stack executability.  PT_GNU_RELRO  = 0x6474e552, // Read-only after relocation.  // ARM program header types.  PT_ARM_ARCHEXT = 0x70000000, // Platform architecture compatibility info  // These all contain stack unwind tables.  PT_ARM_EXIDX   = 0x70000001,  PT_ARM_UNWIND  = 0x70000001};string ReadPhdrType(Elf32_Word flag) {	switch (flag) {		case PT_NULL:	return "null";		case PT_LOAD:	return "load";		case PT_DYNAMIC: return "dynamic";		case PT_INTERP:  return "interp";		case PT_NOTE:	return "note";		case PT_SHLIB:   return "shlib";		case PT_PHDR:	return "phdr";		case PT_TLS:	 return "tls";		case PT_LOOS:	return "loos";		case PT_HIOS:	return "hios";		case PT_LOPROC:  return "loproc";		case PT_HIPROC:  return "hiproc";	}	return "ERROR";}// Program header for ELF32.typedef struct {  Elf32_Word p_type 
    
     ; // Type of segment  Elf32_Off  p_offset; // File offset where segment is located, in bytes  Elf32_Addr p_vaddr;  // Virtual address of beginning of segment  Elf32_Addr p_paddr;  // Physical address of beginning of segment (OS-specific)  Elf32_Word p_filesz; // Num. of bytes in file image of segment (may be zero)  Elf32_Word p_memsz;  // Num. of bytes in mem image of segment (may be zero)  Elf32_Word p_flags;  // Segment flags  Elf32_Word p_align;  // Segment alignment constraint} Elf32_Phdr;local uint section_name_off = 0;local uint dynsym_name_off = 0;local uint oatdata_off = 0;local uint oatexec_off = 0;typedef struct {	Elf32_Word off;	local quad curroff = FTell();	FSeek( section_name_off + off );	string s_name_str;	FSeek( curroff );} Elf32_Shdr_Name;// Section header.typedef struct {  Elf32_Word sh_name 
     
      ;	  // Section name (index into string table)  Elf32_Word sh_type;	  // Section type (SHT_*)  Elf32_Word sh_flags;	 // Section flags (SHF_*)  Elf32_Addr sh_addr;	  // Address where section is to be loaded  Elf32_Off  sh_offset;	// File offset of section data, in bytes  Elf32_Word sh_size;	  // Size of section, in bytes  Elf32_Word sh_link;	  // Section type-specific header table index link  Elf32_Word sh_info;	  // Section type-specific extra information  Elf32_Word sh_addralign; // Section address alignment  Elf32_Word sh_entsize;   // Size of records contained within the section} Elf32_Shdr;string ReadShdrName(Elf32_Word off) {	return ReadString(section_name_off + off);}string ReadDynsymName(Elf32_Word off) {	return ReadString(dynsym_name_off + off);}typedef struct {	Elf32_Word	st_name;  // Symbol name (index into string table)	Elf32_Addr	st_value; // Value or address associated with the symbol	Elf32_Word	st_size;  // Size of the symbol	unsigned char st_info;  // Symbol's type and binding attributes	unsigned char st_other; // Must be zero; reserved	Elf32_Half	st_shndx; // Which section (header table index) it's defined in} Elf32_Sym_Fixed;typedef struct {	Elf32_Word	st_name 
      
       ;  // Symbol name (index into string table)	Elf32_Addr	st_value; // Value or address associated with the symbol	Elf32_Word	st_size;  // Size of the symbol	unsigned char st_info;  // Symbol's type and binding attributes	unsigned char st_other; // Must be zero; reserved	Elf32_Half	st_shndx; // Which section (header table index) it's defined in	if (st_size) {		local quad off = FTell();		FSeek( st_value );		uchar data[st_size];		FSeek( off );	}	local string name = ReadDynsymName(st_name);	if (Strcmp(name, "oatdata") == 0) {		oatdata_off = st_value;	}} Elf32_Sym 
       
        ;// local int iter;int FindNamedSection( string sect ) {	local int i;	local string shdr_nn;		for(i=0; i
        
         ; if(val > 0x7f) { ubyte val 
         
          ; if (val > 0x7f) { ubyte val 
          
           ; if(val > 0x7f) { ubyte val 
           
            ; if(val > 0x7f) { ubyte val 
            
             ; } } } }} uleb128 
             
              ;// get the actual uint value of the uleb128uint uleb128_value(uleb128 &u) { local uint result; local ubyte cur; result = u.val[0]; if(result > 0x7f) { cur = u.val[1]; result = (result & 0x7f) | (uint)((cur & 0x7f) << 7); if(cur > 0x7f) { cur = u.val[2]; result |= (uint)(cur & 0x7f) << 14; if(cur > 0x7f) { cur = u.val[3]; result |= (uint)(cur & 0x7f) << 21; if(cur > 0x7f) { cur = u.val[4]; result |= (uint)cur << 28; } } } } return result;}string ULeb128Read(uleb128 &u) { local string s; s = SPrintf(s, "0x%X", uleb128_value(u)); return s;}typedef struct { char magic_[8]; uint32 checksum_; // See also location_checksum_ uchar signature_[20]; uint32 file_size; // size of entire file uint32 header_size; // offset to start of next section uint32 endian_tag; uint32 link_size; // unused uint32 link_off; // unused uint32 map_off; // unused uint32 string_ids_size; // number of StringIds uint32 string_ids_off; // file offset of StringIds array uint32 type_ids_size; // number of TypeIds, we don't support more than 65535 uint32 type_ids_off; // file offset of TypeIds array uint32 proto_ids_size; // number of ProtoIds, we don't support more than 65535 uint32 proto_ids_off; // file offset of ProtoIds array uint32 field_ids_size; // number of FieldIds uint32 field_ids_off; // file offset of FieldIds array uint32 method_ids_size; // number of MethodIds uint32 method_ids_off; // file offset of MethodIds array uint32 class_defs_size; // number of ClassDefs uint32 class_defs_off; // file offset of ClassDef array uint32 data_size; // unused uint32 data_off; // unused} DexFileHeader;local int odexpad = 0;//// String IDs//typedef struct { uleb128 utf16_size 
              
               ; string data 
               
                ;} DexFileStringItem;typedef struct { uint string_data_off 
                
                 ; local int64 pos = FTell(); FSeek(odexpad + string_data_off); DexFileStringItem string_data 
                 
                  ; FSeek(pos);} DexFileStringId 
                  
                   ;string StringDataReader(DexFileStringId &i) { return i.string_data.data;}typedef struct (int size) { local int s = size; DexFileStringId string_ids[size] 
                   
                    ;} DexFileStringIds 
                    
                     ;string StringIDListRead(DexFileStringIds &l) { string s; s = SPrintf(s, "%d strings", l.s); return s;}//// type IDs//// read a value from the string tablestring StringIdRead(int id) { if(id == NO_INDEX) { return "NO_INDEX"; } local string s; SPrintf(s, "(0x%.X) \"%s\"", id, GetStringById(id)); return s;}// read a string from the string tablestring GetStringById(int id) { if(id == NO_INDEX) { return "NO_INDEX"; } if(exists(dex_string_ids.string_id[id])) { return dex_string_ids.string_id[id].string_data.data; } else { return "*** NO STRING"; }}string GetTypeById(struct DexFile& dexfile, int id) { if(id == NO_INDEX) { return "NO_INDEX"; } if(exists(dex_type_ids.type_id[id])) { return GetStringById2(dexfile, dexfile.dex_type_ids.type_id[id].descriptor_idx); } else { return "*** NO TYPE"; }}string GetLongTypeDescriptor(string descriptor) { local string desc = ""; local string post = ""; local int i = 0; local int len = Strlen(descriptor); // array descriptors while(descriptor[i] == '[') { post += "[]"; i++; if(i >= len) return "ERROR"; } if(descriptor[i] == 'L') { // fully qualified class descriptors i++; while(i < len) { if(descriptor[i] == '/') desc += "."; else if(descriptor[i] == ';') break; else desc += descriptor[i]; i++; } } else { // simple type descriptors switch(descriptor[i]) { case 'V': desc = "void"; break; case 'Z': desc = "boolean"; break; case 'B': desc = "byte"; break; case 'S': desc = "short"; break; case 'C': desc = "char"; break; case 'I': desc = "int"; break; case 'J': desc = "long"; break; case 'F': desc = "float"; break; case 'D': desc = "double"; break; } } return desc + post;}string GetLongTypeById(int id) { return GetLongTypeDescriptor(GetTypeById(id));}string GetMethodById(int id) { if(id == NO_INDEX) { return "NO_INDEX"; } if(exists(dex_method_ids.method_id[id])) { return MethodIdItemRead(dex_method_ids.method_id[id]); } else { return "*** NO METHOD"; }}string GetFieldById(int id) { if(id == NO_INDEX) { return "NO_INDEX"; } if(exists(dex_field_ids.field_id[id])) { return FieldIdItemRead(dex_field_ids.field_id[id]); } else { return "*** NO FIELD"; }}typedef struct { uint descriptor_idx 
                     
                      ; local string name = GetStringById2(parentof(parentof(this)), descriptor_idx);} DexFileTypeId 
                      
                       ;string GetStringById2(struct DexFile& dexfile, int id) { if(id == NO_INDEX) { return "NO_INDEX"; } if(exists(dexfile.dex_string_ids.string_ids[id])) { return dexfile.dex_string_ids.string_ids[id].string_data.data; } else { return "*** NO STRING"; }}string TypeIDRead(DexFileTypeId &i) { return i.name;}typedef struct (int size) { local int s = size; DexFileTypeId type_id[size] 
                       
                        ;} DexFileTypeIds 
                        
                         ;string TypeIDListRead(DexFileTypeIds &l) { string s; s = SPrintf(s, "%d types", l.s); return s;}// proto typedef struct { ushort type_idx 
                         
                          ; local string type = GetLongTypeDescriptor(GetTypeById(parentof(parentof(parentof(parentof(this)))), return_type_idx));} DexFileTypeItem 
                          
                           ;typedef struct { uint size 
                           
                            ; DexFileTypeItem list[size] 
                            
                             ;} DexFileTypeList 
                             
                              ;string TypeItemRead(DexFileTypeItem &t) { return t.type;}string TypeItemListRead(DexFileTypeList &l) { string s = ""; string tmp; int i; for(i = 0; i < l.size; i++) { s += l.list[i].type; if(i+1 < l.size) { s += ", "; } } return s;}typedef struct { uint shorty_idx 
                              
                               ; local string shorty = GetStringById2(parentof(parentof(this)), shorty_idx); uint return_type_idx 
                               
                                ; local string return_type = GetLongTypeDescriptor(GetTypeById(parentof(parentof(this)), return_type_idx)); uint parameters_off 
                                
                                 ; if(parameters_off != 0) { local int64 pos = FTell(); FSeek(odexpad + parameters_off); DexFileTypeList parameters 
                                 
                                  ; FSeek(pos); }} DexFileProtoId 
                                  
                                   ;string ProtoIDItemRead(DexFileProtoId &i) { return GetPrototypeSignature(i);}string GetParameterListString(DexFileTypeList &l) { local string s = "("; local string tmp; local int i; for(i = 0; i < l.size; i++) { s += l.list[i].type; if(i+1 < l.size) { s += ", "; } } return s + ")";}string GetPrototypeSignature(DexFileProtoId &item) { string ret = item.return_type; string params = "()"; if(exists(item.parameters)) { params = GetParameterListString(item.parameters); } return ret + " " + params;}typedef struct (int size) { local int s = size; DexFileProtoId proto_id[size] 
                                   
                                    ;} DexFileProtoIds 
                                    
                                     ;string ProtoIDListRead(DexFileProtoIds &l) { string s; s = SPrintf(s, "%d protot ypes", l.s); return s;}//// fields//typedef struct { ushort class_idx 
                                     
                                      ; local string class = GetLongTypeDescriptor(GetTypeById(parentof(parentof(this)), class_idx)); ushort type_idx 
                                      
                                       ; local string type = GetLongTypeDescriptor(GetTypeById(parentof(parentof(this)), type_idx)); uint name_idx 
                                       
                                        ; local string name = GetStringById2(parentof(parentof(this)), name_idx); } DexFileFieldId 
                                        
                                         ;string FieldIdItemRead(DexFileFieldId &i) { return i.type + " " + i.class + " : " + i.name;}typedef struct (int size) { local int s = size; DexFileFieldId field_id[size] 
                                         
                                          ;} DexFileFieldIds 
                                          
                                           ;string FieldIDListRead(DexFileFieldIds &l) { string s; s = SPrintf(s, "%d fields", l.s); return s;}//// methods//typedef struct { ushort class_idx 
                                           
                                            ; local string class = GetLongTypeDescriptor(GetTypeById(parentof(parentof(this)), class_idx)); ushort proto_idx 
                                            
                                             ; local string proto = ""; uint name_idx 
                                             
                                              ; local string name = GetStringById2(parentof(parentof(this)), name_idx);} DexFileMethodId 
                                              
                                               ;string ProtoIdxRead(ushort p) { string s; SPrintf(s, "(0x%X) %s", p, GetPrototypeSignature(dex_proto_ids.proto_id[p])); return s;}string MethodIdItemRead(DexFileMethodId &m) {// local string retval = GetLongTypeDescriptor(GetTypeById(dex_proto_ids.proto_id[m.proto_idx].return_type_idx));// local string classname = GetLongTypeDescriptor(GetStringById(dex_type_ids.type_id[m.class_idx].descriptor_idx));// local string methodname = GetStringById(m.name_idx);// local string params = "()";// if(exists(dex_proto_ids.proto_id[m.proto_idx].parameters)) {// params = GetParameterListString(dex_proto_ids.proto_id[m.proto_idx].parameters);// } return m.proto + " " + m.class + "." + m.name;}typedef struct (int size) { local int s = size; DexFileMethodId method_id[size] 
                                               
                                                ;} DexFileMethodIds 
                                                
                                                 ;string MethodIDListRead(DexFileMethodIds &l) { string s; s = SPrintf(s, "%d methods", l.s); return s;}// access flags. some of these mean different things for different items (class/field/method)typedef enum 
                                                 
                                                   { ACC_PUBLIC = 0x1, ACC_PRIVATE = 0x2, ACC_PROTECTED = 0x4, ACC_STATIC = 0x8, ACC_FINAL = 0x10, ACC_SYNCHRONIZED = 0x20, ACC_VOLATILE = 0x40, // field //ACC_BRIDGE = 0x40, // method ACC_TRANSIENT = 0x80, // field //ACC_VARARGS = 0x80, // method ACC_NATIVE = 0x100, ACC_INTERFACE = 0x200, ACC_ABSTRACT = 0x400, ACC_STRICT = 0x800, ACC_SYNTHETIC = 0x1000, ACC_ANNOTATION = 0x2000, ACC_ENUM = 0x4000, ACC_CONSTRUCTOR = 0x10000, ACC_DECLARED_SYNCHRONIZED = 0x20000} ACCESS_FLAGS 
                                                  
                                                   ;string AccessFlagsRead(ACCESS_FLAGS f) { string ret = ""; string flags = ""; ACCESS_FLAGS i = 1; while(i <= ACC_DECLARED_SYNCHRONIZED) { if (f & i) { flags += EnumToString(i) + " "; } i = i << 1; } SPrintf(ret, "(0x%X) %s", f, flags); return ret;}typedef enum { AF_CLASS, AF_FIELD, AF_METHOD} AF_TYPE;string GetFriendlyAccessFlag(int flag, AF_TYPE type) { switch (flag) { case ACC_PUBLIC: return "public"; case ACC_PRIVATE: return "private"; case ACC_PROTECTED: return "protected"; case ACC_STATIC: return "static"; case ACC_FINAL: return "final"; case ACC_SYNCHRONIZED: return "synchronized"; case ACC_VOLATILE: if(type == AF_FIELD) return "volatile"; else return "bridge"; // 0x40 is 'bridge' for methods case ACC_TRANSIENT: if(type == AF_FIELD) return "transient"; else return "varargs"; // 0x80 is 'varargs' for methods case ACC_NATIVE: return "native"; case ACC_INTERFACE: return "interface"; case ACC_ABSTRACT: return "abstract"; case ACC_STRICT: return "strict"; case ACC_SYNTHETIC: return "synthetic"; case ACC_ANNOTATION: return "annotation"; case ACC_ENUM: return "enum"; case ACC_CONSTRUCTOR: return "constructor"; case ACC_DECLARED_SYNCHRONIZED: return "declared-synchronized"; } return "ERROR";}string GetFriendlyAccessFlags(ACCESS_FLAGS f, AF_TYPE type) { string flags = ""; ACCESS_FLAGS i = 1; while(i <= ACC_DECLARED_SYNCHRONIZED) { if (f & i) { flags += GetFriendlyAccessFlag(i, type) + " "; } i = i << 1; } return flags;}typedef struct { uleb128 static_fields_size 
                                                   
                                                    ; uleb128 instance_fields_size 
                                                    
                                                     ; uleb128 direct_methods_size 
                                                     
                                                      ; uleb128 virtual_methods_size 
                                                      
                                                       ; if(uleb128_value(static_fields_size) > 0) {// encoded_field_list static_fields(uleb128_value(static_fields_size)) 
                                                       
                                                        ; } if(uleb128_value(instance_fields_size) > 0) {// encoded_field_list instance_fields(uleb128_value(instance_fields_size)) 
                                                        
                                                         ; } if(uleb128_value(direct_methods_size) > 0) {// encoded_method_list direct_methods(uleb128_value(direct_methods_size)) 
                                                         
                                                          ; } if(uleb128_value(virtual_methods_size) > 0) {// encoded_method_list virtual_methods(uleb128_value(virtual_methods_size)) 
                                                          
                                                           ; }} DexFileClassData 
                                                           
                                                            ;string ClassDataItemRead(DexFileClassData &i) { local string s; SPrintf(s, "%i static fields, %i instance fields, %i direct methods, %i virtual methods", uleb128_value(i.static_fields_size), uleb128_value(i.instance_fields_size), uleb128_value(i.direct_methods_size), uleb128_value(i.virtual_methods_size)); return s;}typedef struct { local int64 pos; uint class_idx 
                                                            
                                                             ; local string class = GetLongTypeDescriptor(GetTypeById(parentof(parentof(this)), class_idx)); ACCESS_FLAGS access_flags 
                                                             
                                                              ; uint superclass_idx 
                                                              
                                                               ; local string superclass = GetLongTypeDescriptor(GetTypeById(parentof(parentof(this)), superclass_idx)); uint interfaces_off 
                                                               
                                                                ; if(interfaces_off != 0) { pos = FTell(); FSeek(odexpad + interfaces_off); // type_item_list interfaces 
                                                                
                                                                 ; FSeek(pos); } uint source_file_idx 
                                                                 
                                                                  ; local string source_path = GetStringById2(parentof(parentof(this)), source_file_idx); uint annotations_off 
                                                                  
                                                                   ; if(annotations_off != 0) { pos = FTell(); FSeek(odexpad + annotations_off); // annotations_directory_item annotations 
                                                                   
                                                                    ; FSeek(pos); } uint class_data_off 
                                                                    
                                                                     ; if(class_data_off != 0) { pos = FTell(); FSeek(odexpad + class_data_off); DexFileClassData class_data 
                                                                     
                                                                      ; FSeek(pos); } uint static_values_off 
                                                                      
                                                                       ; if(static_values_off != 0) { pos = FTell(); FSeek(odexpad + static_values_off); // struct encoded_array_item static_values 
                                                                       
                                                                        ; FSeek(pos); }} DexFileClassDefItem 
                                                                        
                                                                         ;string ClassDefItemRead(DexFileClassDefItem &i) { local string flags = GetFriendlyAccessFlags(i.access_flags, AF_CLASS); return flags + i.class;}typedef struct (int size) { local int s = size; DexFileClassDefItem class_def[size] 
                                                                         
                                                                          ;} DexFileClassDefs 
                                                                          
                                                                           ;string ClassDefItemListRead(DexFileClassDefs &l) { string s; s = SPrintf(s, "%d classes", l.s); return s;}//// map list//enum 
                                                                           
                                                                             TYPE_CODES { TYPE_HEADER_ITEM = 0x0000, TYPE_STRING_ID_ITEM = 0x0001, TYPE_TYPE_ID_ITEM = 0x0002, TYPE_PROTO_ID_ITEM = 0x0003, TYPE_FIELD_ID_ITEM = 0x0004, TYPE_METHOD_ID_ITEM = 0x0005, TYPE_CLASS_DEF_ITEM = 0x0006, TYPE_MAP_LIST = 0x1000, TYPE_TYPE_LIST = 0x1001, TYPE_ANNOTATION_SET_REF_LIST = 0x1002, TYPE_ANNOTATION_SET_ITEM = 0x1003, TYPE_CLASS_DATA_ITEM = 0x2000, TYPE_CODE_ITEM = 0x2001, TYPE_STRING_DATA_ITEM = 0x2002, TYPE_DEBUG_INFO_ITEM = 0x2003, TYPE_ANNOTATION_ITEM = 0x2004, TYPE_ENCODED_ARRAY_ITEM = 0x2005, TYPE_ANNOTATIONS_DIRECTORY_ITEM = 0x2006};typedef struct { TYPE_CODES type; ushort unused; uint size; uint offset; } DexFileMapItem 
                                                                            
                                                                             ;string MapItemRead(DexFileMapItem &m) { string s; SPrintf(s, "%s", EnumToString(m.type)); return s;}typedef struct { uint size; DexFileMapItem list[size];} DexFileMapList 
                                                                             
                                                                              ;string MapListTypeRead(DexFileMapList &t) { local string s; SPrintf(s, "%i items", t.size); return s;}//// dex file//typedef struct { DexFileHeader header; if(header.map_off != 0) { FSeek(odexpad + header.map_off); DexFileMapList dex_map_list 
                                                                              
                                                                               ; local int i; for (i=0; i
                                                                               
                                                                                ; } else if (dex_map_list.list[i].type == TYPE_TYPE_ID_ITEM) { DexFileTypeIds dex_type_ids(header.type_ids_size) 
                                                                                
                                                                                 ; } else if (dex_map_list.list[i].type == TYPE_PROTO_ID_ITEM) { DexFileProtoIds dex_proto_ids(header.proto_ids_size) 
                                                                                 
                                                                                  ; } else if (dex_map_list.list[i].type == TYPE_FIELD_ID_ITEM) { DexFileFieldIds dex_field_ids(header.field_ids_size) 
                                                                                  
                                                                                   ; } else if (dex_map_list.list[i].type == TYPE_METHOD_ID_ITEM) { DexFileMethodIds dex_method_ids(header.method_ids_size) 
                                                                                   
                                                                                    ; } else if (dex_map_list.list[i].type == TYPE_CLASS_DEF_ITEM) { DexFileClassDefs dex_class_defs(header.class_defs_size) 
                                                                                    
                                                                                     ; } else { // uint UNPROCESS_TYPE = dex_map_list.list[i].type; } } }} DexFile;typedef struct { uint32 code_offset_; uint32 frame_size_in_bytes_; uint32 core_spill_mask_; uint32 fp_spill_mask_; uint32 mapping_table_offset_; uint32 vmap_table_offset_; uint32 gc_map_offset_; local uint32 off = code_offset_ & ~0x1; if (off > 0) { Printf("code_offset [%x][%x] = %x\n", code_offset_, off, off + 0x1000); }} OatMethodOffsets;typedef struct (int index) { uint32 status; local int methodCount = getClassMethodCount(parentof(parentof(this)), index); local string name = getClassName(parentof(parentof(this)), index); if (methodCount > 0) { OatMethodOffsets methodOffset[methodCount] 
                                                                                     
                                                                                      ; }} OatClass 
                                                                                      
                                                                                       ;string ReadOatClass(OatClass &c) { return c.name;}typedef struct (int size) { local int total = size; local int idx; for (idx=0; idx
                                                                                       
                                                                                        ;string ReadOatClasses(OatClasses &oc) { local string s; SPrintf(s, "%i classes", oc.total); return s;}string getClassName(struct OatDexFile& oatfile, int classIdx) { if (exists(oatfile.dex_file.dex_class_defs.class_def[classIdx])) { return oatfile.dex_file.dex_class_defs.class_def[classIdx].class; } return "** NO NAME **";}int getClassMethodCount(struct OatDexFile& oatfile, int classIdx) { if (exists(oatfile.dex_file.dex_class_defs.class_def[classIdx])) { if (exists(oatfile.dex_file.dex_class_defs.class_def[classIdx].class_data)) { local int dirNum = uleb128_value(oatfile.dex_file.dex_class_defs.class_def[classIdx].class_data.direct_methods_size); local int virNum = uleb128_value(oatfile.dex_file.dex_class_defs.class_def[classIdx].class_data.virtual_methods_size); return dirNum + virNum; } } return 0;}typedef struct { uint32 dex_file_location_size; char dex_file_location_data[dex_file_location_size]; uint32 dex_file_checksum; uint32 dex_file_offset; local quad off = FTell(); local quad method_count = (oatdata_off + dex_file_offset - off) / sizeof(uint32); uint32 method_offs[method_count]; odexpad = oatdata_off + dex_file_offset; FSeek(oatdata_off + dex_file_offset); DexFile dex_file; FSeek(oatdata_off + dex_file_offset + dex_file.header.file_size); OatClasses oat_classes(dex_file.header.class_defs_size) ; } OatDexFile 
                                                                                        
                                                                                         ;typedef struct { char magic[4]; char version[4]; uint32 checksum; InstructionSet instruction_set; uint32 dex_file_count; uint32 executable_offset_; uint32 interpreter_to_interpreter_bridge_offset_; uint32 interpreter_to_compiled_code_bridge_offset_; uint32 jni_dlsym_lookup_offset_; uint32 portable_resolution_trampoline_offset_; uint32 portable_to_interpreter_bridge_offset_; uint32 quick_resolution_trampoline_offset_; uint32 quick_to_interpreter_bridge_offset_; uint32 image_file_location_oat_checksum_; uint32 image_file_location_oat_data_begin_; uint32 image_file_location_size; char image_file_location_data[image_file_location_size];} OatHeader;struct { Elf32_Ehdr elf_header; if (elf_header.e_phnum > 0) { FSeek(elf_header.e_phoff); Elf32_Phdr elf_program_header[elf_header.e_phnum]; } local uint soff = elf_header.e_shoff + elf_header.e_shentsize * elf_header.e_shstrndx; section_name_off = ReadUInt(soff + 3 * sizeof( Elf32_Word ) + sizeof( Elf32_Addr )); // Printf("section_name_off=%x", section_name_off); if (elf_header.e_shnum > 0) { FSeek(elf_header.e_shoff); Elf32_Shdr elf_section_header[elf_header.e_shnum] 
                                                                                         
                                                                                          ; local uint strindex = FindNamedSection(".dynstr"); dynsym_name_off = elf_section_header[strindex].sh_offset; local uint symindex = FindNamedSection(".dynsym"); local uint symcount = elf_section_header[symindex].sh_size / sizeof(Elf32_Sym_Fixed); FSeek(elf_section_header[symindex].sh_offset); // dynsym Elf32_Sym symtab[symcount] 
                                                                                          
                                                                                           ; // dynstr if (elf_section_header[strindex].sh_size > 0) { local quad off = FTell(); FSeek( dynsym_name_off ); char dynstr[elf_section_header[strindex].sh_size]; FSeek( off ); } // hash local uint hashindex = FindNamedSection(".hash"); FSeek( elf_section_header[hashindex].sh_offset ); Elf32_Word hash[elf_section_header[hashindex].sh_size]; // rodata local uint rodataindex = FindNamedSection(".rodata"); FSeek( elf_section_header[rodataindex].sh_offset ); uchar rodata[elf_section_header[rodataindex].sh_size]; // text local uint textindex = FindNamedSection(".text"); FSeek( elf_section_header[textindex].sh_offset ); uchar text[elf_section_header[textindex].sh_size]; // dynamic local uint dynamicindex = FindNamedSection(".dynamic"); FSeek( elf_section_header[dynamicindex].sh_offset ); uchar dynamic[elf_section_header[dynamicindex].sh_size]; // shstrtab local uint shstrtabindex = FindNamedSection(".shstrtab"); FSeek( elf_section_header[shstrtabindex].sh_offset ); char shstrtab[elf_section_header[shstrtabindex].sh_size]; } if (oatdata_off > 0) { FSeek(oatdata_off); OatHeader oat_header; OatDexFile dex_files[oat_header.dex_file_count]; }} file;
                                                                                          
                                                                                         
                                                                                        
                                                                                       
                                                                                      
                                                                                     
                                                                                    
                                                                                   
                                                                                  
                                                                                 
                                                                                
                                                                               
                                                                              
                                                                             
                                                                            
                                                                           
                                                                          
                                                                         
                                                                        
                                                                       
                                                                      
                                                                     
                                                                    
                                                                   
                                                                  
                                                                 
                                                                
                                                               
                                                              
                                                             
                                                            
                                                           
                                                          
                                                         
                                                        
                                                       
                                                      
                                                     
                                                    
                                                   
                                                  
                                                 
                                                
                                               
                                              
                                             
                                            
                                           
                                          
                                         
                                        
                                       
                                      
                                     
                                    
                                   
                                  
                                 
                                
                               
                              
                             
                            
                           
                          
                         
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     
    
   

最后：

模版让使用者有过优化或改进，请反馈给我，在这里先感谢一下。

bool OatFile::ElfFileOpen(File* file, byte* requested_base, bool writable, bool executable) {  elf_file_.reset(ElfFile::Open(file, writable, true));  if (elf_file_.get() == NULL) {    if (writable) {      PLOG(WARNING) << "Failed to open ELF file for " << file->GetPath();    }    return false;  }  ......

ElfFile* ElfFile::Open(File* file, bool writable, bool program_header_only) {  UniquePtr
    
      elf_file(new ElfFile());  if (!elf_file->Setup(file, writable, program_header_only)) {    return NULL;  }  return elf_file.release();}
    

bool ElfFile::Setup(File* file, bool writable, bool program_header_only) {  CHECK(file != NULL);  file_ = file;  writable_ = writable;  program_header_only_ = program_header_only;  int prot;  int flags;  if (writable_) {    prot = PROT_READ | PROT_WRITE;    flags = MAP_SHARED;  } else {    prot = PROT_READ;    flags = MAP_PRIVATE;  }  int64_t file_length = file_->GetLength();  if (file_length < 0) {    errno = -file_length;    PLOG(WARNING) << "Failed to get length of file: " << file_->GetPath() << " fd=" << file_->Fd();    return false;  }  if (file_length < sizeof(llvm::ELF::Elf32_Ehdr)) {    if (writable) {      LOG(WARNING) << "File size of " << file_length                   << " bytes not large enough to contain ELF header of "                   << sizeof(llvm::ELF::Elf32_Ehdr) << " bytes: " << file_->GetPath();    }    return false;  }  if (program_header_only) {    // first just map ELF header to get program header size information    size_t elf_header_size = sizeof(llvm::ELF::Elf32_Ehdr);    if (!SetMap(MemMap::MapFile(elf_header_size, prot, flags, file_->Fd(), 0))) {      return false;    }    // then remap to cover program header    size_t program_header_size = header_->e_phoff + (header_->e_phentsize * header_->e_phnum);    if (file_length < program_header_size) {      LOG(WARNING) << "File size of " << file_length                   << " bytes not large enough to contain ELF program header of "                   << program_header_size << " bytes: " << file_->GetPath();      return false;    }    if (!SetMap(MemMap::MapFile(program_header_size, prot, flags, file_->Fd(), 0))) {      LOG(WARNING) << "Failed to map ELF program headers: " << file_->GetPath();      return false;    }  } else {    ......    }  }  // Either way, the program header is relative to the elf header  program_headers_start_ = Begin() + GetHeader().e_phoff;  if (!program_header_only) {     ......  }  return true;}

static MemMap* MapFile(size_t byte_count, int prot, int flags, int fd, off_t start) {    return MapFileAtAddress(NULL, byte_count, prot, flags, fd, start, false);  }

MemMap* MemMap::MapFileAtAddress(byte* addr, size_t byte_count,                                 int prot, int flags, int fd, off_t start, bool reuse) {  CHECK_NE(0, prot);  CHECK_NE(0, flags & (MAP_SHARED | MAP_PRIVATE));  if (byte_count == 0) {    return new MemMap("file", NULL, 0, NULL, 0, prot);  }  // Adjust 'offset' to be page-aligned as required by mmap.  int page_offset = start % kPageSize;  off_t page_aligned_offset = start - page_offset;  // Adjust 'byte_count' to be page-aligned as we will map this anyway.  size_t page_aligned_byte_count = RoundUp(byte_count + page_offset, kPageSize);  // The 'addr' is modified (if specified, ie non-null) to be page aligned to the file but not  // necessarily to virtual memory. mmap will page align 'addr' for us.  byte* page_aligned_addr = (addr == NULL) ? NULL : (addr - page_offset);  if (!reuse) {    // reuse means it is okay that it overlaps an existing page mapping.    // Only use this if you actually made the page reservation yourself.    CheckMapRequest(page_aligned_addr, page_aligned_byte_count);  } else {    CHECK(addr != NULL);  }  byte* actual = reinterpret_cast
    
     (mmap(page_aligned_addr,                                              page_aligned_byte_count,                                              prot,                                              flags,                                              fd,                                              page_aligned_offset));  if (actual == MAP_FAILED) {    std::string maps;    ReadFileToString("/proc/self/maps", &maps);    PLOG(ERROR) << "mmap(" << reinterpret_cast
     
      (page_aligned_addr)                << ", " << page_aligned_byte_count                << ", " << prot << ", " << flags << ", " << fd << ", " << page_aligned_offset                << ") failed\n" << maps;    return NULL;  }  return new MemMap("file", actual + page_offset, byte_count, actual, page_aligned_byte_count,                    prot);}
     
    

bool ElfFile::SetMap(MemMap* map) {  if (map == NULL) {    // MemMap::Open should have already logged    return false;  }  map_.reset(map);  CHECK(map_.get() != NULL) << file_->GetPath();  CHECK(map_->Begin() != NULL) << file_->GetPath();  header_ = reinterpret_cast
    
     (map_->Begin());  if ((llvm::ELF::ElfMagic[0] != header_->e_ident[llvm::ELF::EI_MAG0])      || (llvm::ELF::ElfMagic[1] != header_->e_ident[llvm::ELF::EI_MAG1])      || (llvm::ELF::ElfMagic[2] != header_->e_ident[llvm::ELF::EI_MAG2])      || (llvm::ELF::ElfMagic[3] != header_->e_ident[llvm::ELF::EI_MAG3])) {    LOG(WARNING) << "Failed to find ELF magic in " << file_->GetPath()                 << ": " << std::hex                 << static_cast
     
      (header_->e_ident[llvm::ELF::EI_MAG0])                 << static_cast
      
       (header_->e_ident[llvm::ELF::EI_MAG1])                 << static_cast
       
        (header_->e_ident[llvm::ELF::EI_MAG2])                 << static_cast
        
         (header_->e_ident[llvm::ELF::EI_MAG3]);    return false;  }  ......    return true;}
        
       
      
     
    

llvm::ELF::ElfMagic[0] = 0x7f;llvm::ELF::ElfMagic[1] = 'E';llvm::ELF::ElfMagic[2] = 'L';llvm::ELF::ElfMagic[3] = 'F';

bool loaded = elf_file_->Load(executable);  if (!loaded) {    LOG(WARNING) << "Failed to load ELF file " << file->GetPath();    return false;  }

bool ElfFile::Load(bool executable) {  CHECK(program_header_only_) << file_->GetPath();  for (llvm::ELF::Elf32_Word i = 0; i < GetProgramHeaderNum(); i++) {    llvm::ELF::Elf32_Phdr& program_header = GetProgramHeader(i);    // Record .dynamic header information for later use    if (program_header.p_type == llvm::ELF::PT_DYNAMIC) {      dynamic_program_header_ = &program_header;      continue;    }    // Not something to load, move on.    if (program_header.p_type != llvm::ELF::PT_LOAD) {      continue;    }    int64_t file_length = file_->GetLength();    if (program_header.p_vaddr == 0) {      std::string reservation_name("ElfFile reservation for ");      reservation_name += file_->GetPath();      UniquePtr
    
      reserve(MemMap::MapAnonymous(reservation_name.c_str(),                                                     NULL, GetLoadedSize(), PROT_NONE));      CHECK(reserve.get() != NULL) << file_->GetPath();      base_address_ = reserve->Begin();      segments_.push_back(reserve.release());    }    // empty segment, nothing to map    if (program_header.p_memsz == 0) {      continue;    }    ......
    

MemMap* MemMap::MapAnonymous(const char* name, byte* addr, size_t byte_count, int prot) {  if (byte_count == 0) {    return new MemMap(name, NULL, 0, NULL, 0, prot);  }  size_t page_aligned_byte_count = RoundUp(byte_count, kPageSize);  CheckMapRequest(addr, page_aligned_byte_count);#ifdef USE_ASHMEM  // android_os_Debug.cpp read_mapinfo assumes all ashmem regions associated with the VM are  // prefixed "dalvik-".  std::string debug_friendly_name("dalvik-");  debug_friendly_name += name;  ScopedFd fd(ashmem_create_region(debug_friendly_name.c_str(), page_aligned_byte_count));  int flags = MAP_PRIVATE;  if (fd.get() == -1) {    PLOG(ERROR) << "ashmem_create_region failed (" << name << ")";    return NULL;  }#else  ScopedFd fd(-1);  int flags = MAP_PRIVATE | MAP_ANONYMOUS;#endif  byte* actual = reinterpret_cast
    
     (mmap(addr, page_aligned_byte_count, prot, flags, fd.get(), 0));  if (actual == MAP_FAILED) {    std::string maps;    ReadFileToString("/proc/self/maps", &maps);    PLOG(ERROR) << "mmap(" << reinterpret_cast
     
      (addr) << ", " << page_aligned_byte_count                << ", " << prot << ", " << flags << ", " << fd.get() << ", 0) failed for " << name                << "\n" << maps;    return NULL;  }  return new MemMap(name, actual, byte_count, actual, page_aligned_byte_count, prot);}
     
    

size_t ElfFile::GetLoadedSize() {  llvm::ELF::Elf32_Addr min_vaddr = 0xFFFFFFFFu;  llvm::ELF::Elf32_Addr max_vaddr = 0x00000000u;  for (llvm::ELF::Elf32_Word i = 0; i < GetProgramHeaderNum(); i++) {    llvm::ELF::Elf32_Phdr& program_header = GetProgramHeader(i);    if (program_header.p_type != llvm::ELF::PT_LOAD) {      continue;    }    llvm::ELF::Elf32_Addr begin_vaddr = program_header.p_vaddr;    if (begin_vaddr < min_vaddr) {       min_vaddr = begin_vaddr;    }    llvm::ELF::Elf32_Addr end_vaddr = program_header.p_vaddr + program_header.p_memsz;    if (end_vaddr > max_vaddr) {      max_vaddr = end_vaddr;    }  }  min_vaddr = RoundDown(min_vaddr, kPageSize);  max_vaddr = RoundUp(max_vaddr, kPageSize);  CHECK_LT(min_vaddr, max_vaddr) << file_->GetPath();  size_t loaded_size = max_vaddr - min_vaddr;  return loaded_size;}

byte* p_vaddr = base_address_ + program_header.p_vaddr;    int prot = 0;    if (executable && ((program_header.p_flags & llvm::ELF::PF_X) != 0)) {      prot |= PROT_EXEC;    }    if ((program_header.p_flags & llvm::ELF::PF_W) != 0) {      prot |= PROT_WRITE;    }    if ((program_header.p_flags & llvm::ELF::PF_R) != 0) {      prot |= PROT_READ;    }    int flags = MAP_FIXED;    if (writable_) {      prot |= PROT_WRITE;      flags |= MAP_SHARED;    } else {      flags |= MAP_PRIVATE;    }    if (file_length < (program_header.p_offset + program_header.p_memsz)) {      LOG(WARNING) << "File size of " << file_length                   << " bytes not large enough to contain ELF segment " << i                   << " of " << (program_header.p_offset + program_header.p_memsz)                   << " bytes: " << file_->GetPath();      return false;    }    UniquePtr
    
      segment(MemMap::MapFileAtAddress(p_vaddr,                                                       program_header.p_memsz,                                                       prot, flags, file_->Fd(),                                                       program_header.p_offset,                                                       true));    CHECK(segment.get() != NULL) << file_->GetPath();    CHECK_EQ(segment->Begin(), p_vaddr) << file_->GetPath();    segments_.push_back(segment.release());  }
    

dynamic_section_start_      = reinterpret_cast
    
     (base_address_ + GetDynamicProgramHeader().p_vaddr);  for (llvm::ELF::Elf32_Word i = 0; i < GetDynamicNum(); i++) {    llvm::ELF::Elf32_Dyn& elf_dyn = GetDynamic(i);    byte* d_ptr = base_address_ + elf_dyn.d_un.d_ptr;    switch (elf_dyn.d_tag) {      case llvm::ELF::DT_HASH: {        hash_section_start_ = reinterpret_cast
     
      (d_ptr);        break;      }      case llvm::ELF::DT_STRTAB: {        dynstr_section_start_ = reinterpret_cast
      
       (d_ptr);        break;      }      case llvm::ELF::DT_SYMTAB: {        dynsym_section_start_ = reinterpret_cast
       
        (d_ptr);        break;      }      case llvm::ELF::DT_NULL: {        CHECK_EQ(GetDynamicNum(), i+1);        break;      }    }  }  return true;}
       
      
     
    

begin_ = elf_file_->FindDynamicSymbolAddress("oatdata");  if (begin_ == NULL) {    LOG(WARNING) << "Failed to find oatdata symbol in " << file->GetPath();    return false;  }  if (requested_base != NULL && begin_ != requested_base) {    std::string maps;    ReadFileToString("/proc/self/maps", &maps);    LOG(WARNING) << "Failed to find oatdata symbol at expected address: oatdata="                 << reinterpret_cast
    
     (begin_) << " != expected="                 << reinterpret_cast
     
      (requested_base)                 << " /proc/self/maps:\n" << maps;    return false;  }  end_ = elf_file_->FindDynamicSymbolAddress("oatlastword");  if (end_ == NULL) {    LOG(WARNING) << "Failed to find oatlastword symbol in " << file->GetPath();    return false;  }  // Readjust to be non-inclusive upper bound.  end_ += sizeof(uint32_t);  return Setup();}