2019/01/30(Wed) 20:17

 * merge from brach dev20190129.

Squashed commit of the following:

commit 7a19e5dde2c1384a138da5333c1d1fb0eb5fe162
Author: Koine Yuusuke(koinec) <koinec@users.osdn.me>
Date:   Wed Jan 30 20:15:02 2019 +0900

    2019/01/30(Wed)
      * typedef Ptr change to 64bit unsigned char & void * union data.

diff --git a/include/drd64_types.h b/include/drd64_types.h
index 9c31ec9..63a5908 100644 (file)
--- a/include/drd64_types.h
+++ b/include/drd64_types.h
@@ -15,7 +15,13 @@ Comment:
 #ifndef DRD64_HEADER_TYPES
 #define DRD64_HEADER_TYPES
 
-typedef        unsigned long   Ptr;
+typedef unsigned long  PtrValue;
+typedef void *                         PtrAddr;
+
+typedef union  {
+       PtrAddr                 addr;
+       PtrValue                value;
+} Ptr;
 
 typedef unsigned char  Byte;
 typedef        char                    Char;

diff --git a/libgoblin/drd64_libgoblin_debug_addrinfo.c b/libgoblin/drd64_libgoblin_debug_addrinfo.c
index e42cccf..4d4bba4 100644 (file)
--- a/libgoblin/drd64_libgoblin_debug_addrinfo.c
+++ b/libgoblin/drd64_libgoblin_debug_addrinfo.c
@@ -66,8 +66,8 @@ int
 
        for( dw_cnt = 0; dw_cnt < p_binfo->dw_max_addrinfo; dw_cnt++, p_addr++ )        {
                if( 0x00 < b_level )    {
-                       printf("  %08lx - %08lx (%8d) ", p_addr->ptr_address,
-                                                       p_addr->ptr_address + p_addr->dw_size, p_addr->dw_size );
+                       printf("  %08lx - %08lx (%8d) ", p_addr->ptr_addr.value,
+                                                       p_addr->ptr_addr.value + p_addr->dw_size, p_addr->dw_size );
 
                        // b_elf_flags
                        w_scope = p_addr->b_elf_flags >> 4;

diff --git a/libgoblin/drd64_libgoblin_debug_elf.c b/libgoblin/drd64_libgoblin_debug_elf.c
index df5debc..e2226f7 100644 (file)
--- a/libgoblin/drd64_libgoblin_debug_elf.c
+++ b/libgoblin/drd64_libgoblin_debug_elf.c
@@ -48,7 +48,7 @@ int
 {
        Byte                                    b_cnt;
        void                                    *p_shdr;
-       Ptr                                             ptr_start;
+       PtrValue                                ptr_start;
        LibGoblin_SectionInfo   *p_secinfo;
        LibGoblin_ProgramInfo   *p_pginfo;
        Elf64_Shdr                              *p_shdr64;
@@ -72,12 +72,12 @@ int
                if( isElf64( p_binfo ) )        {
                        p_shdr64        = (Elf64_Shdr *)p_secinfo->pb_sechdr;
                        assert( NULL != p_shdr64 );
-                       ptr_start       = (Ptr)p_shdr64->sh_addr;
+                       ptr_start       = (PtrValue)p_shdr64->sh_addr;
                }
                else    {
                        p_shdr32= (Elf32_Shdr *)p_secinfo->pb_sechdr;
                        assert( NULL != p_shdr32);
-                       ptr_start       = (Ptr)p_shdr32->sh_addr;
+                       ptr_start       = (PtrValue)p_shdr32->sh_addr;
                }
 
                if( 0x00 < b_level )    {

diff --git a/libgoblin/drd64_libgoblin_debug_symwork.c b/libgoblin/drd64_libgoblin_debug_symwork.c
index d090cf9..af6fb9a 100644 (file)
--- a/libgoblin/drd64_libgoblin_debug_symwork.c
+++ b/libgoblin/drd64_libgoblin_debug_symwork.c
@@ -46,7 +46,7 @@ int
                        LibGoblin_SymbolWorkTable       *p_symworktbl,
                        Byte            b_level )
 {
-       Ptr                                             ptr_value       = 0x0000000000000000;
+       PtrValue                                ptr_value       = 0x0000000000000000;
        int                                             i_order         = 0x00;
        DWord                                   dw_cnt;
        LibGoblin_SymbolWorkInfo        *p_symnow;
@@ -56,21 +56,21 @@ int
 
        p_symnow        = p_symworktbl->p_symwork;
        for( dw_cnt = 0; dw_cnt < p_symworktbl->dw_max_symwork; dw_cnt++ )      {
-               if( ptr_value <= p_symnow->ptr_address )        {
+               if( ptr_value <= p_symnow->ptr_value )  {
                        if( 0x01 < b_level )    {
                                printf("[%05d] %08lx : DataPtr=%8p\n",
-                                               dw_cnt, p_symnow->ptr_address, p_symnow->pb_symbol );
+                                               dw_cnt, p_symnow->ptr_value, p_symnow->pb_symbol );
                        }
                }
                else    {
                        if( 0x00 < b_level )    {
                                printf("[%05d] %08lx : DataPtr=%8p  **Invalid Order Address!!**\n",
-                                                       dw_cnt, p_symnow->ptr_address, p_symnow->pb_symbol );
+                                                       dw_cnt, p_symnow->ptr_value, p_symnow->pb_symbol );
                        }
                        i_order = 0x01;
                }
 
-               ptr_value       = p_symnow->ptr_address;
+               ptr_value       = p_symnow->ptr_value;
 
                p_symnow++;
        }

diff --git a/libgoblin/drd64_libgoblin_elf_dynamic.c b/libgoblin/drd64_libgoblin_elf_dynamic.c
index 6294988..daf63fb 100644 (file)
--- a/libgoblin/drd64_libgoblin_elf_dynamic.c
+++ b/libgoblin/drd64_libgoblin_elf_dynamic.c
@@ -81,7 +81,7 @@ Elf64_Phdr    *
 Elf64_Phdr     *
        ELF64_ProgramHeader_Search_inRange(
                LibGoblin_BinaryInfo    *p_binfo,
-               Ptr     ptr_address,
+               PtrValue        ptr_value,
                QWord   qw_size )
 {
        int                                             i_cnt;
@@ -107,8 +107,8 @@ Elf64_Phdr  *
        p_pghrange      = NULL;
        qw_szrange      = 0xffffffffffffffff;
        for( i_cnt = 0; i_cnt < i_phdrnum; i_cnt++ )    {
-               if(( p_proghdr->p_vaddr <= ptr_address )
-                               && ((ptr_address + qw_size) <= (p_proghdr->p_vaddr + p_proghdr->p_memsz) ) )    {
+               if(( p_proghdr->p_vaddr <= ptr_value )
+                               && ((ptr_value + qw_size) <= (p_proghdr->p_vaddr + p_proghdr->p_memsz) ) )      {
                        p_pghrange      = p_proghdr;
                        qw_szrange      = p_proghdr->p_memsz;
                }
@@ -134,8 +134,8 @@ int
        QWord                                   qw_tag;
        QWord                                   qw_value;
        QWord                                   qw_dynsize;
-       Ptr                                             ptr_addr;
-       Ptr                                             ptr_dynaddr;
+       //PtrValue                              ptr_value;
+       PtrValue                                ptr_dynvalue;
        Elf64_Ehdr                              *p_elfhdr;
        Elf64_Phdr                              *p_pghdr_dynamic;
        Elf64_Phdr                              *p_pghdr_dynstr;
@@ -164,17 +164,17 @@ int
        }
 
        // Seearch & Setting .dynstr section info. ---
-       ptr_dynaddr     = 0x0000000000000000;
-       qw_dynsize      = 0;
-       pb_dynamic      = pb_data + p_pghdr_dynamic->p_offset;
+       ptr_dynvalue    = 0x0000000000000000;
+       qw_dynsize              = 0;
+       pb_dynamic              = pb_data + p_pghdr_dynamic->p_offset;
        do      {
                p_dyn64         = (Elf64_Dyn *)pb_dynamic;
                qw_tag          = (QWord)p_dyn64->d_tag;
                qw_value        = (QWord)p_dyn64->d_un.d_val;
-               ptr_addr        = (Ptr)p_dyn64->d_un.d_ptr;
+               //ptr_value     = (PtrValue)p_dyn64->d_un.d_ptr;
 
                /* 05 - Address of string table. */
-               if( DT_STRTAB == qw_tag )               { ptr_dynaddr   = qw_value; }
+               if( DT_STRTAB == qw_tag )               { ptr_dynvalue  = qw_value; }
                /* 10 - Size of string table. */
                else if( DT_STRSZ == qw_tag )   { qw_dynsize    = qw_value; }
                /* 20 - Type of relocation used for PLT. */
@@ -187,16 +187,16 @@ int
        }while( DT_NULL != qw_tag );
 
        p_sec_dynstr    = NULL;
-       if(( 0 < ptr_dynaddr ) && ( 0 < qw_dynsize ))   {
+       if(( 0 < ptr_dynvalue ) && ( 0 < qw_dynsize ))  {
                // Search ProgHdr in .dynstr section ---
-               p_pghdr_dynstr  = ELF64_ProgramHeader_Search_inRange( p_binfo, ptr_dynaddr, qw_dynsize );
+               p_pghdr_dynstr  = ELF64_ProgramHeader_Search_inRange( p_binfo, ptr_dynvalue, qw_dynsize );
                assert( NULL != p_pghdr_dynstr );
 
                p_sec_dynstr    = LibGoblin_Section_GetSectionInfo( p_pginfo, LIBGOBLIN_SECTION_ID_DYNSTR );
-               p_sec_dynstr->qw_size           = qw_dynsize;
-               p_sec_dynstr->ptr_address       = ptr_dynaddr;
-               p_sec_dynstr->pb_data           = pb_data
-                                                                                       + (ptr_dynaddr - p_pghdr_dynstr->p_vaddr)
+               p_sec_dynstr->qw_size                   = qw_dynsize;
+               p_sec_dynstr->ptr_addr.value    = ptr_dynvalue;
+               p_sec_dynstr->pb_data                   = pb_data
+                                                                                       + (ptr_dynvalue - p_pghdr_dynstr->p_vaddr)
                                                                                        + p_pghdr_dynstr->p_offset;
                p_sec_dynstr->pb_sechdr         = NULL;
                p_sec_dynstr->i_fid                     = -0x01;        // Temporary.
@@ -225,15 +225,15 @@ void
                p_secnow->i_fid         = -0x01;        // Temporary.
 
                // Calc. Offset
-               if(( 0x00000000 != p_secnow->ptr_address ) && ( 0 < p_secnow->qw_size ))        {
+               if(( 0x00000000 != p_secnow->ptr_addr.value ) && ( 0 < p_secnow->qw_size ))     {
                        p_bfile = BinaryFile_GetBinaryFile( p_binfo->i_binfile );
                        assert( NULL != p_bfile );
 
                        p_pghdr = ELF64_ProgramHeader_Search_inRange(
-                                                       p_binfo, p_secnow->ptr_address, p_secnow->qw_size );
+                                                       p_binfo, p_secnow->ptr_addr.value, p_secnow->qw_size );
                        if( NULL != p_pghdr )   {
                                p_secnow->pb_data       = p_bfile->pb_binary
-                                                                                       + (p_secnow->ptr_address - p_pghdr->p_vaddr)
+                                                                                       + (p_secnow->ptr_addr.value - p_pghdr->p_vaddr)
                                                                                        + p_pghdr->p_offset;
                        }
                }
@@ -250,7 +250,7 @@ void
                LibGoblin_ProgramInfo   *p_pginfo,
                LibGoblin_BinaryInfo    *p_binfo,
                DWord   dw_secid,
-               Ptr             ptr_addr )
+               PtrValue        ptr_value )
 {
        Elf64_Phdr                              *p_pghdr;
        LibGoblin_SectionInfo   *p_secnow;
@@ -258,19 +258,19 @@ void
 
        p_secnow        = LibGoblin_Section_GetSectionInfo( p_pginfo, dw_secid );
        if( NULL == p_secnow->pb_sechdr )       {
-               p_secnow->ptr_address   = ptr_addr;
-               p_secnow->i_fid         = -0x01;        // Temporary.
+               p_secnow->ptr_addr.value        = ptr_value;
+               p_secnow->i_fid                         = -0x01;        // Temporary.
 
                // Calc. Offset
-               if(( NULL != p_secnow->ptr_address ) && ( 0 < p_secnow->qw_size ))      {
+               if(( 0x00000000 != p_secnow->ptr_addr.value ) && ( 0 < p_secnow->qw_size ))     {
                        p_bfile = BinaryFile_GetBinaryFile( p_binfo->i_binfile );
                        assert( NULL != p_bfile );
 
                        p_pghdr = ELF64_ProgramHeader_Search_inRange(
-                                                       p_binfo, p_secnow->ptr_address, p_secnow->qw_size );
+                                                       p_binfo, p_secnow->ptr_addr.value, p_secnow->qw_size );
                        if( NULL != p_pghdr )   {
                                p_secnow->pb_data       = p_bfile->pb_binary
-                                                                                       + (p_secnow->ptr_address - p_pghdr->p_vaddr)
+                                                                                       + (p_secnow->ptr_addr.value - p_pghdr->p_vaddr)
                                                                                        + p_pghdr->p_offset;
                        }
                }
@@ -292,7 +292,7 @@ int
        DWord                                   dw_secid;
        QWord                                   qw_tag;
        QWord                                   qw_value;
-       Ptr                                             ptr_addr;
+       PtrValue                                ptr_value;
        Elf64_Dyn                               *p_dyn64;
        Elf32_Dyn                               *p_dyn32;
        LibGoblin_BinaryInfo    *p_bintmp;
@@ -331,13 +331,13 @@ int
 
                        qw_tag          = (QWord)p_dyn64->d_tag;
                        qw_value        = (QWord)p_dyn64->d_un.d_val;
-                       ptr_addr        = (Ptr)p_dyn64->d_un.d_ptr;
+                       ptr_value       = (PtrValue)p_dyn64->d_un.d_ptr;
                } else  {
                        p_dyn32 = (Elf32_Dyn *)pb_data;
 
                        qw_tag          = (QWord)p_dyn32->d_tag;
                        qw_value        = (QWord)p_dyn32->d_un.d_val;
-                       ptr_addr        = (Ptr)p_dyn32->d_un.d_ptr;
+                       ptr_value       = (PtrValue)p_dyn32->d_un.d_ptr;
                }
 
                switch( qw_tag )        {
@@ -372,19 +372,19 @@ int
                                                { dw_secid      = LIBGOBLIN_SECTION_ID_RELA_PLT; }
                                else    { dw_secid      = LIBGOBLIN_SECTION_ID_REL_PLT; }
 
-                               ELF64_Dynamic_SetSectionAddress( p_pginfo, p_binfo, dw_secid, ptr_addr );
+                               ELF64_Dynamic_SetSectionAddress( p_pginfo, p_binfo, dw_secid, ptr_value );
                                break;
 
                        /* 03 - Processor-dependent address. */
                        case DT_PLTGOT:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GOT_PLT, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GOT_PLT, ptr_value );
                                break;
 
                        /* 06 - Address of symbol table. */
                        case DT_SYMTAB:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_DYNSYM, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_DYNSYM, ptr_value );
                                break;  
 
                        /* 11 - Size of each symbol table entry. */
@@ -396,24 +396,24 @@ int
                        /* 04 - Address of symbol hash table. */
                        case DT_HASH:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_HASH, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_HASH, ptr_value );
                                break;
 
                        /* 12 - Address of initialization function. */
                        case DT_INIT:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_TEXT_INIT, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_TEXT_INIT, ptr_value );
                                break;
 
                        /* 13 - Address of finalization function. */
                        case DT_FINI:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_TEXT_FINI, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_TEXT_FINI, ptr_value );
                                break;
 
                        /* 07 - Address of ElfNN_Rela relocations. */
                        case DT_RELA:
-                               //ELF64_Dynamic_SetSectionAddress( p_pginfo, LIBGOBLIN_SECTION_ID_, ptr_addr );
+                               //ELF64_Dynamic_SetSectionAddress( p_pginfo, LIBGOBLIN_SECTION_ID_, ptr_value );
                                break;
 
                        /* 08 - Total size of ElfNN_Rela relocations. */
@@ -515,19 +515,19 @@ int
                        /* 0x6ffffff0 - Address of versym section. */
                        case DT_VERSYM:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GNU_VERSION, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GNU_VERSION, ptr_value );
                                break;
 
                        /* 0x6ffffffe -  Address of verneed section. */
                        case DT_VERNEED:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GNU_VERSION_R, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GNU_VERSION_R, ptr_value );
                                break;
 
                        /* 0x6ffffef5 - GNU-style hash table */
                        case DT_GNU_HASH:
                                ELF64_Dynamic_SetSectionAddress(
-                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GNU_HASH, ptr_addr );
+                                               p_pginfo, p_binfo, LIBGOBLIN_SECTION_ID_GNU_HASH, ptr_value );
                                // XXX
                                break;
                        /* 0x6ffffff9 - number of RELATIVE relocations */

