1 /* Compute size of an aggregate type from DWARF.
2 Copyright (C) 2010, 2014, 2016 Red Hat, Inc.
3 This file is part of elfutils.
4
5 This file is free software; you can redistribute it and/or modify
6 it under the terms of either
7
8 * the GNU Lesser General Public License as published by the Free
9 Software Foundation; either version 3 of the License, or (at
10 your option) any later version
11
12 or
13
14 * the GNU General Public License as published by the Free
15 Software Foundation; either version 2 of the License, or (at
16 your option) any later version
17
18 or both in parallel, as here.
19
20 elfutils is distributed in the hope that it will be useful, but
21 WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 General Public License for more details.
24
25 You should have received copies of the GNU General Public License and
26 the GNU Lesser General Public License along with this program. If
27 not, see <http://www.gnu.org/licenses/>. */
28
29 #ifdef HAVE_CONFIG_H
30 # include <config.h>
31 #endif
32
33 #include <dwarf.h>
34 #include "libdwP.h"
35
36
37 static Dwarf_Die *
get_type(Dwarf_Die * die,Dwarf_Attribute * attr_mem,Dwarf_Die * type_mem)38 get_type (Dwarf_Die *die, Dwarf_Attribute *attr_mem, Dwarf_Die *type_mem)
39 {
40 Dwarf_Die *type = INTUSE(dwarf_formref_die)
41 (INTUSE(dwarf_attr_integrate) (die, DW_AT_type, attr_mem), type_mem);
42
43 if (INTUSE(dwarf_peel_type) (type, type) != 0)
44 return NULL;
45
46 return type;
47 }
48
49 static int aggregate_size (Dwarf_Die *die, Dwarf_Word *size,
50 Dwarf_Die *type_mem, int depth);
51
52 static int
array_size(Dwarf_Die * die,Dwarf_Word * size,Dwarf_Attribute * attr_mem,int depth)53 array_size (Dwarf_Die *die, Dwarf_Word *size,
54 Dwarf_Attribute *attr_mem, int depth)
55 {
56 Dwarf_Word eltsize;
57 Dwarf_Die type_mem, aggregate_type_mem;
58 if (aggregate_size (get_type (die, attr_mem, &type_mem), &eltsize,
59 &aggregate_type_mem, depth) != 0)
60 return -1;
61
62 /* An array can have DW_TAG_subrange_type or DW_TAG_enumeration_type
63 children instead that give the size of each dimension. */
64
65 Dwarf_Die child;
66 if (INTUSE(dwarf_child) (die, &child) != 0)
67 return -1;
68
69 bool any = false;
70 Dwarf_Word count_total = 1;
71 do
72 {
73 Dwarf_Word count;
74 switch (INTUSE(dwarf_tag) (&child))
75 {
76 case DW_TAG_subrange_type:
77 /* This has either DW_AT_count or DW_AT_upper_bound. */
78 if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_count,
79 attr_mem) != NULL)
80 {
81 if (INTUSE(dwarf_formudata) (attr_mem, &count) != 0)
82 return -1;
83 }
84 else
85 {
86 Dwarf_Sword upper;
87 Dwarf_Sword lower;
88 if (INTUSE(dwarf_formsdata) (INTUSE(dwarf_attr_integrate)
89 (&child, DW_AT_upper_bound,
90 attr_mem), &upper) != 0)
91 return -1;
92
93 /* Having DW_AT_lower_bound is optional. */
94 if (INTUSE(dwarf_attr_integrate) (&child, DW_AT_lower_bound,
95 attr_mem) != NULL)
96 {
97 if (INTUSE(dwarf_formsdata) (attr_mem, &lower) != 0)
98 return -1;
99 }
100 else
101 {
102 Dwarf_Die cu = CUDIE (die->cu);
103 int lang = INTUSE(dwarf_srclang) (&cu);
104 if (lang == -1
105 || INTUSE(dwarf_default_lower_bound) (lang, &lower) != 0)
106 return -1;
107 }
108 if (unlikely (lower > upper))
109 return -1;
110 count = upper - lower + 1;
111 }
112 break;
113
114 case DW_TAG_enumeration_type:
115 /* We have to find the DW_TAG_enumerator child with the
116 highest value to know the array's element count. */
117 count = 0;
118 Dwarf_Die enum_child;
119 int has_children = INTUSE(dwarf_child) (die, &enum_child);
120 if (has_children < 0)
121 return -1;
122 if (has_children > 0)
123 do
124 if (INTUSE(dwarf_tag) (&enum_child) == DW_TAG_enumerator)
125 {
126 Dwarf_Word value;
127 if (INTUSE(dwarf_formudata) (INTUSE(dwarf_attr_integrate)
128 (&enum_child, DW_AT_const_value,
129 attr_mem), &value) != 0)
130 return -1;
131 if (value >= count)
132 count = value + 1;
133 }
134 while (INTUSE(dwarf_siblingof) (&enum_child, &enum_child) > 0);
135 break;
136
137 default:
138 continue;
139 }
140
141 count_total *= count;
142
143 any = true;
144 }
145 while (INTUSE(dwarf_siblingof) (&child, &child) == 0);
146
147 if (!any)
148 return -1;
149
150 /* This is a subrange_type or enumeration_type and we've set COUNT.
151 Now determine the stride for this array. */
152 Dwarf_Word stride = eltsize;
153 if (INTUSE(dwarf_attr_integrate) (die, DW_AT_byte_stride,
154 attr_mem) != NULL)
155 {
156 if (INTUSE(dwarf_formudata) (attr_mem, &stride) != 0)
157 return -1;
158 }
159 else if (INTUSE(dwarf_attr_integrate) (die, DW_AT_bit_stride,
160 attr_mem) != NULL)
161 {
162 if (INTUSE(dwarf_formudata) (attr_mem, &stride) != 0)
163 return -1;
164 if (stride % 8) /* XXX maybe compute in bits? */
165 return -1;
166 stride /= 8;
167 }
168
169 *size = count_total * stride;
170 return 0;
171 }
172
173 static int
aggregate_size(Dwarf_Die * die,Dwarf_Word * size,Dwarf_Die * type_mem,int depth)174 aggregate_size (Dwarf_Die *die, Dwarf_Word *size,
175 Dwarf_Die *type_mem, int depth)
176 {
177 Dwarf_Attribute attr_mem;
178
179 /* Arrays of arrays of subrange types of arrays... Don't recurse too deep. */
180 #define MAX_DEPTH 256
181 if (die == NULL || depth++ >= MAX_DEPTH)
182 return -1;
183
184 if (INTUSE(dwarf_attr_integrate) (die, DW_AT_byte_size, &attr_mem) != NULL)
185 return INTUSE(dwarf_formudata) (&attr_mem, size);
186
187 switch (INTUSE(dwarf_tag) (die))
188 {
189 case DW_TAG_subrange_type:
190 {
191 Dwarf_Die aggregate_type_mem;
192 return aggregate_size (get_type (die, &attr_mem, type_mem),
193 size, &aggregate_type_mem, depth);
194 }
195
196 case DW_TAG_array_type:
197 return array_size (die, size, &attr_mem, depth);
198
199 /* Assume references and pointers have pointer size if not given an
200 explicit DW_AT_byte_size. */
201 case DW_TAG_pointer_type:
202 case DW_TAG_reference_type:
203 case DW_TAG_rvalue_reference_type:
204 *size = die->cu->address_size;
205 return 0;
206 }
207
208 /* Most types must give their size directly. */
209 return -1;
210 }
211
212 int
dwarf_aggregate_size(Dwarf_Die * die,Dwarf_Word * size)213 dwarf_aggregate_size (Dwarf_Die *die, Dwarf_Word *size)
214 {
215 Dwarf_Die die_mem, type_mem;
216
217 if (INTUSE (dwarf_peel_type) (die, &die_mem) != 0)
218 return -1;
219
220 return aggregate_size (&die_mem, size, &type_mem, 0);
221 }
222 INTDEF (dwarf_aggregate_size)
223 OLD_VERSION (dwarf_aggregate_size, ELFUTILS_0.144)
224 NEW_VERSION (dwarf_aggregate_size, ELFUTILS_0.161)
225