• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 *
get_type(Dwarf_Die * die,Dwarf_Attribute * attr_mem,Dwarf_Die * type_mem)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
array_size(Dwarf_Die * die,Dwarf_Word * size,Dwarf_Attribute * attr_mem,Dwarf_Die * type_mem)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
aggregate_size(Dwarf_Die * die,Dwarf_Word * size,Dwarf_Die * type_mem)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
dwarf_aggregate_size(die,size)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)
244