diff --git a/libgoblin/drd64_libgoblin_elf_symtab.c b/libgoblin/drd64_libgoblin_elf_symtab.c
index bd61e10..34d1372 100644 (file)
--- a/libgoblin/drd64_libgoblin_elf_symtab.c
+++ b/libgoblin/drd64_libgoblin_elf_symtab.c
@@ -94,7 +94,7 @@ int
 
                for( dw_cnt = 0; ((dw_cnt < dw_symbols) && (0x00 == i_result)); dw_cnt++, p_sym64++ )   {
                        i_result        = LibGoblin_SymWork_AddSymbolWorkInfo(
-                                                               p_binfo, p_symwork, (Ptr)p_sym64->st_value, (Byte *)p_sym64,
+                                                               p_binfo, p_symwork, (PtrValue)p_sym64->st_value, (Byte *)p_sym64,
                                                                LIBGOBLIN_SYMWORKINFO_TYPE_SYMTAB );
                }
        }
@@ -103,7 +103,7 @@ int
 
                for( dw_cnt = 0; ((dw_cnt < dw_symbols) && (0x00 == i_result)); dw_cnt++, p_sym32++ )   {
                         i_result       = LibGoblin_SymWork_AddSymbolWorkInfo(
-                                                               p_binfo, p_symwork, (Ptr)p_sym32->st_value, (Byte *)p_sym32,
+                                                               p_binfo, p_symwork, (PtrValue)p_sym32->st_value, (Byte *)p_sym32,
                                                                LIBGOBLIN_SYMWORKINFO_TYPE_SYMTAB );
                }
        }

