dyuddlZddlmZddlmZmZmZmZddlm Z m Z ddl m Z ddl mZdd lGd d eZd ZGd deZGddeZGddeZGddeZGddeZGddeZGddeZeddZdZdZiZeejAD]!Z!e!jEdse!eee!<#y) N) namedtuple) struct_parse dwarf_assertpreserve_stream_pos iterbytes)StructSwitch)DW_EH_encoding_flags) DWARFStructs)*c`eZdZdZ ddZdZdZdZdZdZ dZ d Z d Z d Z ed Zy ) CallFrameInfoa DWARF CFI (Call Frame Info) Note that this also supports unwinding information as found in .eh_frame sections: its format differs slightly from the one in .debug_frame. See . stream, size: A stream holding the .debug_frame section, and the size of the section in it. address: Virtual address for this section. This is used to decode relative addresses. base_structs: The structs to be used as the base for parsing this section. Eventually, each entry gets its own structs based on the initial length field it starts with. The address_size, however, is taken from base_structs. This appears to be a limitation of the DWARFv3 standard, fixed in v4. A discussion I had on dwarf-discuss confirms this. So for DWARFv4 we'll take the address size from the CIE header, but for earlier versions will use the elfclass of the containing file; more sophisticated methods are used by libdwarf and others, such as guessing which CU contains which FDEs (based on their address ranges) and taking the address_size from those CUs. cf||_||_||_||_d|_i|_||_yN)streamsizeaddress base_structsentries _entry_cache for_eh_frame)selfrrrrrs :/usr/lib/python3/dist-packages/elftools/dwarf/callframe.py__init__zCallFrameInfo.__init__/s:   (  )c\|j|j|_|jS)z Get a list of entries that constitute this CFI. The list consists of CIE or FDE objects, in the order of their appearance in the section. )r_parse_entriesrs r get_entrieszCallFrameInfo.get_entriesAs( << ..0DL||rcg}d}||jkrJ|j|j||jj }||jkrJ|S)Nr)rappend_parse_entry_atrtell)rroffsets rrzCallFrameInfo._parse_entriesLsVtyy NN4//7 8[[%%'Ftyy rc ||jvr|j|St|jjd|j|}|j r|dk(r t |S|dk(rdnd}t|jj||jj}t|jd|j}|j r|dk(}n|dk(xr|dk(xs|dk(}|r<|j r |jn |j}t||j|}n|j||}|j s;|jdk\r,t|j|j|j}|r|j!||\} } n|j#|||} |j%|} | j&j)d t*d } | t*d k7r8|j-||jj/t1| z | } nd } ||j2z|j5z}|j7||jj/|}|rt9||| | | |j|<n2|j#|||} t;||||| |  |j|<|j|S)z Parse an entry from self.stream starting with the given offset. Return the entry object. self.stream will point right after the entry. rl@ ) little_endian dwarf_format address_sizel LSDA_encoding DW_EH_PE_omitN)header instructionsr&augmentation_dictaugmentation_bytesstructs)r1r2r&r5cier4 lsda_pointer)rrr Dwarf_uint32rrZEROr r+r- Dwarf_offset EH_CIE_headerDwarf_CIE_header_parse_fde_header dwarf_versionr,_parse_cie_augmentation_parse_cie_for_fde_read_augmentation_datar3getr _parse_lsda_pointerr%lenlengthinitial_length_field_size_parse_instructionsCIEFDE)rr& entry_lengthr, entry_structsCIE_idis_CIE header_structr1 aug_bytesaug_dictr6 lsda_encodingr7 end_offsetr2s rr$zCallFrameInfo._parse_entry_atTs T&& &$$V, ,#    * *2 . VE    !2< )Z7rR $++99%**779   & &r *DKK9   q[F#<*(<-,,   $ 1 1+88*;; "t{{F4F++M6BF   ]%@%@A%E(+99*77#002M "&">">M#+ Ix))&&-HC44]CI1155oG[\kGlmM 4_ EE#77 8< 8H8H8JSQZ^8[8E G  $  V]] "  3 3 5 6  // 4;;++-z;  (+L"*#,% )'D  f %))&&-HC(+L%3#,) )D  f %   ((rcNg}||krt|jd|j|}g}|tz}|tz}|t k(r|g}n|t k(r)|t|jd|jg}n|tk(r|g}n|tttfvrg}n|tk(r(t|jd|jg}n|tk(r(t|jd|jg}n^|tk(r(t|j!d|jg}n-|t"k(r(t|j%d|jg}n|t&t(t*t,fvrLt|jd|jt|jd|jg}n|t.t0t2t4t6fvr(t|jd|jg}nS|t8k(r(t|j;d|jg}n"|t<k(r%t|j>d|jg}n|t@tBfvrIt|jd|jt|j>d|jg}n|tDtFtHfvrKt|jd|jt|j;d|jg}n?|tJk(r't|jd|jg}ntMdd|z|jOtQ|||jjS}||kr|S)z Parse a list of CFI instructions from self.stream, starting with the offset and until (not including) end_offset. Return a list of CallFrameInstruction objects. r( DW_FORM_blockFzUnknown CFI opcode: 0x%xopcodeargs)*r Dwarf_uint8r _PRIMARY_MASK_PRIMARY_ARG_MASKDW_CFA_advance_loc DW_CFA_offset Dwarf_uleb128DW_CFA_restore DW_CFA_nopDW_CFA_remember_stateDW_CFA_restore_stateDW_CFA_set_locDwarf_target_addrDW_CFA_advance_loc1DW_CFA_advance_loc2 Dwarf_uint16DW_CFA_advance_loc4r8DW_CFA_offset_extendedDW_CFA_registerDW_CFA_def_cfaDW_CFA_val_offsetDW_CFA_restore_extendedDW_CFA_undefinedDW_CFA_same_valueDW_CFA_def_cfa_registerDW_CFA_def_cfa_offsetDW_CFA_def_cfa_offset_sf Dwarf_sleb128DW_CFA_def_cfa_expression Dwarf_dw_formDW_CFA_expressionDW_CFA_val_expressionDW_CFA_offset_extended_sfDW_CFA_def_cfa_sfDW_CFA_val_offset_sfDW_CFA_GNU_args_sizerr#CallFrameInstructionr%) rr5r&rRr2rVrWprimary primary_args rrGz!CallFrameInfo._parse_instructionssL  z!!'"5"5b"94;;OFD},G #44K,,#}M) !6!6r!:DKKHJN*#}J(=022>) !:!:2!> LN..$W%8%8% LM33$W%:%:2%> LM44$))/:DKKIJ-/DEE !6!6r!:DKKH --o> MN5-/CEE!!6!6r!:DKKH !6!6r!:DKKHJ//$W%:%:2%> LMU$>$GH    4F N O[[%%'Fsz!trc|jr|d}||jdzz|z }n|d}t|j5|j |cdddS#1swYyxYw)z3 Parse the CIE that corresponds to an FDE. CIE_pointerN)rr,rrr$)r fde_offset fde_headerrKcie_displacement cie_offsets rr@z CallFrameInfo._parse_cie_for_fdest    *-8 $}'A'AQ'FF,-J$M2J! - 4'' 3 4 4 4s AA&cB|jd}|sdifS|jdsJdjt||j d|j d|j ddt d |j d td d |j|jDcic]\}}||d c}}d }g}i}t|D]#} || } | durd|| <|j| %|jj} t dg|} |jt!| |j| |jj#| |j%|} | |fScc}}w#t$rYwxYw)z Parse CIE augmentation data from the annotation string in `header`. Return a tuple that contains 1) the augmentation data as a string (without the length field) and 2) the augmentation data as a dict. augmentationr(zz!Unhandled augmentation string: {}rEr/ FDE_encodingT personalityencodingfunctionc |jdzS)N)r)ctxs rz7CallFrameInfo._parse_cie_augmentation..ss||d/Br)rLRSPAugmentation_Data)rB startswithformatreprr]rXr r _eh_encoding_to_fielditemsrKeyErrorr#rr%updaterseekrA)rr1rKrencfld_consavailable_fieldsfieldsrPbfldr&structrOs rr?z%CallFrameInfo._parse_cie_augmentations zz.1 8O&&t, L / 6 6tL7I J L, --h7++O<++N;))*5z#B11-@FFHEJ%X*--EJKL   <( #A &q)d{ $  c" # !!#+5f5 VT[[&AB  00? 8$$AEJ  s9F -F FFc|jsyttd|jd|jd}|jj |S)z Read augmentation data. This assumes that the augmentation string starts with 'z', i.e. that augmentation data is prefixed by a length field, which is not returned. rDummy_Augmentation_DatarE)rrr r]rread)rrKaugmentation_data_lengths rrAz%CallFrameInfo._read_augmentation_dataAs]   #/ , ..x8 : KK$"$# {{ 899rc:|tdk7sJ|dz}|dz}|j|}ttd||d|j|d}|tdk(r |S|tdk(r||j |zz }|SJd j |) a} Parse bytes to get an LSDA pointer. The basic encoding (lower four bits of the encoding) describes how the values are encoded in a CIE or an FDE. The modifier (upper four bits of the encoding) describes how the raw values, after decoded using a basic encoding, should be modified before using. Ref: https://www.airs.com/blog/archives/460 r0rr LSDA_pointer) stream_posDW_EH_PE_absptrDW_EH_PE_pcrelz5Unsupported encoding modifier for LSDA pointer: {:#x})r rrr rrr)rr5 stream_offsetrbasic_encodingmodifierformatsptrs rrCz!CallFrameInfo._parse_lsda_pointerPs/@@@@!Dd?,,W5 &*7>*>: < KKM34BC +,=> >  -.>? ? 4<<-/ /C   cQXXYab b5rc|js!t|j|j|S|j d|j dg}tt dg||j|}|j|||}|jj}|jd}|tdk7sJ|dz}|dz} |j|} |j| |d|j| |d tt d g||j|} | d k(r | S| td k(r| dxx|j|zz cc<| SJd j|)zB Compute a struct to parse the header of the current FDE. rEreh_frame_minimal_headerrr0rrinitial_location address_rangeDwarf_FDE_headerrrzUnsupported encoding: {:#x})rrrrDwarf_initial_lengthr:r r@r%r3r rr#rr) rrKr&rminimal_headerr6initial_location_offsetrrencoding_modifierrresults rr=zCallFrameInfo._parse_fde_headeros   > > &( ( 44X>,,];= &f-F'6.4'67;{{FL%%fnmL"&++"2"2"4 ((8/@@@@!D$tO,,]; -gn-.@AB -gn-o>?f%7A&A"kk63  !  "67G"H H % & 66 8 &   I7>>xH H5rc\td|jtd|jtd|jtd|jtd|j td|j td|jtd|jtd |ji S) z Return a mapping from basic encodings (DW_EH_encoding_flags) the corresponding field constructors (for instance entry_structs.Dwarf_uint32). rDW_EH_PE_uleb128DW_EH_PE_udata2DW_EH_PE_udata4DW_EH_PE_udata8DW_EH_PE_sleb128DW_EH_PE_sdata2DW_EH_PE_sdata4DW_EH_PE_sdata8) r rcr]rfr8 Dwarf_uint64rr Dwarf_int16 Dwarf_int32 Dwarf_int64)rKs rrz#CallFrameInfo._eh_encoding_to_fields !!2 3// !3 4++ !2 3** !2 3** !2 3** !3 4++ !2 3)) !2 3)) !2 3))'  rN)F)__name__ __module__ __qualname____doc__rr!rr$rGr@r?rArCr= staticmethodrrrrrsX8$)$^)@@D4$7%r :>,\  rrcB|tz}|dk(r t|St|S)z3 Given an opcode, return the instruction name. r)rY_OPCODE_NAME_MAP)rVr|s rinstruction_namers+}$G!|''((rceZdZdZdZdZy)r{a An instruction in the CFI section. opcode is the instruction opcode, numeric - as it appears in the section. args is a list of arguments (including arguments embedded in the low bits of some instructions, when applicable), decoded from the stream. c ||_||_yrrU)rrVrWs rrzCallFrameInstruction.__init__s  rc`dt|j|j|jfzS)Nz %s (0x%x): %s)rrVrWr s r__repr__zCallFrameInstruction.__repr__s/ T[[ )4;; "CC CrNrrrrrrrrrr{r{s Crr{c,eZdZdZ ddZdZdZdZy)CFIEntryaX A common base class for CFI entries. Contains a header and a list of instructions (CallFrameInstruction). offset: the offset of this entry from the beginning of the section cie: for FDEs, a CIE pointer is required augmentation_dict: Augmentation data as a parsed struct (dict): see CallFrameInfo._parse_cie_augmentation and http://www.airs.com/blog/archives/460. augmentation_bytes: Augmentation data as a chain of bytes: see CallFrameInfo._parse_cie_augmentation and http://www.airs.com/blog/archives/460. Nc|||_||_||_||_||_d|_|r|ni|_||_yr)r1r5r2r&r6_decoded_tabler3r4)rr1r5r2r&r3r4r6s rrzCFIEntry.__init__sC  ( "6G!2R"4rc\|j|j|_|jS)z Decode the CFI contained in this entry and return a DecodedCallFrameTable object representing it. See the documentation of that class to understand how to interpret the decoded table. )r_decode_CFI_tabler s r get_decodedzCFIEntry.get_decodeds-    &"&"8"8":D """rc |j|S)z6 Implement dict-like access to header entries )r1)rnames r __getitem__zCFIEntry.__getitem__s{{4  rc t|tr|}tdtdd}g n|j}|j }t |jdkDr8tj|jd}tj|}nttdd}|d|d<tj|j g}g} fd }|jD]}t|j} | d k(r7|jtj||jd|d<U| d vrE|jtj||dxx|jd|d zz cc<| d k(r+t|jd|jd|d<| dk(r2t|jd|jd|d z|d<| dk(r,t|jd|dj|d<6| dk(r,t|dj |jd|d<g| dk(rt|jd|d<| dk(r@||jdt#t"j$||jd<| dk(r@||jdt#t"j&||jd<| dvrT||jdt#t"j(|jd|dz||jd<l| dvrT||jdt#t"j*|jd|dz||jd<| dk(rN||jdt#t"j,|jd||jd<| dk(rN||jdt#t"j.|jd||jd<j| dk(rN||jdt#t"j0|jd||jd<| dvr||jdt3t|t4d| z|jdvr$||jd||jd<(|j7|jddI| dk(r&|jtj8|t| d k(s{|d} |j7}| |d<|dj t |d!kDr|j|t;| "S)#zr Decode the instructions contained in the given CFI entry and return a DecodedCallFrameTable. rN)regr&)pccfa)rrrc2|vrj|yyr)r#)regnum reg_orders r _add_to_orderz1CFIEntry._decode_CFI_table.._add_to_orders Y&  ('rrb)rdrergr[code_alignment_factorrjr rrxrorprs)exprrmrn)r\rhrwdata_alignment_factor)rkryrirurv)r^rlz%s instruction must be in a FDEr`rar)tabler) isinstancerHdictCFARuler6rrDrcopyrr2rrVr#rWr&r RegisterRule UNDEFINED SAME_VALUEOFFSET VAL_OFFSETREGISTER EXPRESSIONVAL_EXPRESSIONrrIpopdeepcopyDecodedCallFrameTable) rr6cur_linecie_decoded_tablelast_line_in_CIEr line_stackrinstrrrrs @rrzCFIEntry._decode_CFI_tables0 dC Cqg$q&ABHI ((C # 1 $**+a/#'99->-D-DR-H#I 99%56GQ$?@!"45HTN "3"="=>I  ) &&N $E $ELL1D'' TYYx01!&AII TYYx01%**Q-#6M2N"NN))") 1  ::a=#*,,") 1  ::a=3/F+GG#I22") 1 #E?11#300") ++ ::a=#*44")uzz!}"=++ejjm,*6|7M7M*NA',,ejjm,*6|7N7N*OA'99ejjm,*6 ''JJqMC(?$@@+BA'FFejjm,*6 ++JJqMC(?$@@+BA'**ejjm,*6 ))JJqM+#A',,ejjm,*6 ++JJqM+#A'00ejjm,*6 //JJqM+#A'FFejjm,tS)5<>::a=$44.>uzz!}.MHUZZ]+LLA500!!$--"9://d^%>>+!#]N $d E?   *c(ma.? LL "$5IFFr)NrN)rrrrrrrrrrrrrs$ AE 5#! xGrrc eZdZy)rHN)rrrrrrrHrHysrrHc eZdZdfd ZxZS)rIcFtt| ||||||||_y)N)r4r6)superrIrr7) rr1r5r2r&r4r6r7 __class__s rrz FDE.__init__~s) c4!&'<\ntw!x(rNNN)rrrr __classcell__)rs@rrIrI}s ))rrIceZdZdZdZy)r9z End marker for the sequence of CIE/FDE. This is specific to `.eh_frame` sections: this kind of entry does not exist in pure DWARF. `readelf` displays these as "ZERO terminator", hence the class name. c||_yr)r&)rr&s rrz ZERO.__init__s  rN)rrrrrrrrr9r9s  rr9c>eZdZdZdZdZdZdZdZdZ dZ d Z d d Z d Z y )rz Register rules are used to find registers in call frames. Each rule consists of a type (enumeration following DWARFv3 section 6.4.1) and an optional argument to augment the type. rrrrrrr ARCHITECTURALNc ||_||_yrtypearg)rrrs rrzRegisterRule.__init__s rc<d|jd|jdS)Nz RegisterRule(z, )rr s rrzRegisterRule.__repr__s)-DHH==rr)rrrrrrrrrrrr rrrrrrrs;IJ FJHJ%N#M>rrceZdZdZddZdZy)rz A CFA rule is used to compute the CFA for each location. It either consists of a register+offset, or a DWARF expression. Nc.||_||_||_yrrr&r)rrr&rs rrzCFARule.__init__s  rcVd|jd|jd|jdS)Nz CFARule(reg=z , offset=z, expr=rrr s rrzCFARule.__repr__s HHdkk499. .rrrrrrrrs .rrrztable reg_order?DW_CFA)#r collectionsr common.utilsrrrr constructr r enumsr r5r constantsobjectrrr{rrHrIr9rrrrYrZrlistglobalskeysrrrrrr$s "@@&'!e Fe P ) C6 C]Gv]GJ ( )() 6>6>, .f .B#.0    ! "1D x ,04)1r