char *
_dwarf_get_alloc(Dwarf_Debug dbg,
    Dwarf_Small alloc_type, Dwarf_Unsigned count)

void
_dwarf_error(Dwarf_Debug dbg, Dwarf_Error * error, Dwarf_Sword errval)

int         
dwarf_elf_object_access_init(u64 elf_base_addr,
    int libdwarf_owns_elf,                     
    Dwarf_Obj_Access_Interface** ret_obj,      
    int *err)                      

static int                        
_dwarf_get_elf_flags_func(        
    void* obj_in,                 
    Dwarf_Half section_index,     
    Dwarf_Unsigned *flags_out,    
    Dwarf_Unsigned *addralign_out,
    int *error)                   

static int      
dwarf_elf_init_file_ownership(u64 elf_base_addr, 
    int libdwarf_owns_elf,          
    Dwarf_Unsigned access,          
    Dwarf_Handler errhand,          
    Dwarf_Ptr errarg,               
    Dwarf_Debug * ret_dbg,          
    Dwarf_Error * error)               

static int
this_section_dwarf_relevant(const char *scn_name,int type)

static int
get_basic_section_data(Dwarf_Debug dbg,
    struct Dwarf_Section_s *secdata,
    struct Dwarf_Obj_Access_Section_s *doas,
    Dwarf_Half section_index,
    Dwarf_Error* error,
    int duperr, int emptyerr )

int
_dwarf_load_section(Dwarf_Debug dbg,
    struct Dwarf_Section_s *section,
    Dwarf_Error * error)

static int
add_debug_section_info(Dwarf_Debug dbg, 
    /* Name as seen in object file. */
    const char *name,
    unsigned obj_sec_num,
    struct Dwarf_Section_s *secdata,
    /*  The have_dwarf flag is a somewhat imprecise
        way to determine if there is at least one 'meaningful'
        DWARF information section present in the object file.
        If not set on some section we claim (later) that there
        is no DWARF info present. see 'foundDwarf' in this file */
    int duperr,int emptyerr,int have_dwarf,
    int havezdebug,
    int *err)

static int                                        
_dwarf_setup(Dwarf_Debug dbg, Dwarf_Error * error)

int
dwarf_next_cu_header_d(Dwarf_Debug dbg,
    Dwarf_Bool is_info,
    Dwarf_Unsigned * cu_header_length,   // Returns the length of the just-read CU header.
    Dwarf_Half * version_stamp, // Returns the version number (2 to 5) of the CU header
    Dwarf_Unsigned * abbrev_offset, // Returns the .debug_abbrev offset from the the CU header
    Dwarf_Half * address_size, // Returns the address size specified for this CU, usually either 4 or 8.
    Dwarf_Half * offset_size, // Returns the offset size (the length of the size field from the header) specified for this CU
    Dwarf_Half * extension_size,  // If the section is standard 64bit DWARF then this value is 4. Else the value is zero.
    Dwarf_Sig8 * signature,
    Dwarf_Unsigned * typeoffset,
    Dwarf_Unsigned * next_cu_offset,
    Dwarf_Half * header_cu_type, // Returns DW_UT_compile, or other DW_UT value
    Dwarf_Error * error);

static int
_dwarf_next_die_info_ptr(Dwarf_Byte_Ptr die_info_ptr, // start of the DIE
    Dwarf_CU_Context cu_context,
    Dwarf_Byte_Ptr die_info_end,   // end of CU the die belong to
    Dwarf_Byte_Ptr cu_info_start,  // start of CU 
    Dwarf_Bool want_AT_sibling,
    Dwarf_Bool * has_die_child,
    Dwarf_Byte_Ptr *next_die_ptr_out,
    Dwarf_Error *error)

