image_private.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	elf_header
struct	elf_section_header
struct	macho_load_command
struct	macho_uuid_command
struct	macho_section
struct	macho_section32
struct	image_file_map
struct	image_section_map
struct	stab_nlist
struct	macho64_nlist
struct	image_file_map_ops

Macros
#define	IMAGE_NO_MAP   ((void*)-1)

Functions
BOOL	image_check_alternate (struct image_file_map *fmap, const struct module *module) DECLSPEC_HIDDEN
BOOL	elf_map_handle (HANDLE handle, struct image_file_map *fmap) DECLSPEC_HIDDEN
BOOL	pe_map_file (HANDLE file, struct image_file_map *fmap, enum module_type mt) DECLSPEC_HIDDEN
static BOOL	image_find_section (struct image_file_map *fmap, const char *name, struct image_section_map *ism)
static void	image_unmap_file (struct image_file_map *fmap)
static const char *	image_map_section (struct image_section_map *ism)
static void	image_unmap_section (struct image_section_map *ism)
static DWORD_PTR	image_get_map_rva (const struct image_section_map *ism)
static unsigned	image_get_map_size (const struct image_section_map *ism)

Macro Definition Documentation

IMAGE_NO_MAP

#define IMAGE_NO_MAP   ((void*)-1)

Definition at line 24 of file image_private.h.

Function Documentation

elf_map_handle()

BOOL elf_map_handle	(	HANDLE	handle,
		struct image_file_map *	fmap
	)

Definition at line 582 of file elf_module.c.

{
    struct elf_map_file_data emfd;
    emfd.kind = from_handle;
    emfd.u.handle = handle;
    return elf_map_file(&emfd, fmap);
}

Referenced by image_check_debug_link().

image_check_alternate()

BOOL image_check_alternate	(	struct image_file_map *	fmap,
		const struct module *	module
	)

Definition at line 701 of file module.c.

{
    BOOL ret = FALSE;
    BOOL found = FALSE;
    struct image_section_map buildid_sect, debuglink_sect;
 
    /* if present, add the .gnu_debuglink file as an alternate to current one */
    if (image_find_section(fmap, ".note.gnu.build-id", &buildid_sect))
    {
        const UINT32* note;
 
        found = TRUE;
        note = (const UINT32*)image_map_section(&buildid_sect);
        if (note != IMAGE_NO_MAP)
        {
            /* the usual ELF note structure: name-size desc-size type <name> <desc> */
            if (note[2] == NOTE_GNU_BUILD_ID)
            {
                ret = image_locate_build_id_target(fmap, (const BYTE*)(note + 3 + ((note[0] + 3) >> 2)), note[1]);
            }
        }
        image_unmap_section(&buildid_sect);
    }
    /* if present, add the .gnu_debuglink file as an alternate to current one */
    if (!ret && image_find_section(fmap, ".gnu_debuglink", &debuglink_sect))
    {
        const char* dbg_link;
 
        found = TRUE;
        dbg_link = (const char*)image_map_section(&debuglink_sect);
        if (dbg_link != IMAGE_NO_MAP)
        {
            /* The content of a debug link section is:
             * 1/ a NULL terminated string, containing the file name for the
             *    debug info
             * 2/ padding on 4 byte boundary
             * 3/ CRC of the linked file
             */
            DWORD crc = *(const DWORD*)(dbg_link + ((DWORD_PTR)(strlen(dbg_link) + 4) & ~3));
            ret = image_locate_debug_link(module, fmap, dbg_link, crc);
            if (!ret)
                WARN("Couldn't load linked debug file for %s\n",
                     debugstr_w(module->module.ModuleName));
        }
        image_unmap_section(&debuglink_sect);
    }
    return found ? ret : TRUE;
}

Referenced by elf_load_debug_info_from_map(), and pe_load_debug_info().

image_find_section()

static BOOL image_find_section ( struct image_file_map *  fmap, const char *  name, struct image_section_map *  ism  )

inlinestatic

Definition at line 208 of file image_private.h.

{
    while (fmap)
    {
        if (fmap->ops->find_section(fmap, name, ism)) return TRUE;
        fmap = fmap->alternate;
    }
    ism->fmap = NULL;
    ism->sidx = -1;
    return FALSE;
}

Referenced by dwarf2_init_section(), elf_load_debug_info_from_map(), image_check_alternate(), and image_locate_build_id_target().

image_get_map_rva()

static DWORD_PTR image_get_map_rva ( const struct image_section_map *  ism )

inlinestatic

Definition at line 240 of file image_private.h.

{
    return ism->fmap ? ism->fmap->ops->get_map_rva(ism) : 0;
}

Referenced by dwarf2_init_section(), and dwarf2_init_zsection().

image_get_map_size()

static unsigned image_get_map_size ( const struct image_section_map *  ism )

inlinestatic

Definition at line 245 of file image_private.h.

{
    return ism->fmap ? ism->fmap->ops->get_map_size(ism) : 0;
}

Referenced by dwarf2_init_section(), dwarf2_init_zsection(), elf_hash_symtab(), elf_load_debug_info_from_map(), pe_load_rsym(), and pe_load_stabs().