diff --git a/libgoblin/drd64_libgoblin_objinfo.c b/libgoblin/drd64_libgoblin_objinfo.c
index 4abd22e..00709f7 100644 (file)
--- a/libgoblin/drd64_libgoblin_objinfo.c
+++ b/libgoblin/drd64_libgoblin_objinfo.c
@@ -159,8 +159,8 @@ int
 
        assert( 0 == p_objinfo->i_id );
 
-       p_objinfo->addr.ptr_addr        = 0x0000000000000000;
-       p_objinfo->addr.qw_size         = 0xffffffffffffffff;
+       p_objinfo->addr.ptr_addr.value  = 0x0000000000000000;
+       p_objinfo->addr.qw_size                 = 0xffffffffffffffff;
 
        p_pginfo->objinfo.i_topid       = p_objinfo->i_id;
 
@@ -174,7 +174,7 @@ LIBGOBLIN_OBJINFO_EXTERN
 LibGoblin_ObjectInfo *
        ObjectInfo_InsetObject(
                        LibGoblin_ProgramInfo   *p_pginfo,
-                       Ptr                                             ptr_address,
+                       PtrValue                                ptr_value,
                        QWord                                   qw_size,
                        LibGoblin_ObjectInfo    *p_parent,
                        Byte                                    b_mode )
