dlls/dbghelp/image_private.h

   1 /*
   2  * File elf_private.h - definitions for processing of ELF files
   3  *
   4  * Copyright (C) 1996, Eric Youngdale.
   5  *               1999-2007 Eric Pouech
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define IMAGE_NO_MAP  ((void*)-1)
  23
  24 struct elf_header
  25 {
  26     UINT8   e_ident[16];  /* Magic number and other info */
  27     UINT16  e_type;       /* Object file type */
  28     UINT16  e_machine;    /* Architecture */
  29     UINT32  e_version;    /* Object file version */
  30     UINT64  e_entry;      /* Entry point virtual address */
  31     UINT64  e_phoff;      /* Program header table file offset */
  32     UINT64  e_shoff;      /* Section header table file offset */
  33     UINT32  e_flags;      /* Processor-specific flags */
  34     UINT16  e_ehsize;     /* ELF header size in bytes */
  35     UINT16  e_phentsize;  /* Program header table entry size */
  36     UINT16  e_phnum;      /* Program header table entry count */
  37     UINT16  e_shentsize;  /* Section header table entry size */
  38     UINT16  e_shnum;      /* Section header table entry count */
  39     UINT16  e_shstrndx;   /* Section header string table index */
  40 };
  41
  42 struct elf_section_header
  43 {
  44     UINT32  sh_name;       /* Section name (string tbl index) */
  45     UINT32  sh_type;       /* Section type */
  46     UINT64  sh_flags;      /* Section flags */
  47     UINT64  sh_addr;       /* Section virtual addr at execution */
  48     UINT64  sh_offset;     /* Section file offset */
  49     UINT64  sh_size;       /* Section size in bytes */
  50     UINT32  sh_link;       /* Link to another section */
  51     UINT32  sh_info;       /* Additional section information */
  52     UINT64  sh_addralign;  /* Section alignment */
  53     UINT64  sh_entsize;    /* Entry size if section holds table */
  54 };
  55
  56 struct macho_load_command
  57 {
  58     UINT32  cmd;           /* type of load command */
  59     UINT32  cmdsize;       /* total size of command in bytes */
  60 };
  61
  62 struct macho_uuid_command
  63 {
  64     UINT32  cmd;           /* LC_UUID */
  65     UINT32  cmdsize;
  66     UINT8   uuid[16];
  67 };
  68
  69 struct macho_section
  70 {
  71     char    sectname[16];  /* name of this section */
  72     char    segname[16];   /* segment this section goes in */
  73     UINT64  addr;          /* memory address of this section */
  74     UINT64  size;          /* size in bytes of this section */
  75     UINT32  offset;        /* file offset of this section */
  76     UINT32  align;         /* section alignment (power of 2) */
  77     UINT32  reloff;        /* file offset of relocation entries */
  78     UINT32  nreloc;        /* number of relocation entries */
  79     UINT32  flags;         /* flags (section type and attributes)*/
  80     UINT32  reserved1;     /* reserved (for offset or index) */
  81     UINT32  reserved2;     /* reserved (for count or sizeof) */
  82     UINT32  reserved3;     /* reserved */
  83 };
  84
  85 struct macho_section32
  86 {
  87     char    sectname[16];  /* name of this section */
  88     char    segname[16];   /* segment this section goes in */
  89     UINT32  addr;          /* memory address of this section */
  90     UINT32  size;          /* size in bytes of this section */
  91     UINT32  offset;        /* file offset of this section */
  92     UINT32  align;         /* section alignment (power of 2) */
  93     UINT32  reloff;        /* file offset of relocation entries */
  94     UINT32  nreloc;        /* number of relocation entries */
  95     UINT32  flags;         /* flags (section type and attributes)*/
  96     UINT32  reserved1;     /* reserved (for offset or index) */
  97     UINT32  reserved2;     /* reserved (for count or sizeof) */
  98 };
  99
 100 /* structure holding information while handling an ELF image
 101  * allows one by one section mapping for memory savings
 102  */
 103 struct image_file_map
 104 {
 105     enum module_type            modtype;
 106     const struct image_file_map_ops *ops;
 107     unsigned                    addr_size;      /* either 16 (not used), 32 or 64 */
 108     struct image_file_map*      alternate;      /* another file linked to this one */
 109     union
 110     {
 111         struct elf_file_map
 112         {
 113             size_t                      elf_size;
 114             size_t                      elf_start;
 115             HANDLE                      handle;
 116             const char*                 shstrtab;
 117             char*                       target_copy;
 118             struct elf_header           elfhdr;
 119             struct
 120             {
 121                 struct elf_section_header       shdr;
 122                 const char*                     mapped;
 123             }*                          sect;
 124         } elf;
 125         struct macho_file_map
 126         {
 127             size_t                      segs_size;
 128             size_t                      segs_start;
 129             HANDLE                      handle;
 130             struct image_file_map*      dsym;   /* the debug symbols file associated with this one */
 131             size_t                      header_size; /* size of real header in file */
 132             size_t                      commands_size;
 133             unsigned int                commands_count;
 134
 135             const struct macho_load_command*    load_commands;
 136             const struct macho_uuid_command*    uuid;
 137
 138             /* The offset in the file which is this architecture.  mach_header was
 139              * read from arch_offset. */
 140             unsigned                    arch_offset;
 141
 142             int                         num_sections;
 143             struct
 144             {
 145                 struct macho_section            section;
 146                 const char*                     mapped;
 147                 unsigned int                    ignored : 1;
 148             }*                          sect;
 149         } macho;
 150         struct pe_file_map
 151         {
 152             HANDLE                      hMap;
 153             IMAGE_NT_HEADERS            ntheader;
 154             BOOL                        builtin;
 155             unsigned                    full_count;
 156             void*                       full_map;
 157             struct
 158             {
 159                 IMAGE_SECTION_HEADER            shdr;
 160                 const char*                     mapped;
 161             }*                          sect;
 162             const char*                 strtable;
 163         } pe;
 164     } u;
 165 };
 166
 167 struct image_section_map
 168 {
 169     struct image_file_map*      fmap;
 170     LONG_PTR                    sidx;
 171 };
 172
 173 struct stab_nlist
 174 {
 175     unsigned            n_strx;
 176     unsigned char       n_type;
 177     char                n_other;
 178     short               n_desc;
 179     unsigned            n_value;
 180 };
 181
 182 struct macho64_nlist
 183 {
 184     unsigned            n_strx;
 185     unsigned char       n_type;
 186     char                n_other;
 187     short               n_desc;
 188     UINT64              n_value;
 189 };
 190
 191 BOOL image_check_alternate(struct image_file_map* fmap, const struct module* module) DECLSPEC_HIDDEN;
 192
 193 BOOL elf_map_handle(HANDLE handle, struct image_file_map* fmap) DECLSPEC_HIDDEN;
 194 BOOL pe_map_file(HANDLE file, struct image_file_map* fmap, enum module_type mt) DECLSPEC_HIDDEN;
 195
 196 struct image_file_map_ops
 197 {
 198     const char* (*map_section)(struct image_section_map* ism);
 199     void  (*unmap_section)(struct image_section_map* ism);
 200     BOOL (*find_section)(struct image_file_map* fmap, const char* name, struct image_section_map* ism);
 201     DWORD_PTR (*get_map_rva)(const struct image_section_map* ism);
 202     unsigned (*get_map_size)(const struct image_section_map* ism);
 203     void (*unmap_file)(struct image_file_map *fmap);
 204 };
 205
 206 static inline BOOL image_find_section(struct image_file_map* fmap, const char* name,
 207                                       struct image_section_map* ism)
 208 {
 209     while (fmap)
 210     {
 211         if (fmap->ops->find_section(fmap, name, ism)) return TRUE;
 212         fmap = fmap->alternate;
 213     }
 214     ism->fmap = NULL;
 215     ism->sidx = -1;
 216     return FALSE;
 217 }
 218
 219 static inline void image_unmap_file(struct image_file_map* fmap)
 220 {
 221     while (fmap)
 222     {
 223         fmap->ops->unmap_file(fmap);
 224         fmap = fmap->alternate;
 225     }
 226 }
 227
 228 static inline const char* image_map_section(struct image_section_map* ism)
 229 {
 230     return ism->fmap ? ism->fmap->ops->map_section(ism) : NULL;
 231 }
 232
 233 static inline void image_unmap_section(struct image_section_map* ism)
 234 {
 235     if (ism->fmap) ism->fmap->ops->unmap_section(ism);
 236 }
 237
 238 static inline DWORD_PTR image_get_map_rva(const struct image_section_map* ism)
 239 {
 240     return ism->fmap ? ism->fmap->ops->get_map_rva(ism) : 0;
 241 }
 242
 243 static inline unsigned image_get_map_size(const struct image_section_map* ism)
 244 {
 245     return ism->fmap ? ism->fmap->ops->get_map_size(ism) : 0;
 246 }