libdw/dwarf_aggregate_size.c

   1 /* Compute size of an aggregate type from DWARF.
   2    Copyright (C) 2010 Red Hat, Inc.
   3    This file is part of Red Hat elfutils.
   4
   5    Red Hat elfutils is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; version 2 of the License.
   8
   9    Red Hat elfutils is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with Red Hat elfutils; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  17
  18    In addition, as a special exception, Red Hat, Inc. gives You the
  19    additional right to link the code of Red Hat elfutils with code licensed
  20    under any Open Source Initiative certified open source license
  21    (http://www.opensource.org/licenses/index.php) which requires the
  22    distribution of source code with any binary distribution and to
  23    distribute linked combinations of the two.  Non-GPL Code permitted under
  24    this exception must only link to the code of Red Hat elfutils through
  25    those well defined interfaces identified in the file named EXCEPTION
  26    found in the source code files (the "Approved Interfaces").  The files
  27    of Non-GPL Code may instantiate templates or use macros or inline
  28    functions from the Approved Interfaces without causing the resulting
  29    work to be covered by the GNU General Public License.  Only Red Hat,
  30    Inc. may make changes or additions to the list of Approved Interfaces.
  31    Red Hat's grant of this exception is conditioned upon your not adding
  32    any new exceptions.  If you wish to add a new Approved Interface or
  33    exception, please contact Red Hat.  You must obey the GNU General Public
  34    License in all respects for all of the Red Hat elfutils code and other
  35    code used in conjunction with Red Hat elfutils except the Non-GPL Code
  36    covered by this exception.  If you modify this file, you may extend this
  37    exception to your version of the file, but you are not obligated to do
  38    so.  If you do not wish to provide this exception without modification,
  39    you must delete this exception statement from your version and license
  40    this file solely under the GPL without exception.
  41
  42    Red Hat elfutils is an included package of the Open Invention Network.
  43    An included package of the Open Invention Network is a package for which
  44    Open Invention Network licensees cross-license their patents.  No patent
  45    license is granted, either expressly or impliedly, by designation as an
  46    included package.  Should you wish to participate in the Open Invention
  47    Network licensing program, please visit www.openinventionnetwork.com
  48    <http://www.openinventionnetwork.com>.  */
  49
  50 #ifdef HAVE_CONFIG_H
  51 # include <config.h>
  52 #endif
  53
  54 #include <dwarf.h>
  55 #include "libdwP.h"
  56
  57
  58 static Dwarf_Die *
  59 get_type (Dwarf_Die *die, Dwarf_Attribute *attr_mem, Dwarf_Die *type_mem)
  60 {
  61   return INTUSE(dwarf_formref_die)
  62     (INTUSE(dwarf_attr_integrate) (die, DW_AT_type, attr_mem), type_mem);
  63 }
  64
  65 static int
  66 array_size (Dwarf_Die *die, Dwarf_Word *size,
  67             Dwarf_Attribute *attr_mem, Dwarf_Die *type_mem)
  68 {
  69   Dwarf_Word eltsize;
  70   if (INTUSE(dwarf_aggregate_size) (get_type (die, attr_mem, type_mem),
  71                                     &eltsize) != 0)
  72       return -1;
  73
  74   /* An array can have DW_TAG_subrange_type or DW_TAG_enumeration_type
  75      children instead that give the size of each dimension.  */
  76
  77   Dwarf_Die child;
  78   if (INTUSE(dwarf_child) (die, &child) != 0)
  79     return -1;
  80
  81   bool any = false;
  82   Dwarf_Word total = 0;
  83   do
  84     {
  85       Dwarf_Word count;
  86       switch (INTUSE(dwarf_tag) (&child))
  87         {
  88         case DW_TAG_subrange_type:
  89           /* This has either DW_AT_count or DW_AT_upper_bound.  */
  90           if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_count,
  91                                             attr_mem) != NULL)
  92             {
  93               if (INTUSE(dwarf_formudata) (attr_mem, &count) != 0)
  94                 return -1;
  95             }
  96           else
  97             {
  98               Dwarf_Sword upper;
  99               Dwarf_Sword lower;
 100               if (INTUSE(dwarf_formsdata) (INTUSE(dwarf_attr_integrate)
 101                                            (&child, DW_AT_upper_bound,
 102                                             attr_mem), &upper) != 0)
 103                 return -1;
 104
 105               /* Having DW_AT_lower_bound is optional.  */
 106               if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_lower_bound,
 107                                                 attr_mem) != NULL)
 108                 {
 109                   if (INTUSE(dwarf_formsdata) (attr_mem, &lower) != 0)
 110                     return -1;
 111                 }
 112               else
 113                 {
 114                   /* Determine default lower bound from language,
 115                      as per "4.12 Subrange Type Entries".  */
 116                   Dwarf_Die cu = CUDIE (die->cu);
 117                   switch (INTUSE(dwarf_srclang) (&cu))
 118                     {
 119                     case DW_LANG_C:
 120                     case DW_LANG_C89:
 121                     case DW_LANG_C99:
 122                     case DW_LANG_C_plus_plus:
 123                     case DW_LANG_Objc:
 124                     case DW_LANG_ObjC_plus_plus:
 125                     case DW_LANG_Java:
 126                     case DW_LANG_D:
 127                     case DW_LANG_UPC:
 128                       lower = 0;
 129                       break;
 130
 131                     case DW_LANG_Ada83:
 132                     case DW_LANG_Ada95:
 133                     case DW_LANG_Cobol74:
 134                     case DW_LANG_Cobol85:
 135                     case DW_LANG_Fortran77:
 136                     case DW_LANG_Fortran90:
 137                     case DW_LANG_Fortran95:
 138                     case DW_LANG_Pascal83:
 139                     case DW_LANG_Modula2:
 140                     case DW_LANG_PL1:
 141                       lower = 1;
 142                       break;
 143
 144                     default:
 145                       return -1;
 146                     }
 147                 }
 148               if (unlikely (lower > upper))
 149                 return -1;
 150               count = upper - lower + 1;
 151             }
 152           break;
 153
 154         case DW_TAG_enumeration_type:
 155           /* We have to find the DW_TAG_enumerator child with the
 156              highest value to know the array's element count.  */
 157           count = 0;
 158           Dwarf_Die enum_child;
 159           int has_children = INTUSE(dwarf_child) (die, &enum_child);
 160           if (has_children < 0)
 161             return -1;
 162           if (has_children > 0)
 163             do
 164               if (INTUSE(dwarf_tag) (&enum_child) == DW_TAG_enumerator)
 165                 {
 166                   Dwarf_Word value;
 167                   if (INTUSE(dwarf_formudata) (INTUSE(dwarf_attr_integrate)
 168                                                (&enum_child, DW_AT_const_value,
 169                                                 attr_mem), &value) != 0)
 170                     return -1;
 171                   if (value >= count)
 172                     count = value + 1;
 173                 }
 174             while (INTUSE(dwarf_siblingof) (&enum_child, &enum_child) > 0);
 175           break;
 176
 177         default:
 178           continue;
 179         }
 180
 181       /* This is a subrange_type or enumeration_type and we've set COUNT.
 182          Now determine the stride for this array dimension.  */
 183       Dwarf_Word stride = eltsize;
 184       if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_byte_stride,
 185                                         attr_mem) != NULL)
 186         {
 187           if (INTUSE(dwarf_formudata) (attr_mem, &stride) != 0)
 188             return -1;
 189         }
 190       else if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_bit_stride,
 191                                              attr_mem) != NULL)
 192         {
 193           if (INTUSE(dwarf_formudata) (attr_mem, &stride) != 0)
 194             return -1;
 195           if (stride % 8)       /* XXX maybe compute in bits? */
 196             return -1;
 197           stride /= 8;
 198         }
 199
 200       any = true;
 201       total += stride * count;
 202     }
 203   while (INTUSE(dwarf_siblingof) (&child, &child) == 0);
 204
 205   if (!any)
 206     return -1;
 207
 208   *size = total;
 209   return 0;
 210 }
 211
 212 static int
 213 aggregate_size (Dwarf_Die *die, Dwarf_Word *size, Dwarf_Die *type_mem)
 214 {
 215   Dwarf_Attribute attr_mem;
 216
 217   if (INTUSE(dwarf_attr_integrate) (die, DW_AT_byte_size, &attr_mem) != NULL)
 218     return INTUSE(dwarf_formudata) (&attr_mem, size);
 219
 220   switch (INTUSE(dwarf_tag) (die))
 221     {
 222     case DW_TAG_typedef:
 223     case DW_TAG_subrange_type:
 224       return aggregate_size (get_type (die, &attr_mem, type_mem),
 225                              size, type_mem); /* Tail call.  */
 226
 227     case DW_TAG_array_type:
 228       return array_size (die, size, &attr_mem, type_mem);
 229     }
 230
 231   /* Most types must give their size directly.  */
 232   return -1;
 233 }
 234
 235 int
 236 dwarf_aggregate_size (die, size)
 237      Dwarf_Die *die;
 238      Dwarf_Word *size;
 239 {
 240   Dwarf_Die type_mem;
 241   return aggregate_size (die, size, &type_mem);
 242 }
 243 INTDEF (dwarf_aggregate_size)