int
dwarf_siblingof_b(Dwarf_Debug dbg,
    Dwarf_Die die,
    Dwarf_Bool is_info,
    Dwarf_Die * caller_ret_die, Dwarf_Error * error)
{

int
dwarf_offdie(Dwarf_Debug dbg,
    Dwarf_Off offset, Dwarf_Die * new_die, Dwarf_Error * error)

typedef struct Dwarf_Error_s*      Dwarf_Error;

struct Dwarf_Error_s {
    /* 等效于error */
    Dwarf_Sword er_errval;

    /*  If non-zero the Dwarf_Error_s struct is not malloc'd.
        To aid when malloc returns NULL.
        If zero a normal dwarf_dealloc will work.
        er_static_alloc only accessed by dwarf_alloc.c.

        If er_static_alloc is 1 in a Dwarf_Error_s
        struct (set by libdwarf) and client code accidentally
        turns that 0 to zero through a wild
        pointer reference (the field is hidden
        from clients...) then chaos will
        eventually follow.
    */
    int er_static_alloc;
};

struct Dwarf_Obj_Access_Section_s {                                        
    /*  addr is the virtual address of the first byte of                   
        the section data.  Usually zero when the address                   
        makes no sense for a given section. */                             
    Dwarf_Addr     addr;                                                   
                                                                           
    /* Section type. */                                                    
    Dwarf_Unsigned type;                                                   
                                                                           
    /* Size in bytes of the section. */                                    
    Dwarf_Unsigned size;                                                   
                                                                           
    /*  Having an accurate section name makes debugging of libdwarf easier.
        and is essential to find the .debug_ sections.  */                 
    const char*    name;                                                   
    /*  Set link to zero if it is meaningless.  If non-zero                
        it should be a link to a rela section or from symtab               
        to strtab.  In Elf it is sh_link. */                               
    Dwarf_Unsigned link;                                                   
                                                                           
    /*  The section header index of the section to which the               
        relocation applies. In Elf it is sh_info. */                       
    Dwarf_Unsigned info;                                                   
                                                                           
    /*  Elf sections that are tables have a non-zero entrysize so          
        the count of entries can be calculated even without                
        the right structure definition. If your object format              
        does not have this data leave this zero. */                        
    Dwarf_Unsigned entrysize;                                              
};                                

struct Dwarf_Section_s {
    Dwarf_Small *  dss_data;
    Dwarf_Unsigned dss_size;
  
    /*  dss_index is the section index as things are numbered in
        an object file being read.   An Elf section number. */
    Dwarf_Word     dss_index;
    /*  dss_addr is the 'section address' which is only
        non-zero for a GNU eh section.
        Purpose: to handle DW_EH_PE_pcrel encoding. Leaving
        it zero is fine for non-elf.  */
    Dwarf_Addr     dss_addr;
    Dwarf_Small    dss_data_was_malloc;
    /*  is_in_use set during initial object reading to
        detect duplicates. Ignored after setup done. */
    Dwarf_Small    dss_is_in_use;

    /*  If this is zdebug, to start  data/size are the
        raw section bytes.
        Initially for all sections dss_data_was_malloc set FALSE
            and dss_requires_decompress set FALSE.
        For zdebug dss_requires_decompress then set TRUE

        On translation (ie zlib use and malloc)
        Set dss_data dss_size to point to malloc space and
            malloc size.
        Set dss_requires_decompress FALSE
        Set dss_was_malloc  TRUE */
    Dwarf_Small    dss_requires_decompress;

    /*  For non-elf, leaving the following fields zero
        will mean they are ignored. */
    /*  dss_link should be zero unless a section has a link
        to another (sh_link).  Used to access relocation data for
        a section (and for symtab section, access its strtab). */
    Dwarf_Word     dss_link;
    /*  The following is used when reading .rela sections
        (such sections appear in some .o files). */
    Dwarf_Half     dss_reloc_index; /* Zero means ignore the reloc fields. */
    Dwarf_Small *  dss_reloc_data;
    Dwarf_Unsigned dss_reloc_size;
    Dwarf_Unsigned dss_reloc_entrysize;
    Dwarf_Addr     dss_reloc_addr;
    /*  dss_reloc_symtab is the sh_link of a .rela to its .symtab, leave
        it 0 if non-meaningful. */
    Dwarf_Addr     dss_reloc_symtab;
    /*  dss_reloc_link should be zero unless a reloc section has a link
        to another (sh_link).  Used to access the symtab for relocations
        a section. */
    Dwarf_Word     dss_reloc_link;
    /*  Pointer to the elf symtab, used for elf .rela. Leave it 0
        if not relevant. */
    struct Dwarf_Section_s *dss_symtab;
    /*  dss_name must never be freed, it is a quoted string
        in libdwarf. */
    const char * dss_name;

    /* Object section number in object file. */
    unsigned dss_number;
    
    /*  These are elf flags and non-elf object should
        just leave these fields zero. Which is essentially
        automatic as they are not in
        Dwarf_Obj_Access_Section_s.  */
    Dwarf_Word  dss_flags;
    Dwarf_Word  dss_addralign;
};  

struct Dwarf_dbg_sect_s {
    /*  Debug section name must not be freed, is quoted string.
        This is the name from the object file itself. */
    const char *ds_name;
    /* The section number in object section numbering. */
    unsigned ds_number;
    /*   Debug section information, points to de_debug_*member
        (or the like) of the dbg struct.  */
    struct Dwarf_Section_s *ds_secdata;

    int ds_duperr;                     /* Error code for duplicated section */
    int ds_emptyerr;                   /* Error code for empty section */
    int ds_have_dwarf;                 /* Section contains DWARF */
    int ds_have_zdebug;                /* Section compressed. */
};

typedef struct Dwarf_CU_Context_s *Dwarf_CU_Context;

typedef struct Dwarf_Debug_InfoTypes_s *Dwarf_Debug_InfoTypes;

typedef struct Dwarf_Die_s*        Dwarf_Die;

typedef struct Dwarf_Abbrev_List_s *Dwarf_Abbrev_List;