@@ -212,15 +212,15 @@ LibGoblin_ObjectInfo *
        p_objprev       = NULL;
        do      {
 
-               if(( p_objnow->addr.ptr_addr <= ptr_address )
-                               && ( (ptr_address + qw_size) <= (p_objnow->addr.ptr_addr + p_objnow->addr.qw_size) ))   {
+               if(( p_objnow->addr.ptr_addr.value <= ptr_value )
+                               && ( (ptr_value + qw_size) <= (p_objnow->addr.ptr_addr.value + p_objnow->addr.qw_size) ))       {
                        if( p_objnow->addr.qw_size <= p_objover->addr.qw_size ) { p_objover     = p_objnow; }
                }
 
-               if( ptr_address == p_objnow->addr.ptr_addr )    {
+               if( ptr_value == p_objnow->addr.ptr_addr.value )        {
                        if( qw_size > p_objnow->addr.qw_size )  { break; }
                }
-               else if( ptr_address < p_objnow->addr.ptr_addr )        { break; }
+               else if( ptr_value < p_objnow->addr.ptr_addr.value )    { break; }
                
                p_objprev       = p_objnow;
                p_objnow        = ((NO_OBJ != p_objnow->addrlink.i_next_id)
@@ -249,10 +249,10 @@ LibGoblin_ObjectInfo *
                                                        ? OBJINFO( p_pginfo, p_parent->grplink.i_child_topid ) : NULL );
        p_objprev       = NULL;
        do      {
-               if( ptr_address == p_objnow->addr.ptr_addr )    {
+               if( ptr_value == p_objnow->addr.ptr_addr.value )        {
                        if( qw_size > p_objnow->addr.qw_size )  { break; }
                }
-               else if( ptr_address < p_objnow->addr.ptr_addr )        { break; }
+               else if( ptr_value < p_objnow->addr.ptr_addr.value )    { break; }
                
                p_objprev       = p_objnow;
                p_objnow        = ((NO_OBJ != p_objnow->grplink.i_next_id)
@@ -269,8 +269,8 @@ LibGoblin_ObjectInfo *
        if( NULL != p_objnow )  { p_objnow->grplink.i_prev_id   = p_objinfo->i_id; }
 
 goto_ObjectInfo_InsetObject_set:
-       p_objinfo->addr.ptr_addr        = ptr_address;
-       p_objinfo->addr.qw_size         = qw_size;
+       p_objinfo->addr.ptr_addr.value  = ptr_value;
+       p_objinfo->addr.qw_size                 = qw_size;
 
 goto_ObjectInfo_InsetObject_post:
        return p_objinfo;
@@ -284,7 +284,7 @@ LibGoblin_ObjectInfo *
        ObjectInfo_AllocWorkObject(
                        LibGoblin_ProgramInfo   *p_pginfo,
                        LibGoblin_ObjectInfo    *p_objtop,
-                       Ptr                                             ptr_address )
+                       Ptr                                             ptr_addr )
 {
        LibGoblin_ObjectInfo    *p_objinfo;
 

diff --git a/libgoblin/drd64_libgoblin_objinfo.h b/libgoblin/drd64_libgoblin_objinfo.h
index d1af519..b678740 100644 (file)
--- a/libgoblin/drd64_libgoblin_objinfo.h
+++ b/libgoblin/drd64_libgoblin_objinfo.h
@@ -68,7 +68,7 @@ LIBGOBLIN_OBJINFO_EXTERN
        LibGoblin_ObjectInfo *ObjectInfo_AllocObjectInfo( LibGoblin_ProgramInfo *p_pginfo );
 LIBGOBLIN_OBJINFO_EXTERN
        LibGoblin_ObjectInfo *ObjectInfo_InsetObject(
-                       LibGoblin_ProgramInfo *p_pginfo, Ptr ptr_address, QWord qw_size,
+                       LibGoblin_ProgramInfo *p_pginfo, PtrValue ptr_value, QWord qw_size,
             LibGoblin_ObjectInfo *p_parent, Byte b_mode );
 LIBGOBLIN_OBJINFO_EXTERN
        int ObjectInfo_FreeObjectInfo( LibGoblin_ProgramInfo *p_pginfo, LibGoblin_ObjectInfo *p_binfo );

diff --git a/libgoblin/drd64_libgoblin_section.c b/libgoblin/drd64_libgoblin_section.c
index 95e0b6d..9faed72 100644 (file)
--- a/libgoblin/drd64_libgoblin_section.c
+++ b/libgoblin/drd64_libgoblin_section.c
@@ -189,7 +189,7 @@ int
 
                for( dw_cnt = 0; ((dw_cnt < dw_symbols) && (0x00 == i_result)); dw_cnt++, p_sym64++ )   {
                        i_result        = LibGoblin_SymWork_AddSymbolWorkInfo(
-                                                               p_binfo, p_symwork, (Ptr)p_sym64->st_value, (Byte *)p_sym64,
+                                                               p_binfo, p_symwork, (PtrValue)p_sym64->st_value, (Byte *)p_sym64,
                                                                LIBGOBLIN_SYMWORKINFO_TYPE_SYMTAB );
                }
        }
@@ -198,7 +198,7 @@ int
 
                for( dw_cnt = 0; ((dw_cnt < dw_symbols) && (0x00 == i_result)); dw_cnt++, p_sym32++ )   {
                         i_result       = LibGoblin_SymWork_AddSymbolWorkInfo(
-                                                               p_binfo, p_symwork, (Ptr)p_sym32->st_value, (Byte *)p_sym32,
+                                                               p_binfo, p_symwork, (PtrValue)p_sym32->st_value, (Byte *)p_sym32,
                                                                LIBGOBLIN_SYMWORKINFO_TYPE_SYMTAB );
                }
        }
@@ -291,7 +291,7 @@ int
 
                if( NULL != p_section->pb_sechdr )      {
                        p_objinfo       = ObjectInfo_InsetObject(
-                                                               p_pginfo, p_section->ptr_address, p_section->qw_size, NULL, 0x01 );
+                                                               p_pginfo, p_section->ptr_addr.value, p_section->qw_size, NULL, 0x01 );
 
                        p_objinfo->b_type       = OBJINFO_TYPE_SECTION;
                        p_objinfo->file.i_fid   = p_section->i_fid;

diff --git a/libgoblin/drd64_libgoblin_symwork.c b/libgoblin/drd64_libgoblin_symwork.c
index 2349365..666f2b8 100644 (file)
--- a/libgoblin/drd64_libgoblin_symwork.c
+++ b/libgoblin/drd64_libgoblin_symwork.c
@@ -62,9 +62,9 @@ int
                        LibGoblin_SymbolWorkInfo        *p_symdata,
                        LibGoblin_SymbolWorkInfo        *p_sympivot )
 {
-       if( p_symdata->ptr_address < p_sympivot->ptr_address )
+       if( p_symdata->ptr_value < p_sympivot->ptr_value )
                { return -0x01; }
-       else if( p_symdata->ptr_address > p_sympivot->ptr_address )
+       else if( p_symdata->ptr_value > p_sympivot->ptr_value )
                { return 0x01; }
 
        if((STT_SECTION == (p_symdata->dw_type & 0x0f))
@@ -182,9 +182,9 @@ int
        LibGoblin_SymWork_AddSymbolWorkInfo(
                LibGoblin_BinaryInfo            *p_binfo,
                LibGoblin_SymbolWorkTable       *p_symworktbl,
-               Ptr             ptr_address,
-               Byte    *pb_dataptr,
-               DWord   dw_type )
+               PtrValue        ptr_value,
+               Byte            *pb_dataptr,
+               DWord           dw_type )
 {
        DWord           dw_value;
        Elf32_Sym       *p_sym32;
@@ -224,7 +224,7 @@ int
        
        p_symwork       += p_symworktbl->dw_max_symwork;
 
-       p_symwork->ptr_address  = ptr_address;
+       p_symwork->ptr_value    = ptr_value;
        p_symwork->dw_type              = dw_value;
        p_symwork->pb_symbol    = pb_dataptr;
 

diff --git a/libgoblin/drd64_libgoblin_symwork.h b/libgoblin/drd64_libgoblin_symwork.h
index ad1455c..2d1e3da 100644 (file)
--- a/libgoblin/drd64_libgoblin_symwork.h
+++ b/libgoblin/drd64_libgoblin_symwork.h
@@ -58,7 +58,7 @@ Comment:
 
 
 typedef        struct  {
-       Ptr             ptr_address;
+       PtrValue        ptr_value;
        Byte    *pb_symbol;
        DWord   dw_type;
 } LibGoblin_SymbolWorkInfo;
@@ -78,7 +78,7 @@ LIBGOBLIN_SYMWORK_EXTERN
 LIBGOBLIN_SYMWORK_EXTERN
        int LibGoblin_SymWork_AddSymbolWorkInfo(
                        LibGoblin_BinaryInfo *p_binfo, LibGoblin_SymbolWorkTable *p_symworktbl,
-                       Ptr ptr_address, Byte *pb_dataptr, DWord dw_type );
+                       PtrValue ptr_address, Byte *pb_dataptr, DWord dw_type );
 LIBGOBLIN_SYMWORK_EXTERN
        LibGoblin_SymbolWorkInfo *LibGoblin_SymWork_CreateWorkTable(
                        LibGoblin_BinaryInfo *p_binfo, DWord *pdw_items, int i_analyzefid );

diff --git a/libgoblin/drd64_libgoblin_type.h b/libgoblin/drd64_libgoblin_type.h
index c7e4b1b..fa01190 100644 (file)
--- a/libgoblin/drd64_libgoblin_type.h
+++ b/libgoblin/drd64_libgoblin_type.h
@@ -42,7 +42,7 @@ Comment:
 typedef struct {
        Byte    *pb_sechdr;
        Byte    *pb_data;               // FileLocation (Offset)
-       Ptr             ptr_address;
+       Ptr             ptr_addr;
        QWord   qw_size;
        char    *pstr_secname;
        int             i_fid;
@@ -121,7 +121,7 @@ typedef     struct  {
 
 /*=====================================================================*/
 typedef struct {
-       Ptr             ptr_address;
+       Ptr             ptr_addr;
        int             i_objid;
 } LibGoblin_AddressInfo;