image_map_section()

static const char * image_map_section ( struct image_section_map *  ism )

inlinestatic

Definition at line 230 of file image_private.h.

{
    return ism->fmap ? ism->fmap->ops->map_section(ism) : NULL;
}

Referenced by dwarf2_init_section(), dwarf2_init_zsection(), elf_hash_symtab(), elf_load_debug_info_from_map(), image_check_alternate(), image_locate_build_id_target(), pe_load_rsym(), and pe_load_stabs().

image_unmap_file()

static void image_unmap_file ( struct image_file_map *  fmap )

inlinestatic

Definition at line 221 of file image_private.h.

{
    while (fmap)
    {
        fmap->ops->unmap_file(fmap);
        fmap = fmap->alternate;
    }
}

Referenced by elf_fetch_file_info(), elf_load_file(), elf_module_remove(), image_locate_build_id_target(), pe_load_native_module(), and pe_module_remove().

image_unmap_section()

static void image_unmap_section ( struct image_section_map *  ism )

inlinestatic

Definition at line 235 of file image_private.h.

{
    if (ism->fmap) ism->fmap->ops->unmap_section(ism);
}

Referenced by dwarf2_init_zsection(), dwarf2_parse(), elf_hash_symtab(), elf_load_debug_info_from_map(), image_check_alternate(), image_locate_build_id_target(), pe_load_rsym(), and pe_load_stabs().

pe_map_file()

BOOL pe_map_file	(	HANDLE	file,
		struct image_file_map *	fmap,
		enum module_type	mt
	)

Definition at line 245 of file pe_module.c.

{
    void*       mapping;
 
    fmap->modtype = mt;
    fmap->ops = &pe_file_map_ops;
    fmap->alternate = NULL;
    fmap->u.pe.hMap = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
    if (fmap->u.pe.hMap == 0) return FALSE;
    fmap->u.pe.full_count = 0;
    fmap->u.pe.full_map = NULL;
    if (!(mapping = pe_map_full(fmap, NULL))) goto error;
 
    switch (mt)
    {
    case DMT_PE:
        {
            IMAGE_NT_HEADERS*       nthdr;
            IMAGE_SECTION_HEADER*   section;
            unsigned                i;
 
            if (!(nthdr = RtlImageNtHeader(mapping))) goto error;
            memcpy(&fmap->u.pe.ntheader, nthdr, sizeof(fmap->u.pe.ntheader));
            switch (nthdr->OptionalHeader.Magic)
            {
            case 0x10b: fmap->addr_size = 32; break;
            case 0x20b: fmap->addr_size = 64; break;
            default: return FALSE;
            }
 
            fmap->u.pe.builtin = !memcmp((const IMAGE_DOS_HEADER*)mapping + 1, builtin_signature, sizeof(builtin_signature));
            section = (IMAGE_SECTION_HEADER*)
                ((char*)&nthdr->OptionalHeader + nthdr->FileHeader.SizeOfOptionalHeader);
            fmap->u.pe.sect = HeapAlloc(GetProcessHeap(), 0,
                                        nthdr->FileHeader.NumberOfSections * sizeof(fmap->u.pe.sect[0]));
            if (!fmap->u.pe.sect) goto error;
            for (i = 0; i < nthdr->FileHeader.NumberOfSections; i++)
            {
                memcpy(&fmap->u.pe.sect[i].shdr, section + i, sizeof(IMAGE_SECTION_HEADER));
                fmap->u.pe.sect[i].mapped = IMAGE_NO_MAP;
            }
            if (nthdr->FileHeader.PointerToSymbolTable && nthdr->FileHeader.NumberOfSymbols)
            {
                LARGE_INTEGER li;
 
                if (GetFileSizeEx(file, &li) && pe_is_valid_pointer_table(nthdr, mapping, li.QuadPart))
                {
                    /* FIXME ugly: should rather map the relevant content instead of copying it */
                    const char* src = (const char*)mapping +
                        nthdr->FileHeader.PointerToSymbolTable +
                        nthdr->FileHeader.NumberOfSymbols * sizeof(IMAGE_SYMBOL);
                    char* dst;
                    DWORD sz = *(DWORD*)src;
 
                    if ((dst = HeapAlloc(GetProcessHeap(), 0, sz)))
                        memcpy(dst, src, sz);
                    fmap->u.pe.strtable = dst;
                }
                else
                {
                    WARN("Bad coff table... wipping out\n");
                    /* we have bad information here, wipe it out */
                    fmap->u.pe.ntheader.FileHeader.PointerToSymbolTable = 0;
                    fmap->u.pe.ntheader.FileHeader.NumberOfSymbols = 0;
                    fmap->u.pe.strtable = NULL;
                }
            }
            else fmap->u.pe.strtable = NULL;
        }
        break;
    default: assert(0); goto error;
    }
    pe_unmap_full(fmap);
 
    return TRUE;
error:
    pe_unmap_full(fmap);
    CloseHandle(fmap->u.pe.hMap);
    return FALSE;
}

Referenced by image_check_debug_link(), pe_load_native_module(), and search_builtin_pe().