contrib/elftoolchain/libdwarf/libdwarf_elf_access.c

   1 /*-
   2  * Copyright (c) 2009 Kai Wang
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include "_libdwarf.h"
  28
  29 ELFTC_VCSID("$Id: libdwarf_elf_access.c 2070 2011-10-27 03:05:32Z jkoshy $");
  30
  31 int
  32 _dwarf_elf_get_section_info(void *obj, Dwarf_Half ndx,
  33     Dwarf_Obj_Access_Section *ret_section, int *error)
  34 {
  35         Dwarf_Elf_Object *e;
  36         GElf_Shdr *sh;
  37
  38         e = obj;
  39         assert(e != NULL);
  40
  41         if (ret_section == NULL) {
  42                 if (error)
  43                         *error = DW_DLE_ARGUMENT;
  44                 return (DW_DLV_ERROR);
  45         }
  46
  47         if (ndx >= e->eo_seccnt) {
  48                 if (error)
  49                         *error = DW_DLE_NO_ENTRY;
  50                 return (DW_DLV_NO_ENTRY);
  51         }
  52
  53         sh = &e->eo_shdr[ndx];
  54
  55         ret_section->addr = sh->sh_addr;
  56         ret_section->size = sh->sh_size;
  57
  58         ret_section->name = elf_strptr(e->eo_elf, e->eo_strndx, sh->sh_name);
  59         if (ret_section->name == NULL) {
  60                 if (error)
  61                         *error = DW_DLE_ELF;
  62                 return (DW_DLV_ERROR);
  63         }
  64
  65         return (DW_DLV_OK);
  66 }
  67
  68 Dwarf_Endianness
  69 _dwarf_elf_get_byte_order(void *obj)
  70 {
  71         Dwarf_Elf_Object *e;
  72
  73         e = obj;
  74         assert(e != NULL);
  75
  76         switch (e->eo_ehdr.e_ident[EI_DATA]) {
  77         case ELFDATA2MSB:
  78                 return (DW_OBJECT_MSB);
  79
  80         case ELFDATA2LSB:
  81         case ELFDATANONE:
  82         default:
  83                 return (DW_OBJECT_LSB);
  84         }
  85 }
  86
  87 Dwarf_Small
  88 _dwarf_elf_get_length_size(void *obj)
  89 {
  90         Dwarf_Elf_Object *e;
  91
  92         e = obj;
  93         assert(e != NULL);
  94
  95         if (gelf_getclass(e->eo_elf) == ELFCLASS32)
  96                 return (4);
  97         else if (e->eo_ehdr.e_machine == EM_MIPS)
  98                 return (8);
  99         else
 100                 return (4);
 101 }
 102
 103 Dwarf_Small
 104 _dwarf_elf_get_pointer_size(void *obj)
 105 {
 106         Dwarf_Elf_Object *e;
 107
 108         e = obj;
 109         assert(e != NULL);
 110
 111         if (gelf_getclass(e->eo_elf) == ELFCLASS32)
 112                 return (4);
 113         else
 114                 return (8);
 115 }
 116
 117 Dwarf_Unsigned
 118 _dwarf_elf_get_section_count(void *obj)
 119 {
 120         Dwarf_Elf_Object *e;
 121
 122         e = obj;
 123         assert(e != NULL);
 124
 125         return (e->eo_seccnt);
 126 }
 127
 128 int
 129 _dwarf_elf_load_section(void *obj, Dwarf_Half ndx, Dwarf_Small** ret_data,
 130     int *error)
 131 {
 132         Dwarf_Elf_Object *e;
 133         Dwarf_Elf_Data *ed;
 134
 135         e = obj;
 136         assert(e != NULL);
 137
 138         if (ret_data == NULL) {
 139                 if (error)
 140                         *error = DW_DLE_ARGUMENT;
 141                 return (DW_DLV_ERROR);
 142         }
 143
 144         if (ndx >= e->eo_seccnt) {
 145                 if (error)
 146                         *error = DW_DLE_NO_ENTRY;
 147                 return (DW_DLV_NO_ENTRY);
 148         }
 149
 150         ed = &e->eo_data[ndx];
 151
 152         if (ed->ed_alloc != NULL)
 153                 *ret_data = ed->ed_alloc;
 154         else {
 155                 if (ed->ed_data == NULL) {
 156                         if (error)
 157                                 *error = DW_DLE_NO_ENTRY;
 158                         return (DW_DLV_NO_ENTRY);
 159                 }
 160                 *ret_data = ed->ed_data->d_buf;
 161         }
 162
 163         return (DW_DLV_OK);
 164 }