]>
Commit | Line | Data |
---|---|---|
c44af4eb TT |
1 | /* Rust language support routines for GDB, the GNU debugger. |
2 | ||
1d506c26 | 3 | Copyright (C) 2016-2024 Free Software Foundation, Inc. |
c44af4eb TT |
4 | |
5 | This file is part of GDB. | |
6 | ||
7 | This program is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 3 of the License, or | |
10 | (at your option) any later version. | |
11 | ||
12 | This program 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 | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ | |
19 | ||
c44af4eb TT |
20 | |
21 | #include <ctype.h> | |
22 | ||
23 | #include "block.h" | |
24 | #include "c-lang.h" | |
25 | #include "charset.h" | |
26 | #include "cp-support.h" | |
8b302db8 | 27 | #include "demangle.h" |
e5dc0d5d | 28 | #include "event-top.h" |
c44af4eb TT |
29 | #include "gdbarch.h" |
30 | #include "infcall.h" | |
31 | #include "objfiles.h" | |
32 | #include "rust-lang.h" | |
a33ccfc7 | 33 | #include "typeprint.h" |
c44af4eb TT |
34 | #include "valprint.h" |
35 | #include "varobj.h" | |
a33ccfc7 | 36 | #include <algorithm> |
ab8b80a8 TT |
37 | #include <string> |
38 | #include <vector> | |
7f6aba03 | 39 | #include "cli/cli-style.h" |
af30c400 | 40 | #include "parser-defs.h" |
6fab4359 | 41 | #include "rust-exp.h" |
c44af4eb | 42 | |
c9317f21 | 43 | /* See rust-lang.h. */ |
c44af4eb | 44 | |
c9317f21 TT |
45 | const char * |
46 | rust_last_path_segment (const char *path) | |
c44af4eb TT |
47 | { |
48 | const char *result = strrchr (path, ':'); | |
49 | ||
50 | if (result == NULL) | |
c9317f21 | 51 | return path; |
c44af4eb TT |
52 | return result + 1; |
53 | } | |
54 | ||
03c85b11 | 55 | /* See rust-lang.h. */ |
c44af4eb | 56 | |
03c85b11 | 57 | std::string |
c44af4eb TT |
58 | rust_crate_for_block (const struct block *block) |
59 | { | |
3c45e9f9 | 60 | const char *scope = block->scope (); |
c44af4eb TT |
61 | |
62 | if (scope[0] == '\0') | |
03c85b11 | 63 | return std::string (); |
c44af4eb | 64 | |
03c85b11 | 65 | return std::string (scope, cp_find_first_component (scope)); |
c44af4eb TT |
66 | } |
67 | ||
c9317f21 TT |
68 | /* Return true if TYPE, which must be a struct type, represents a Rust |
69 | enum. */ | |
c44af4eb | 70 | |
b96645f1 | 71 | static bool |
9c6a1327 | 72 | rust_enum_p (struct type *type) |
b96645f1 | 73 | { |
9c6a1327 TT |
74 | /* is_dynamic_type will return true if any field has a dynamic |
75 | attribute -- but we only want to check the top level. */ | |
76 | return TYPE_HAS_VARIANT_PARTS (type); | |
b96645f1 MG |
77 | } |
78 | ||
9c6a1327 TT |
79 | /* Return true if TYPE, which must be an already-resolved enum type, |
80 | has no variants. */ | |
098b2108 TT |
81 | |
82 | static bool | |
83 | rust_empty_enum_p (const struct type *type) | |
84 | { | |
1f704f76 | 85 | return type->num_fields () == 0; |
098b2108 TT |
86 | } |
87 | ||
9c6a1327 TT |
88 | /* Given an already-resolved enum type and contents, find which |
89 | variant is active. */ | |
c44af4eb | 90 | |
9c6a1327 TT |
91 | static int |
92 | rust_enum_variant (struct type *type) | |
c44af4eb | 93 | { |
9c6a1327 | 94 | /* The active variant is simply the first non-artificial field. */ |
1f704f76 | 95 | for (int i = 0; i < type->num_fields (); ++i) |
454977cd | 96 | if (!type->field (i).is_artificial ()) |
9c6a1327 | 97 | return i; |
c44af4eb | 98 | |
9c6a1327 TT |
99 | /* Perhaps we could get here by trying to print an Ada variant |
100 | record in Rust mode. Unlikely, but an error is safer than an | |
101 | assert. */ | |
102 | error (_("Could not find active enum variant")); | |
c44af4eb TT |
103 | } |
104 | ||
105 | /* See rust-lang.h. */ | |
106 | ||
65c40c95 | 107 | bool |
c44af4eb TT |
108 | rust_tuple_type_p (struct type *type) |
109 | { | |
110 | /* The current implementation is a bit of a hack, but there's | |
111 | nothing else in the debuginfo to distinguish a tuple from a | |
112 | struct. */ | |
78134374 | 113 | return (type->code () == TYPE_CODE_STRUCT |
7d93a1e0 SM |
114 | && type->name () != NULL |
115 | && type->name ()[0] == '('); | |
c44af4eb TT |
116 | } |
117 | ||
c44af4eb | 118 | /* Return true if all non-static fields of a structlike type are in a |
c9317f21 | 119 | sequence like __0, __1, __2. */ |
c44af4eb | 120 | |
65c40c95 | 121 | static bool |
c9317f21 | 122 | rust_underscore_fields (struct type *type) |
c44af4eb TT |
123 | { |
124 | int i, field_number; | |
125 | ||
126 | field_number = 0; | |
127 | ||
78134374 | 128 | if (type->code () != TYPE_CODE_STRUCT) |
65c40c95 | 129 | return false; |
1f704f76 | 130 | for (i = 0; i < type->num_fields (); ++i) |
c44af4eb | 131 | { |
c819a338 | 132 | if (!type->field (i).is_static ()) |
c44af4eb | 133 | { |
c9317f21 | 134 | char buf[20]; |
c44af4eb | 135 | |
c9317f21 | 136 | xsnprintf (buf, sizeof (buf), "__%d", field_number); |
33d16dd9 | 137 | if (strcmp (buf, type->field (i).name ()) != 0) |
c9317f21 TT |
138 | return false; |
139 | field_number++; | |
c44af4eb TT |
140 | } |
141 | } | |
65c40c95 | 142 | return true; |
c44af4eb TT |
143 | } |
144 | ||
145 | /* See rust-lang.h. */ | |
146 | ||
65c40c95 | 147 | bool |
c44af4eb TT |
148 | rust_tuple_struct_type_p (struct type *type) |
149 | { | |
12df5c00 TT |
150 | /* This is just an approximation until DWARF can represent Rust more |
151 | precisely. We exclude zero-length structs because they may not | |
152 | be tuple structs, and there's no way to tell. */ | |
1f704f76 | 153 | return type->num_fields () > 0 && rust_underscore_fields (type); |
c44af4eb TT |
154 | } |
155 | ||
b0dd661f | 156 | /* Return true if TYPE is "slice-like"; false otherwise. */ |
c44af4eb | 157 | |
b0dd661f | 158 | static bool |
49ed499c | 159 | rust_slice_type_p (const struct type *type) |
c44af4eb | 160 | { |
506ec52e TT |
161 | if (type->code () == TYPE_CODE_STRUCT |
162 | && type->name () != NULL | |
163 | && type->num_fields () == 2) | |
164 | { | |
165 | /* The order of fields doesn't matter. While it would be nice | |
166 | to check for artificiality here, the Rust compiler doesn't | |
167 | emit this information. */ | |
168 | const char *n1 = type->field (0).name (); | |
169 | const char *n2 = type->field (1).name (); | |
170 | return ((streq (n1, "data_ptr") && streq (n2, "length")) | |
171 | || (streq (n2, "data_ptr") && streq (n1, "length"))); | |
172 | } | |
173 | return false; | |
c44af4eb TT |
174 | } |
175 | ||
176 | /* Return true if TYPE is a range type, otherwise false. */ | |
177 | ||
65c40c95 | 178 | static bool |
c44af4eb TT |
179 | rust_range_type_p (struct type *type) |
180 | { | |
181 | int i; | |
182 | ||
78134374 | 183 | if (type->code () != TYPE_CODE_STRUCT |
1f704f76 | 184 | || type->num_fields () > 2 |
7d93a1e0 SM |
185 | || type->name () == NULL |
186 | || strstr (type->name (), "::Range") == NULL) | |
65c40c95 | 187 | return false; |
c44af4eb | 188 | |
1f704f76 | 189 | if (type->num_fields () == 0) |
65c40c95 | 190 | return true; |
c44af4eb TT |
191 | |
192 | i = 0; | |
33d16dd9 | 193 | if (strcmp (type->field (0).name (), "start") == 0) |
c44af4eb | 194 | { |
1f704f76 | 195 | if (type->num_fields () == 1) |
65c40c95 | 196 | return true; |
c44af4eb TT |
197 | i = 1; |
198 | } | |
1f704f76 | 199 | else if (type->num_fields () == 2) |
c44af4eb TT |
200 | { |
201 | /* First field had to be "start". */ | |
65c40c95 | 202 | return false; |
c44af4eb TT |
203 | } |
204 | ||
33d16dd9 | 205 | return strcmp (type->field (i).name (), "end") == 0; |
c44af4eb TT |
206 | } |
207 | ||
6873858b TT |
208 | /* Return true if TYPE is an inclusive range type, otherwise false. |
209 | This is only valid for types which are already known to be range | |
210 | types. */ | |
211 | ||
212 | static bool | |
213 | rust_inclusive_range_type_p (struct type *type) | |
214 | { | |
7d93a1e0 SM |
215 | return (strstr (type->name (), "::RangeInclusive") != NULL |
216 | || strstr (type->name (), "::RangeToInclusive") != NULL); | |
6873858b TT |
217 | } |
218 | ||
c44af4eb TT |
219 | /* Return true if TYPE seems to be the type "u8", otherwise false. */ |
220 | ||
65c40c95 | 221 | static bool |
c44af4eb TT |
222 | rust_u8_type_p (struct type *type) |
223 | { | |
78134374 | 224 | return (type->code () == TYPE_CODE_INT |
c6d940a9 | 225 | && type->is_unsigned () |
df86565b | 226 | && type->length () == 1); |
c44af4eb TT |
227 | } |
228 | ||
229 | /* Return true if TYPE is a Rust character type. */ | |
230 | ||
65c40c95 | 231 | static bool |
c44af4eb TT |
232 | rust_chartype_p (struct type *type) |
233 | { | |
78134374 | 234 | return (type->code () == TYPE_CODE_CHAR |
df86565b | 235 | && type->length () == 4 |
c6d940a9 | 236 | && type->is_unsigned ()); |
c44af4eb TT |
237 | } |
238 | ||
71a3c369 TT |
239 | /* If VALUE represents a trait object pointer, return the underlying |
240 | pointer with the correct (i.e., runtime) type. Otherwise, return | |
241 | NULL. */ | |
242 | ||
243 | static struct value * | |
244 | rust_get_trait_object_pointer (struct value *value) | |
245 | { | |
d0c97917 | 246 | struct type *type = check_typedef (value->type ()); |
71a3c369 | 247 | |
1f704f76 | 248 | if (type->code () != TYPE_CODE_STRUCT || type->num_fields () != 2) |
71a3c369 TT |
249 | return NULL; |
250 | ||
251 | /* Try to be a bit resilient if the ABI changes. */ | |
252 | int vtable_field = 0; | |
253 | for (int i = 0; i < 2; ++i) | |
254 | { | |
33d16dd9 | 255 | if (strcmp (type->field (i).name (), "vtable") == 0) |
71a3c369 | 256 | vtable_field = i; |
33d16dd9 | 257 | else if (strcmp (type->field (i).name (), "pointer") != 0) |
71a3c369 TT |
258 | return NULL; |
259 | } | |
260 | ||
261 | CORE_ADDR vtable = value_as_address (value_field (value, vtable_field)); | |
262 | struct symbol *symbol = find_symbol_at_address (vtable); | |
cf724bc9 | 263 | if (symbol == NULL || symbol->subclass != SYMBOL_RUST_VTABLE) |
71a3c369 TT |
264 | return NULL; |
265 | ||
266 | struct rust_vtable_symbol *vtable_sym | |
267 | = static_cast<struct rust_vtable_symbol *> (symbol); | |
268 | struct type *pointer_type = lookup_pointer_type (vtable_sym->concrete_type); | |
269 | return value_cast (pointer_type, value_field (value, 1 - vtable_field)); | |
270 | } | |
271 | ||
b0dd661f TT |
272 | /* Find and possibly rewrite the unsized part of a slice-like type. |
273 | ||
274 | This function has two modes. If the out parameters are both NULL, | |
275 | it will return true if an unsized member of IN_TYPE is found. | |
276 | ||
277 | If the out parameters are both non-NULL, it will do the same, but | |
278 | will also rewrite the unsized member's type to be an array of the | |
279 | appropriate type. BOUND is the upper bound of the new array. | |
280 | ||
281 | See convert_slice to understand the different kinds of unsized type | |
282 | and how they are represented. | |
283 | */ | |
284 | static bool | |
285 | rewrite_slice_type (struct type *in_type, struct type **new_type, | |
286 | LONGEST bound, ULONGEST *additional_length) | |
287 | { | |
288 | if (in_type->code () != TYPE_CODE_STRUCT) | |
289 | return false; | |
290 | ||
291 | unsigned nfields = in_type->num_fields (); | |
292 | if (nfields == 0) | |
293 | return false; | |
294 | ||
295 | struct type *rewritten; | |
296 | const field &field = in_type->field (nfields - 1); | |
297 | struct type *field_type = field.type (); | |
298 | if (field.loc_kind () == FIELD_LOC_KIND_BITPOS | |
299 | && field.loc_bitpos () == 8 * in_type->length ()) | |
300 | { | |
301 | if (additional_length == nullptr) | |
302 | return true; | |
303 | rewritten = lookup_array_range_type (field_type, 0, bound); | |
304 | *additional_length = rewritten->length (); | |
305 | } | |
306 | else | |
307 | { | |
308 | if (!rewrite_slice_type (field_type, &rewritten, bound, | |
309 | additional_length)) | |
310 | return false; | |
311 | if (additional_length == nullptr) | |
312 | return true; | |
313 | } | |
314 | ||
315 | struct type *result = copy_type (in_type); | |
316 | result->copy_fields (in_type); | |
317 | result->field (nfields - 1).set_type (rewritten); | |
318 | result->set_length (result->length () + *additional_length); | |
319 | ||
320 | *new_type = result; | |
321 | return true; | |
322 | } | |
323 | ||
324 | /* Convert a Rust slice to its "true" representation. | |
325 | ||
326 | The Rust compiler emits slices as "fat" pointers like: | |
327 | ||
328 | struct { payload *data_ptr; usize length } | |
329 | ||
330 | Any sort of unsized type is emitted this way. | |
331 | ||
332 | If 'payload' is a struct type, then it must be searched to see if | |
333 | the trailing field is unsized. This has to be done recursively (as | |
334 | in, if the final field in the struct type itself has struct type, | |
335 | then that type must be searched). In this scenario, the unsized | |
336 | field can be recognized because it does not contribute to the | |
337 | type's size. | |
338 | ||
339 | If 'payload' does not have a trailing unsized type, or if it is not | |
340 | of struct type, then this slice is "array-like". In this case | |
341 | rewriting will return an array. | |
342 | */ | |
343 | static struct value * | |
344 | convert_slice (struct value *val) | |
345 | { | |
346 | struct type *type = check_typedef (val->type ()); | |
347 | /* This must have been checked by the caller. */ | |
348 | gdb_assert (rust_slice_type_p (type)); | |
349 | ||
350 | struct value *len = value_struct_elt (&val, {}, "length", nullptr, | |
351 | "slice"); | |
352 | LONGEST llen = value_as_long (len); | |
353 | ||
354 | struct value *ptr = value_struct_elt (&val, {}, "data_ptr", nullptr, | |
355 | "slice"); | |
356 | struct type *original_type = ptr->type ()->target_type (); | |
357 | ULONGEST new_length_storage = 0; | |
358 | struct type *new_type = nullptr; | |
359 | if (!rewrite_slice_type (original_type, &new_type, llen - 1, | |
360 | &new_length_storage)) | |
361 | new_type = lookup_array_range_type (original_type, 0, llen - 1); | |
362 | ||
363 | struct value *result = value::allocate_lazy (new_type); | |
364 | result->set_lval (lval_memory); | |
365 | result->set_address (value_as_address (ptr)); | |
366 | result->fetch_lazy (); | |
367 | ||
368 | return result; | |
369 | } | |
370 | ||
371 | /* If TYPE is an array-like slice, return the element type; otherwise | |
372 | return NULL. */ | |
373 | static struct type * | |
374 | rust_array_like_element_type (struct type *type) | |
375 | { | |
376 | /* Caller must check this. */ | |
377 | gdb_assert (rust_slice_type_p (type)); | |
378 | for (int i = 0; i < type->num_fields (); ++i) | |
379 | { | |
380 | if (strcmp (type->field (i).name (), "data_ptr") == 0) | |
381 | { | |
382 | struct type *base_type = type->field (i).type ()->target_type (); | |
383 | if (rewrite_slice_type (base_type, nullptr, 0, nullptr)) | |
384 | return nullptr; | |
385 | return base_type; | |
386 | } | |
387 | } | |
388 | return nullptr; | |
389 | } | |
390 | ||
c44af4eb TT |
391 | \f |
392 | ||
1c485265 | 393 | /* See language.h. */ |
c44af4eb | 394 | |
1c485265 AB |
395 | void |
396 | rust_language::printstr (struct ui_file *stream, struct type *type, | |
397 | const gdb_byte *string, unsigned int length, | |
398 | const char *user_encoding, int force_ellipses, | |
399 | const struct value_print_options *options) const | |
c44af4eb TT |
400 | { |
401 | /* Rust always uses UTF-8, but let the caller override this if need | |
402 | be. */ | |
403 | const char *encoding = user_encoding; | |
404 | if (user_encoding == NULL || !*user_encoding) | |
405 | { | |
406 | /* In Rust strings, characters are "u8". */ | |
407 | if (rust_u8_type_p (type)) | |
408 | encoding = "UTF-8"; | |
409 | else | |
410 | { | |
411 | /* This is probably some C string, so let's let C deal with | |
412 | it. */ | |
3a3bb6eb TT |
413 | language_defn::printstr (stream, type, string, length, |
414 | user_encoding, force_ellipses, | |
415 | options); | |
c44af4eb TT |
416 | return; |
417 | } | |
418 | } | |
419 | ||
420 | /* This is not ideal as it doesn't use our character printer. */ | |
421 | generic_printstr (stream, type, string, length, encoding, force_ellipses, | |
422 | '"', 0, options); | |
423 | } | |
424 | ||
425 | \f | |
426 | ||
506ec52e TT |
427 | static const struct generic_val_print_decorations rust_decorations = |
428 | { | |
429 | /* Complex isn't used in Rust, but we provide C-ish values just in | |
430 | case. */ | |
431 | "", | |
432 | " + ", | |
433 | " * I", | |
434 | "true", | |
435 | "false", | |
436 | "()", | |
437 | "[", | |
438 | "]" | |
439 | }; | |
440 | ||
49ed499c TT |
441 | /* See rust-lang.h. */ |
442 | ||
443 | struct value * | |
444 | rust_slice_to_array (struct value *val) | |
445 | { | |
b0dd661f TT |
446 | val = convert_slice (val); |
447 | if (val->type ()->code () != TYPE_CODE_ARRAY) | |
448 | return nullptr; | |
449 | return val; | |
49ed499c TT |
450 | } |
451 | ||
506ec52e | 452 | /* Helper function to print a slice. */ |
45320ffa | 453 | |
b0dd661f TT |
454 | void |
455 | rust_language::val_print_slice | |
456 | (struct value *val, struct ui_file *stream, int recurse, | |
457 | const struct value_print_options *options) const | |
45320ffa | 458 | { |
b0dd661f | 459 | struct type *orig_type = check_typedef (val->type ()); |
45320ffa | 460 | |
b0dd661f | 461 | val = convert_slice (val); |
d0c97917 | 462 | struct type *type = check_typedef (val->type ()); |
506ec52e | 463 | |
b0dd661f TT |
464 | /* &str is handled here; but for all other slice types it is fine to |
465 | simply print the contents. */ | |
466 | if (orig_type->name () != nullptr | |
467 | && strcmp (orig_type->name (), "&str") == 0) | |
468 | { | |
469 | LONGEST low_bound, high_bound; | |
470 | if (get_array_bounds (type, &low_bound, &high_bound)) | |
506ec52e | 471 | { |
b0dd661f TT |
472 | val_print_string (type->target_type (), "UTF-8", |
473 | val->address (), high_bound - low_bound + 1, | |
474 | stream, options); | |
475 | return; | |
506ec52e TT |
476 | } |
477 | } | |
b0dd661f | 478 | |
251cedae TT |
479 | /* Print the slice type here. This was gdb's historical behavior |
480 | (from before unsized types were generically handled) and helps | |
481 | make it clear that the user is seeing a slice, not an array. | |
482 | Only arrays must be handled as the other cases are handled by | |
483 | value_print_inner. */ | |
484 | if (type->code () == TYPE_CODE_ARRAY) | |
485 | { | |
486 | type_print (orig_type, "", stream, -1); | |
487 | gdb_printf (stream, " "); | |
488 | } | |
489 | ||
b0dd661f | 490 | value_print_inner (val, stream, recurse, options); |
45320ffa TT |
491 | } |
492 | ||
1c485265 | 493 | /* See rust-lang.h. */ |
b96645f1 | 494 | |
1c485265 AB |
495 | void |
496 | rust_language::val_print_struct | |
497 | (struct value *val, struct ui_file *stream, int recurse, | |
498 | const struct value_print_options *options) const | |
b96645f1 MG |
499 | { |
500 | int i; | |
501 | int first_field; | |
d0c97917 | 502 | struct type *type = check_typedef (val->type ()); |
45320ffa | 503 | |
506ec52e | 504 | if (rust_slice_type_p (type)) |
45320ffa | 505 | { |
b0dd661f | 506 | val_print_slice (val, stream, recurse, options); |
45320ffa TT |
507 | return; |
508 | } | |
509 | ||
65c40c95 TT |
510 | bool is_tuple = rust_tuple_type_p (type); |
511 | bool is_tuple_struct = !is_tuple && rust_tuple_struct_type_p (type); | |
b96645f1 MG |
512 | struct value_print_options opts; |
513 | ||
514 | if (!is_tuple) | |
515 | { | |
7d93a1e0 | 516 | if (type->name () != NULL) |
6cb06a8c | 517 | gdb_printf (stream, "%s", type->name ()); |
b96645f1 | 518 | |
1f704f76 | 519 | if (type->num_fields () == 0) |
dda83cd7 | 520 | return; |
b96645f1 | 521 | |
7d93a1e0 | 522 | if (type->name () != NULL) |
0426ad51 | 523 | gdb_puts (" ", stream); |
b96645f1 MG |
524 | } |
525 | ||
526 | if (is_tuple || is_tuple_struct) | |
0426ad51 | 527 | gdb_puts ("(", stream); |
b96645f1 | 528 | else |
0426ad51 | 529 | gdb_puts ("{", stream); |
b96645f1 MG |
530 | |
531 | opts = *options; | |
dad6b350 | 532 | opts.deref_ref = false; |
b96645f1 MG |
533 | |
534 | first_field = 1; | |
1f704f76 | 535 | for (i = 0; i < type->num_fields (); ++i) |
b96645f1 | 536 | { |
c819a338 | 537 | if (type->field (i).is_static ()) |
dda83cd7 | 538 | continue; |
b96645f1 MG |
539 | |
540 | if (!first_field) | |
0426ad51 | 541 | gdb_puts (",", stream); |
b96645f1 MG |
542 | |
543 | if (options->prettyformat) | |
dda83cd7 | 544 | { |
0426ad51 | 545 | gdb_puts ("\n", stream); |
d0b1020b | 546 | print_spaces (2 + 2 * recurse, stream); |
dda83cd7 | 547 | } |
b96645f1 | 548 | else if (!first_field) |
0426ad51 | 549 | gdb_puts (" ", stream); |
b96645f1 MG |
550 | |
551 | first_field = 0; | |
552 | ||
553 | if (!is_tuple && !is_tuple_struct) | |
dda83cd7 | 554 | { |
33d16dd9 | 555 | fputs_styled (type->field (i).name (), |
3f0cbb04 | 556 | variable_name_style.style (), stream); |
0426ad51 | 557 | gdb_puts (": ", stream); |
dda83cd7 | 558 | } |
b96645f1 | 559 | |
887e7158 TT |
560 | common_val_print (value_field (val, i), stream, recurse + 1, &opts, |
561 | this); | |
b96645f1 MG |
562 | } |
563 | ||
564 | if (options->prettyformat) | |
565 | { | |
0426ad51 | 566 | gdb_puts ("\n", stream); |
d0b1020b | 567 | print_spaces (2 * recurse, stream); |
b96645f1 MG |
568 | } |
569 | ||
570 | if (is_tuple || is_tuple_struct) | |
0426ad51 | 571 | gdb_puts (")", stream); |
b96645f1 | 572 | else |
0426ad51 | 573 | gdb_puts ("}", stream); |
b96645f1 MG |
574 | } |
575 | ||
1c485265 | 576 | /* See rust-lang.h. */ |
c9317f21 | 577 | |
1c485265 AB |
578 | void |
579 | rust_language::print_enum (struct value *val, struct ui_file *stream, | |
580 | int recurse, | |
581 | const struct value_print_options *options) const | |
c9317f21 TT |
582 | { |
583 | struct value_print_options opts = *options; | |
d0c97917 | 584 | struct type *type = check_typedef (val->type ()); |
c9317f21 | 585 | |
dad6b350 | 586 | opts.deref_ref = false; |
c9317f21 | 587 | |
9c6a1327 | 588 | gdb_assert (rust_enum_p (type)); |
50888e42 | 589 | gdb::array_view<const gdb_byte> view |
efaf1ae0 | 590 | (val->contents_for_printing ().data (), |
d0c97917 | 591 | val->type ()->length ()); |
9feb2d07 | 592 | type = resolve_dynamic_type (type, view, val->address ()); |
9c6a1327 | 593 | |
098b2108 TT |
594 | if (rust_empty_enum_p (type)) |
595 | { | |
596 | /* Print the enum type name here to be more clear. */ | |
6cb06a8c TT |
597 | gdb_printf (stream, _("%s {%p[<No data fields>%p]}"), |
598 | type->name (), | |
599 | metadata_style.style ().ptr (), nullptr); | |
098b2108 TT |
600 | return; |
601 | } | |
602 | ||
9c6a1327 | 603 | int variant_fieldno = rust_enum_variant (type); |
debd0556 | 604 | val = val->primitive_field (0, variant_fieldno, type); |
940da03e | 605 | struct type *variant_type = type->field (variant_fieldno).type (); |
c9317f21 | 606 | |
1f704f76 | 607 | int nfields = variant_type->num_fields (); |
c9317f21 TT |
608 | |
609 | bool is_tuple = rust_tuple_struct_type_p (variant_type); | |
610 | ||
6cb06a8c | 611 | gdb_printf (stream, "%s", variant_type->name ()); |
c9317f21 TT |
612 | if (nfields == 0) |
613 | { | |
614 | /* In case of a nullary variant like 'None', just output | |
615 | the name. */ | |
616 | return; | |
617 | } | |
618 | ||
619 | /* In case of a non-nullary variant, we output 'Foo(x,y,z)'. */ | |
620 | if (is_tuple) | |
6cb06a8c | 621 | gdb_printf (stream, "("); |
c9317f21 TT |
622 | else |
623 | { | |
624 | /* struct variant. */ | |
6cb06a8c | 625 | gdb_printf (stream, "{"); |
c9317f21 TT |
626 | } |
627 | ||
628 | bool first_field = true; | |
8ac460b7 | 629 | for (int j = 0; j < nfields; j++) |
c9317f21 TT |
630 | { |
631 | if (!first_field) | |
0426ad51 | 632 | gdb_puts (", ", stream); |
c9317f21 TT |
633 | first_field = false; |
634 | ||
635 | if (!is_tuple) | |
6cb06a8c TT |
636 | gdb_printf (stream, "%ps: ", |
637 | styled_string (variable_name_style.style (), | |
638 | variant_type->field (j).name ())); | |
c9317f21 | 639 | |
887e7158 TT |
640 | common_val_print (value_field (val, j), stream, recurse + 1, &opts, |
641 | this); | |
c9317f21 TT |
642 | } |
643 | ||
644 | if (is_tuple) | |
0426ad51 | 645 | gdb_puts (")", stream); |
c9317f21 | 646 | else |
0426ad51 | 647 | gdb_puts ("}", stream); |
c9317f21 TT |
648 | } |
649 | ||
1c485265 AB |
650 | /* See language.h. */ |
651 | ||
652 | void | |
653 | rust_language::value_print_inner | |
654 | (struct value *val, struct ui_file *stream, int recurse, | |
655 | const struct value_print_options *options) const | |
5f56f7cb TT |
656 | { |
657 | struct value_print_options opts = *options; | |
dad6b350 | 658 | opts.deref_ref = true; |
5f56f7cb TT |
659 | |
660 | if (opts.prettyformat == Val_prettyformat_default) | |
661 | opts.prettyformat = (opts.prettyformat_structs | |
662 | ? Val_prettyformat : Val_no_prettyformat); | |
663 | ||
d0c97917 | 664 | struct type *type = check_typedef (val->type ()); |
78134374 | 665 | switch (type->code ()) |
c44af4eb TT |
666 | { |
667 | case TYPE_CODE_PTR: | |
668 | { | |
669 | LONGEST low_bound, high_bound; | |
670 | ||
27710edb SM |
671 | if (type->target_type ()->code () == TYPE_CODE_ARRAY |
672 | && rust_u8_type_p (type->target_type ()->target_type ()) | |
673 | && get_array_bounds (type->target_type (), &low_bound, | |
5f56f7cb TT |
674 | &high_bound)) |
675 | { | |
676 | /* We have a pointer to a byte string, so just print | |
677 | that. */ | |
27710edb | 678 | struct type *elttype = check_typedef (type->target_type ()); |
5f56f7cb | 679 | CORE_ADDR addr = value_as_address (val); |
8ee511af | 680 | struct gdbarch *arch = type->arch (); |
c44af4eb | 681 | |
5f56f7cb TT |
682 | if (opts.addressprint) |
683 | { | |
0426ad51 TT |
684 | gdb_puts (paddress (arch, addr), stream); |
685 | gdb_puts (" ", stream); | |
5f56f7cb | 686 | } |
c44af4eb | 687 | |
0426ad51 | 688 | gdb_puts ("b", stream); |
27710edb | 689 | val_print_string (elttype->target_type (), "ASCII", addr, |
5f56f7cb TT |
690 | high_bound - low_bound + 1, stream, |
691 | &opts); | |
692 | break; | |
693 | } | |
c44af4eb | 694 | } |
5f56f7cb | 695 | goto generic_print; |
c44af4eb | 696 | |
c44af4eb TT |
697 | case TYPE_CODE_INT: |
698 | /* Recognize the unit type. */ | |
df86565b | 699 | if (type->is_unsigned () && type->length () == 0 |
7d93a1e0 | 700 | && type->name () != NULL && strcmp (type->name (), "()") == 0) |
c44af4eb | 701 | { |
0426ad51 | 702 | gdb_puts ("()", stream); |
c44af4eb TT |
703 | break; |
704 | } | |
705 | goto generic_print; | |
706 | ||
707 | case TYPE_CODE_STRING: | |
708 | { | |
c44af4eb TT |
709 | LONGEST low_bound, high_bound; |
710 | ||
711 | if (!get_array_bounds (type, &low_bound, &high_bound)) | |
712 | error (_("Could not determine the array bounds")); | |
713 | ||
714 | /* If we see a plain TYPE_CODE_STRING, then we're printing a | |
715 | byte string, hence the choice of "ASCII" as the | |
716 | encoding. */ | |
0426ad51 | 717 | gdb_puts ("b", stream); |
27710edb | 718 | printstr (stream, type->target_type (), |
efaf1ae0 | 719 | val->contents_for_printing ().data (), |
1c485265 | 720 | high_bound - low_bound + 1, "ASCII", 0, &opts); |
c44af4eb TT |
721 | } |
722 | break; | |
723 | ||
724 | case TYPE_CODE_ARRAY: | |
725 | { | |
726 | LONGEST low_bound, high_bound; | |
727 | ||
728 | if (get_array_bounds (type, &low_bound, &high_bound) | |
729 | && high_bound - low_bound + 1 == 0) | |
0426ad51 | 730 | gdb_puts ("[]", stream); |
c44af4eb TT |
731 | else |
732 | goto generic_print; | |
733 | } | |
734 | break; | |
735 | ||
736 | case TYPE_CODE_UNION: | |
c9317f21 TT |
737 | /* Untagged unions are printed as if they are structs. Since |
738 | the field bit positions overlap in the debuginfo, the code | |
739 | for printing a union is same as that for a struct, the only | |
740 | difference is that the input type will have overlapping | |
741 | fields. */ | |
5f56f7cb | 742 | val_print_struct (val, stream, recurse, &opts); |
c44af4eb TT |
743 | break; |
744 | ||
745 | case TYPE_CODE_STRUCT: | |
c9317f21 | 746 | if (rust_enum_p (type)) |
1c485265 | 747 | print_enum (val, stream, recurse, &opts); |
c9317f21 | 748 | else |
5f56f7cb | 749 | val_print_struct (val, stream, recurse, &opts); |
b96645f1 | 750 | break; |
c44af4eb | 751 | |
b96645f1 MG |
752 | default: |
753 | generic_print: | |
754 | /* Nothing special yet. */ | |
5f56f7cb | 755 | generic_value_print (val, stream, recurse, &opts, &rust_decorations); |
b96645f1 MG |
756 | } |
757 | } | |
c44af4eb | 758 | |
1c9cc052 TT |
759 | /* See language.h. */ |
760 | ||
761 | void | |
762 | rust_language::value_print | |
763 | (struct value *val, struct ui_file *stream, | |
764 | const struct value_print_options *options) const | |
765 | { | |
766 | value_print_options opts = *options; | |
767 | opts.deref_ref = true; | |
768 | ||
d0c97917 | 769 | struct type *type = check_typedef (val->type ()); |
1c9cc052 TT |
770 | if (type->is_pointer_or_reference ()) |
771 | { | |
772 | gdb_printf (stream, "("); | |
d0c97917 | 773 | type_print (val->type (), "", stream, -1); |
1c9cc052 TT |
774 | gdb_printf (stream, ") "); |
775 | } | |
776 | ||
777 | return common_val_print (val, stream, 0, &opts, this); | |
778 | } | |
779 | ||
b96645f1 | 780 | \f |
c44af4eb | 781 | |
b96645f1 | 782 | static void |
c9317f21 TT |
783 | rust_internal_print_type (struct type *type, const char *varstring, |
784 | struct ui_file *stream, int show, int level, | |
785 | const struct type_print_options *flags, | |
a33ccfc7 | 786 | bool for_rust_enum, print_offset_data *podata); |
b96645f1 MG |
787 | |
788 | /* Print a struct or union typedef. */ | |
789 | static void | |
790 | rust_print_struct_def (struct type *type, const char *varstring, | |
b50f188d | 791 | struct ui_file *stream, int show, int level, |
c9317f21 | 792 | const struct type_print_options *flags, |
a33ccfc7 | 793 | bool for_rust_enum, print_offset_data *podata) |
b96645f1 | 794 | { |
b50f188d TT |
795 | /* Print a tuple type simply. */ |
796 | if (rust_tuple_type_p (type)) | |
797 | { | |
0426ad51 | 798 | gdb_puts (type->name (), stream); |
b50f188d TT |
799 | return; |
800 | } | |
c44af4eb | 801 | |
b50f188d TT |
802 | /* If we see a base class, delegate to C. */ |
803 | if (TYPE_N_BASECLASSES (type) > 0) | |
1c6fbf42 | 804 | c_print_type (type, varstring, stream, show, level, language_rust, flags); |
c44af4eb | 805 | |
a33ccfc7 TT |
806 | if (flags->print_offsets) |
807 | { | |
808 | /* Temporarily bump the level so that the output lines up | |
809 | correctly. */ | |
810 | level += 2; | |
811 | } | |
812 | ||
c9317f21 TT |
813 | /* Compute properties of TYPE here because, in the enum case, the |
814 | rest of the code ends up looking only at the variant part. */ | |
7d93a1e0 | 815 | const char *tagname = type->name (); |
c9317f21 TT |
816 | bool is_tuple_struct = rust_tuple_struct_type_p (type); |
817 | bool is_tuple = rust_tuple_type_p (type); | |
818 | bool is_enum = rust_enum_p (type); | |
b96645f1 | 819 | |
c9317f21 TT |
820 | if (for_rust_enum) |
821 | { | |
822 | /* Already printing an outer enum, so nothing to print here. */ | |
823 | } | |
824 | else | |
825 | { | |
826 | /* This code path is also used by unions and enums. */ | |
827 | if (is_enum) | |
828 | { | |
0426ad51 | 829 | gdb_puts ("enum ", stream); |
24e99c6c | 830 | dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS); |
8c2e4e06 SM |
831 | if (prop != nullptr && prop->kind () == PROP_TYPE) |
832 | type = prop->original_type (); | |
c9317f21 | 833 | } |
78134374 | 834 | else if (type->code () == TYPE_CODE_STRUCT) |
0426ad51 | 835 | gdb_puts ("struct ", stream); |
c9317f21 | 836 | else |
0426ad51 | 837 | gdb_puts ("union ", stream); |
b96645f1 | 838 | |
c9317f21 | 839 | if (tagname != NULL) |
0426ad51 | 840 | gdb_puts (tagname, stream); |
c9317f21 | 841 | } |
b96645f1 | 842 | |
1f704f76 | 843 | if (type->num_fields () == 0 && !is_tuple) |
b50f188d | 844 | return; |
a33ccfc7 | 845 | if (for_rust_enum && !flags->print_offsets) |
0426ad51 | 846 | gdb_puts (is_tuple_struct ? "(" : "{", stream); |
c9317f21 | 847 | else |
0426ad51 | 848 | gdb_puts (is_tuple_struct ? " (\n" : " {\n", stream); |
c44af4eb | 849 | |
a33ccfc7 TT |
850 | /* When printing offsets, we rearrange the fields into storage |
851 | order. This lets us show holes more clearly. We work using | |
852 | field indices here because it simplifies calls to | |
853 | print_offset_data::update below. */ | |
854 | std::vector<int> fields; | |
1f704f76 | 855 | for (int i = 0; i < type->num_fields (); ++i) |
b50f188d | 856 | { |
c819a338 | 857 | if (type->field (i).is_static ()) |
b50f188d | 858 | continue; |
454977cd | 859 | if (is_enum && type->field (i).is_artificial ()) |
a33ccfc7 TT |
860 | continue; |
861 | fields.push_back (i); | |
862 | } | |
863 | if (flags->print_offsets) | |
864 | std::sort (fields.begin (), fields.end (), | |
865 | [&] (int a, int b) | |
866 | { | |
b610c045 SM |
867 | return (type->field (a).loc_bitpos () |
868 | < type->field (b).loc_bitpos ()); | |
a33ccfc7 TT |
869 | }); |
870 | ||
871 | for (int i : fields) | |
872 | { | |
873 | QUIT; | |
874 | ||
c819a338 | 875 | gdb_assert (!type->field (i).is_static ()); |
454977cd | 876 | gdb_assert (! (is_enum && type->field (i).is_artificial ())); |
a33ccfc7 TT |
877 | |
878 | if (flags->print_offsets) | |
879 | podata->update (type, i, stream); | |
b50f188d TT |
880 | |
881 | /* We'd like to print "pub" here as needed, but rustc | |
882 | doesn't emit the debuginfo, and our types don't have | |
883 | cplus_struct_type attached. */ | |
884 | ||
885 | /* For a tuple struct we print the type but nothing | |
886 | else. */ | |
a33ccfc7 | 887 | if (!for_rust_enum || flags->print_offsets) |
d0b1020b | 888 | print_spaces (level + 2, stream); |
c9317f21 | 889 | if (is_enum) |
33d16dd9 | 890 | fputs_styled (type->field (i).name (), variable_name_style.style (), |
3f0cbb04 | 891 | stream); |
c9317f21 | 892 | else if (!is_tuple_struct) |
6cb06a8c TT |
893 | gdb_printf (stream, "%ps: ", |
894 | styled_string (variable_name_style.style (), | |
895 | type->field (i).name ())); | |
b50f188d | 896 | |
940da03e | 897 | rust_internal_print_type (type->field (i).type (), NULL, |
53d7df28 | 898 | stream, (is_enum ? show : show - 1), |
a33ccfc7 TT |
899 | level + 2, flags, is_enum, podata); |
900 | if (!for_rust_enum || flags->print_offsets) | |
0426ad51 | 901 | gdb_puts (",\n", stream); |
a33ccfc7 TT |
902 | /* Note that this check of "I" is ok because we only sorted the |
903 | fields by offset when print_offsets was set, so we won't take | |
904 | this branch in that case. */ | |
1f704f76 | 905 | else if (i + 1 < type->num_fields ()) |
0426ad51 | 906 | gdb_puts (", ", stream); |
b50f188d | 907 | } |
c44af4eb | 908 | |
a33ccfc7 TT |
909 | if (flags->print_offsets) |
910 | { | |
911 | /* Undo the temporary level increase we did above. */ | |
912 | level -= 2; | |
913 | podata->finish (type, level, stream); | |
d0b1020b | 914 | print_spaces (print_offset_data::indentation, stream); |
a33ccfc7 | 915 | if (level == 0) |
d0b1020b | 916 | print_spaces (2, stream); |
a33ccfc7 TT |
917 | } |
918 | if (!for_rust_enum || flags->print_offsets) | |
d0b1020b | 919 | print_spaces (level, stream); |
0426ad51 | 920 | gdb_puts (is_tuple_struct ? ")" : "}", stream); |
c44af4eb TT |
921 | } |
922 | ||
c44af4eb TT |
923 | /* la_print_type implementation for Rust. */ |
924 | ||
925 | static void | |
c9317f21 TT |
926 | rust_internal_print_type (struct type *type, const char *varstring, |
927 | struct ui_file *stream, int show, int level, | |
928 | const struct type_print_options *flags, | |
a33ccfc7 | 929 | bool for_rust_enum, print_offset_data *podata) |
c44af4eb | 930 | { |
c44af4eb TT |
931 | QUIT; |
932 | if (show <= 0 | |
7d93a1e0 | 933 | && type->name () != NULL) |
c44af4eb | 934 | { |
921d8f54 | 935 | /* Rust calls the unit type "void" in its debuginfo, |
dda83cd7 | 936 | but we don't want to print it as that. */ |
78134374 | 937 | if (type->code () == TYPE_CODE_VOID) |
0426ad51 | 938 | gdb_puts ("()", stream); |
921d8f54 | 939 | else |
0426ad51 | 940 | gdb_puts (type->name (), stream); |
c44af4eb TT |
941 | return; |
942 | } | |
943 | ||
944 | type = check_typedef (type); | |
78134374 | 945 | switch (type->code ()) |
c44af4eb | 946 | { |
921d8f54 | 947 | case TYPE_CODE_VOID: |
c9317f21 TT |
948 | /* If we have an enum, we've already printed the type's |
949 | unqualified name, and there is nothing else to print | |
950 | here. */ | |
951 | if (!for_rust_enum) | |
0426ad51 | 952 | gdb_puts ("()", stream); |
921d8f54 MG |
953 | break; |
954 | ||
c44af4eb TT |
955 | case TYPE_CODE_FUNC: |
956 | /* Delegate varargs to the C printer. */ | |
a409645d | 957 | if (type->has_varargs ()) |
c44af4eb TT |
958 | goto c_printer; |
959 | ||
0426ad51 | 960 | gdb_puts ("fn ", stream); |
c44af4eb | 961 | if (varstring != NULL) |
0426ad51 TT |
962 | gdb_puts (varstring, stream); |
963 | gdb_puts ("(", stream); | |
1f704f76 | 964 | for (int i = 0; i < type->num_fields (); ++i) |
c44af4eb TT |
965 | { |
966 | QUIT; | |
967 | if (i > 0) | |
0426ad51 | 968 | gdb_puts (", ", stream); |
940da03e | 969 | rust_internal_print_type (type->field (i).type (), "", stream, |
a33ccfc7 | 970 | -1, 0, flags, false, podata); |
c44af4eb | 971 | } |
0426ad51 | 972 | gdb_puts (")", stream); |
921d8f54 | 973 | /* If it returns unit, we can omit the return type. */ |
27710edb | 974 | if (type->target_type ()->code () != TYPE_CODE_VOID) |
dda83cd7 | 975 | { |
0426ad51 | 976 | gdb_puts (" -> ", stream); |
27710edb | 977 | rust_internal_print_type (type->target_type (), "", stream, |
a33ccfc7 | 978 | -1, 0, flags, false, podata); |
dda83cd7 | 979 | } |
c44af4eb TT |
980 | break; |
981 | ||
982 | case TYPE_CODE_ARRAY: | |
983 | { | |
984 | LONGEST low_bound, high_bound; | |
985 | ||
0426ad51 | 986 | gdb_puts ("[", stream); |
27710edb | 987 | rust_internal_print_type (type->target_type (), NULL, |
a33ccfc7 TT |
988 | stream, show - 1, level, flags, false, |
989 | podata); | |
c44af4eb | 990 | |
cf88be68 SM |
991 | if (type->bounds ()->high.kind () == PROP_LOCEXPR |
992 | || type->bounds ()->high.kind () == PROP_LOCLIST) | |
6cb06a8c | 993 | gdb_printf (stream, "; variable length"); |
c44af4eb | 994 | else if (get_array_bounds (type, &low_bound, &high_bound)) |
6cb06a8c TT |
995 | gdb_printf (stream, "; %s", |
996 | plongest (high_bound - low_bound + 1)); | |
0426ad51 | 997 | gdb_puts ("]", stream); |
c44af4eb TT |
998 | } |
999 | break; | |
1000 | ||
c9317f21 | 1001 | case TYPE_CODE_UNION: |
c44af4eb | 1002 | case TYPE_CODE_STRUCT: |
c9317f21 | 1003 | rust_print_struct_def (type, varstring, stream, show, level, flags, |
a33ccfc7 | 1004 | for_rust_enum, podata); |
c44af4eb TT |
1005 | break; |
1006 | ||
1007 | case TYPE_CODE_ENUM: | |
1008 | { | |
b926417a | 1009 | int len = 0; |
c44af4eb | 1010 | |
0426ad51 | 1011 | gdb_puts ("enum ", stream); |
7d93a1e0 | 1012 | if (type->name () != NULL) |
c44af4eb | 1013 | { |
0426ad51 TT |
1014 | gdb_puts (type->name (), stream); |
1015 | gdb_puts (" ", stream); | |
7d93a1e0 | 1016 | len = strlen (type->name ()); |
c44af4eb | 1017 | } |
0426ad51 | 1018 | gdb_puts ("{\n", stream); |
c44af4eb | 1019 | |
1f704f76 | 1020 | for (int i = 0; i < type->num_fields (); ++i) |
c44af4eb | 1021 | { |
33d16dd9 | 1022 | const char *name = type->field (i).name (); |
c44af4eb TT |
1023 | |
1024 | QUIT; | |
1025 | ||
1026 | if (len > 0 | |
7d93a1e0 | 1027 | && strncmp (name, type->name (), len) == 0 |
c44af4eb TT |
1028 | && name[len] == ':' |
1029 | && name[len + 1] == ':') | |
1030 | name += len + 2; | |
6cb06a8c TT |
1031 | gdb_printf (stream, "%*s%ps,\n", |
1032 | level + 2, "", | |
1033 | styled_string (variable_name_style.style (), | |
1034 | name)); | |
c44af4eb TT |
1035 | } |
1036 | ||
0426ad51 | 1037 | gdb_puts ("}", stream); |
c44af4eb | 1038 | } |
73fc52c4 TT |
1039 | break; |
1040 | ||
1041 | case TYPE_CODE_PTR: | |
1042 | { | |
7d93a1e0 | 1043 | if (type->name () != nullptr) |
0426ad51 | 1044 | gdb_puts (type->name (), stream); |
73fc52c4 TT |
1045 | else |
1046 | { | |
1047 | /* We currently can't distinguish between pointers and | |
1048 | references. */ | |
0426ad51 | 1049 | gdb_puts ("*mut ", stream); |
27710edb | 1050 | type_print (type->target_type (), "", stream, 0); |
73fc52c4 TT |
1051 | } |
1052 | } | |
c44af4eb TT |
1053 | break; |
1054 | ||
c44af4eb TT |
1055 | default: |
1056 | c_printer: | |
1c6fbf42 PA |
1057 | c_print_type (type, varstring, stream, show, level, language_rust, |
1058 | flags); | |
c44af4eb TT |
1059 | } |
1060 | } | |
1061 | ||
1062 | \f | |
1063 | ||
c44af4eb TT |
1064 | /* Like arch_composite_type, but uses TYPE to decide how to allocate |
1065 | -- either on an obstack or on a gdbarch. */ | |
1066 | ||
1067 | static struct type * | |
1068 | rust_composite_type (struct type *original, | |
1069 | const char *name, | |
1070 | const char *field1, struct type *type1, | |
1071 | const char *field2, struct type *type2) | |
1072 | { | |
9fa83a7a | 1073 | struct type *result = type_allocator (original).new_type (); |
c44af4eb TT |
1074 | int i, nfields, bitpos; |
1075 | ||
1076 | nfields = 0; | |
1077 | if (field1 != NULL) | |
1078 | ++nfields; | |
1079 | if (field2 != NULL) | |
1080 | ++nfields; | |
1081 | ||
67607e24 | 1082 | result->set_code (TYPE_CODE_STRUCT); |
d0e39ea2 | 1083 | result->set_name (name); |
c44af4eb | 1084 | |
2774f2da | 1085 | result->alloc_fields (nfields); |
c44af4eb TT |
1086 | |
1087 | i = 0; | |
1088 | bitpos = 0; | |
1089 | if (field1 != NULL) | |
1090 | { | |
ceacbf6e | 1091 | struct field *field = &result->field (i); |
c44af4eb | 1092 | |
cd3f655c | 1093 | field->set_loc_bitpos (bitpos); |
df86565b | 1094 | bitpos += type1->length () * TARGET_CHAR_BIT; |
c44af4eb | 1095 | |
d3fd12df | 1096 | field->set_name (field1); |
5d14b6e5 | 1097 | field->set_type (type1); |
c44af4eb TT |
1098 | ++i; |
1099 | } | |
1100 | if (field2 != NULL) | |
1101 | { | |
ceacbf6e | 1102 | struct field *field = &result->field (i); |
2fff16dd | 1103 | unsigned align = type_align (type2); |
c44af4eb TT |
1104 | |
1105 | if (align != 0) | |
1106 | { | |
1107 | int delta; | |
1108 | ||
1109 | align *= TARGET_CHAR_BIT; | |
1110 | delta = bitpos % align; | |
1111 | if (delta != 0) | |
1112 | bitpos += align - delta; | |
1113 | } | |
cd3f655c | 1114 | field->set_loc_bitpos (bitpos); |
c44af4eb | 1115 | |
d3fd12df | 1116 | field->set_name (field2); |
5d14b6e5 | 1117 | field->set_type (type2); |
c44af4eb TT |
1118 | ++i; |
1119 | } | |
1120 | ||
1121 | if (i > 0) | |
b6cdbc9a | 1122 | result->set_length (result->field (i - 1).loc_bitpos () / TARGET_CHAR_BIT |
df86565b | 1123 | + result->field (i - 1).type ()->length ()); |
c44af4eb TT |
1124 | return result; |
1125 | } | |
1126 | ||
1127 | /* See rust-lang.h. */ | |
1128 | ||
1129 | struct type * | |
1130 | rust_slice_type (const char *name, struct type *elt_type, | |
1131 | struct type *usize_type) | |
1132 | { | |
1133 | struct type *type; | |
1134 | ||
1135 | elt_type = lookup_pointer_type (elt_type); | |
1136 | type = rust_composite_type (elt_type, name, | |
1137 | "data_ptr", elt_type, | |
1138 | "length", usize_type); | |
1139 | ||
1140 | return type; | |
1141 | } | |
1142 | ||
c44af4eb TT |
1143 | \f |
1144 | ||
01739a3b | 1145 | /* A helper for rust_evaluate_subexp that handles OP_RANGE. */ |
c44af4eb | 1146 | |
9db6b6dd | 1147 | struct value * |
d148f803 TT |
1148 | rust_range (struct type *expect_type, struct expression *exp, |
1149 | enum noside noside, enum range_flag kind, | |
1150 | struct value *low, struct value *high) | |
c44af4eb | 1151 | { |
c44af4eb TT |
1152 | struct value *addrval, *result; |
1153 | CORE_ADDR addr; | |
1154 | struct type *range_type; | |
1155 | struct type *index_type; | |
1156 | struct type *temp_type; | |
1157 | const char *name; | |
1158 | ||
2f1b18db | 1159 | bool inclusive = !(kind & RANGE_HIGH_BOUND_EXCLUSIVE); |
c44af4eb | 1160 | |
c44af4eb TT |
1161 | if (low == NULL) |
1162 | { | |
1163 | if (high == NULL) | |
1164 | { | |
1165 | index_type = NULL; | |
1166 | name = "std::ops::RangeFull"; | |
1167 | } | |
1168 | else | |
1169 | { | |
d0c97917 | 1170 | index_type = high->type (); |
6873858b TT |
1171 | name = (inclusive |
1172 | ? "std::ops::RangeToInclusive" : "std::ops::RangeTo"); | |
c44af4eb TT |
1173 | } |
1174 | } | |
1175 | else | |
1176 | { | |
1177 | if (high == NULL) | |
1178 | { | |
d0c97917 | 1179 | index_type = low->type (); |
c44af4eb TT |
1180 | name = "std::ops::RangeFrom"; |
1181 | } | |
1182 | else | |
1183 | { | |
d0c97917 | 1184 | if (!types_equal (low->type (), high->type ())) |
c44af4eb | 1185 | error (_("Range expression with different types")); |
d0c97917 | 1186 | index_type = low->type (); |
6873858b | 1187 | name = inclusive ? "std::ops::RangeInclusive" : "std::ops::Range"; |
c44af4eb TT |
1188 | } |
1189 | } | |
1190 | ||
1191 | /* If we don't have an index type, just allocate this on the | |
1192 | arch. Here any type will do. */ | |
1193 | temp_type = (index_type == NULL | |
1194 | ? language_bool_type (exp->language_defn, exp->gdbarch) | |
1195 | : index_type); | |
1196 | /* It would be nicer to cache the range type. */ | |
1197 | range_type = rust_composite_type (temp_type, name, | |
1198 | low == NULL ? NULL : "start", index_type, | |
1199 | high == NULL ? NULL : "end", index_type); | |
1200 | ||
1201 | if (noside == EVAL_AVOID_SIDE_EFFECTS) | |
ee7bb294 | 1202 | return value::zero (range_type, lval_memory); |
c44af4eb | 1203 | |
df86565b | 1204 | addrval = value_allocate_space_in_inferior (range_type->length ()); |
c44af4eb TT |
1205 | addr = value_as_long (addrval); |
1206 | result = value_at_lazy (range_type, addr); | |
1207 | ||
1208 | if (low != NULL) | |
1209 | { | |
158cc4fe | 1210 | struct value *start = value_struct_elt (&result, {}, "start", NULL, |
c44af4eb TT |
1211 | "range"); |
1212 | ||
1213 | value_assign (start, low); | |
1214 | } | |
1215 | ||
1216 | if (high != NULL) | |
1217 | { | |
158cc4fe | 1218 | struct value *end = value_struct_elt (&result, {}, "end", NULL, |
c44af4eb TT |
1219 | "range"); |
1220 | ||
1221 | value_assign (end, high); | |
1222 | } | |
1223 | ||
1224 | result = value_at_lazy (range_type, addr); | |
1225 | return result; | |
1226 | } | |
1227 | ||
1228 | /* A helper function to compute the range and kind given a range | |
1229 | value. TYPE is the type of the range value. RANGE is the range | |
1230 | value. LOW, HIGH, and KIND are out parameters. The LOW and HIGH | |
1231 | parameters might be filled in, or might not be, depending on the | |
1232 | kind of range this is. KIND will always be set to the appropriate | |
1233 | value describing the kind of range, and this can be used to | |
1234 | determine whether LOW or HIGH are valid. */ | |
1235 | ||
1236 | static void | |
1237 | rust_compute_range (struct type *type, struct value *range, | |
1238 | LONGEST *low, LONGEST *high, | |
f2d8e4c5 | 1239 | range_flags *kind) |
c44af4eb TT |
1240 | { |
1241 | int i; | |
1242 | ||
1243 | *low = 0; | |
1244 | *high = 0; | |
2f1b18db | 1245 | *kind = RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT; |
c44af4eb | 1246 | |
1f704f76 | 1247 | if (type->num_fields () == 0) |
c44af4eb TT |
1248 | return; |
1249 | ||
1250 | i = 0; | |
33d16dd9 | 1251 | if (strcmp (type->field (0).name (), "start") == 0) |
c44af4eb | 1252 | { |
2f1b18db | 1253 | *kind = RANGE_HIGH_BOUND_DEFAULT; |
c44af4eb TT |
1254 | *low = value_as_long (value_field (range, 0)); |
1255 | ++i; | |
1256 | } | |
1f704f76 | 1257 | if (type->num_fields () > i |
33d16dd9 | 1258 | && strcmp (type->field (i).name (), "end") == 0) |
c44af4eb | 1259 | { |
2f1b18db AB |
1260 | *kind = (*kind == (RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT) |
1261 | ? RANGE_LOW_BOUND_DEFAULT : RANGE_STANDARD); | |
c44af4eb | 1262 | *high = value_as_long (value_field (range, i)); |
6873858b TT |
1263 | |
1264 | if (rust_inclusive_range_type_p (type)) | |
1265 | ++*high; | |
c44af4eb TT |
1266 | } |
1267 | } | |
1268 | ||
1269 | /* A helper for rust_evaluate_subexp that handles BINOP_SUBSCRIPT. */ | |
1270 | ||
6ce1ad67 | 1271 | struct value * |
984af2cb TT |
1272 | rust_subscript (struct type *expect_type, struct expression *exp, |
1273 | enum noside noside, bool for_addr, | |
1274 | struct value *lhs, struct value *rhs) | |
c44af4eb | 1275 | { |
984af2cb | 1276 | struct value *result; |
c44af4eb | 1277 | struct type *rhstype; |
45f4ed92 | 1278 | LONGEST low, high_bound; |
c44af4eb | 1279 | /* Initialized to appease the compiler. */ |
f2d8e4c5 | 1280 | range_flags kind = RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT; |
45f4ed92 | 1281 | LONGEST high = 0; |
c44af4eb TT |
1282 | int want_slice = 0; |
1283 | ||
d0c97917 | 1284 | rhstype = check_typedef (rhs->type ()); |
c44af4eb TT |
1285 | if (rust_range_type_p (rhstype)) |
1286 | { | |
1287 | if (!for_addr) | |
1288 | error (_("Can't take slice of array without '&'")); | |
1289 | rust_compute_range (rhstype, rhs, &low, &high, &kind); | |
1290 | want_slice = 1; | |
1291 | } | |
1292 | else | |
1293 | low = value_as_long (rhs); | |
1294 | ||
d0c97917 | 1295 | struct type *type = check_typedef (lhs->type ()); |
b0dd661f | 1296 | struct type *orig_type = type; |
c44af4eb TT |
1297 | if (noside == EVAL_AVOID_SIDE_EFFECTS) |
1298 | { | |
b3e3859b | 1299 | struct type *base_type = nullptr; |
78134374 | 1300 | if (type->code () == TYPE_CODE_ARRAY) |
27710edb | 1301 | base_type = type->target_type (); |
b3e3859b TT |
1302 | else if (rust_slice_type_p (type)) |
1303 | { | |
b0dd661f | 1304 | base_type = rust_array_like_element_type (type); |
b3e3859b | 1305 | if (base_type == nullptr) |
b0dd661f | 1306 | error (_("Cannot subscript non-array-like slice")); |
b3e3859b | 1307 | } |
78134374 | 1308 | else if (type->code () == TYPE_CODE_PTR) |
27710edb | 1309 | base_type = type->target_type (); |
b3e3859b TT |
1310 | else |
1311 | error (_("Cannot subscript non-array type")); | |
1312 | ||
1313 | struct type *new_type; | |
1314 | if (want_slice) | |
1315 | { | |
1316 | if (rust_slice_type_p (type)) | |
1317 | new_type = type; | |
1318 | else | |
1319 | { | |
1320 | struct type *usize | |
1321 | = language_lookup_primitive_type (exp->language_defn, | |
1322 | exp->gdbarch, | |
1323 | "usize"); | |
1324 | new_type = rust_slice_type ("&[*gdb*]", base_type, usize); | |
1325 | } | |
1326 | } | |
1327 | else | |
1328 | new_type = base_type; | |
c44af4eb | 1329 | |
736355f2 | 1330 | return value::zero (new_type, lhs->lval ()); |
c44af4eb TT |
1331 | } |
1332 | else | |
1333 | { | |
1334 | LONGEST low_bound; | |
1335 | struct value *base; | |
c44af4eb | 1336 | |
b0dd661f TT |
1337 | if (rust_slice_type_p (type)) |
1338 | { | |
1339 | lhs = convert_slice (lhs); | |
1340 | type = check_typedef (lhs->type ()); | |
1341 | } | |
1342 | ||
78134374 | 1343 | if (type->code () == TYPE_CODE_ARRAY) |
c44af4eb TT |
1344 | { |
1345 | base = lhs; | |
1346 | if (!get_array_bounds (type, &low_bound, &high_bound)) | |
1347 | error (_("Can't compute array bounds")); | |
1348 | if (low_bound != 0) | |
1349 | error (_("Found array with non-zero lower bound")); | |
1350 | ++high_bound; | |
1351 | } | |
78134374 | 1352 | else if (type->code () == TYPE_CODE_PTR) |
42d94011 MG |
1353 | { |
1354 | base = lhs; | |
1355 | low_bound = 0; | |
1356 | high_bound = LONGEST_MAX; | |
1357 | } | |
c44af4eb TT |
1358 | else |
1359 | error (_("Cannot subscript non-array type")); | |
1360 | ||
2f1b18db | 1361 | if (want_slice && (kind & RANGE_LOW_BOUND_DEFAULT)) |
c44af4eb TT |
1362 | low = low_bound; |
1363 | if (low < 0) | |
1364 | error (_("Index less than zero")); | |
1365 | if (low > high_bound) | |
1366 | error (_("Index greater than length")); | |
1367 | ||
1368 | result = value_subscript (base, low); | |
1369 | } | |
1370 | ||
1371 | if (for_addr) | |
1372 | { | |
1373 | if (want_slice) | |
1374 | { | |
1375 | struct type *usize, *slice; | |
1376 | CORE_ADDR addr; | |
1377 | struct value *addrval, *tem; | |
1378 | ||
2f1b18db | 1379 | if (kind & RANGE_HIGH_BOUND_DEFAULT) |
c44af4eb TT |
1380 | high = high_bound; |
1381 | if (high < 0) | |
1382 | error (_("High index less than zero")); | |
1383 | if (low > high) | |
1384 | error (_("Low index greater than high index")); | |
1385 | if (high > high_bound) | |
1386 | error (_("High index greater than length")); | |
1387 | ||
1388 | usize = language_lookup_primitive_type (exp->language_defn, | |
1389 | exp->gdbarch, | |
1390 | "usize"); | |
b0dd661f TT |
1391 | /* Preserve the name for slice-of-slice; this lets |
1392 | string-printing work a bit more nicely. */ | |
1393 | const char *new_name = ((orig_type != nullptr | |
1394 | && rust_slice_type_p (orig_type)) | |
1395 | ? orig_type->name () : "&[*gdb*]"); | |
45320ffa | 1396 | |
d0c97917 | 1397 | slice = rust_slice_type (new_name, result->type (), usize); |
c44af4eb | 1398 | |
df86565b | 1399 | addrval = value_allocate_space_in_inferior (slice->length ()); |
c44af4eb TT |
1400 | addr = value_as_long (addrval); |
1401 | tem = value_at_lazy (slice, addr); | |
1402 | ||
1403 | value_assign (value_field (tem, 0), value_addr (result)); | |
1404 | value_assign (value_field (tem, 1), | |
1405 | value_from_longest (usize, high - low)); | |
1406 | ||
1407 | result = value_at_lazy (slice, addr); | |
1408 | } | |
1409 | else | |
1410 | result = value_addr (result); | |
1411 | } | |
1412 | ||
1413 | return result; | |
1414 | } | |
1415 | ||
f10522c0 TT |
1416 | namespace expr |
1417 | { | |
d123f9e4 | 1418 | |
11dd3dce | 1419 | struct value * |
f10522c0 TT |
1420 | rust_unop_ind_operation::evaluate (struct type *expect_type, |
1421 | struct expression *exp, | |
1422 | enum noside noside) | |
d123f9e4 | 1423 | { |
f10522c0 TT |
1424 | if (noside != EVAL_NORMAL) |
1425 | return unop_ind_operation::evaluate (expect_type, exp, noside); | |
1426 | ||
1427 | struct value *value = std::get<0> (m_storage)->evaluate (nullptr, exp, | |
1428 | noside); | |
d123f9e4 TT |
1429 | struct value *trait_ptr = rust_get_trait_object_pointer (value); |
1430 | if (trait_ptr != NULL) | |
1431 | value = trait_ptr; | |
1432 | ||
1433 | return value_ind (value); | |
1434 | } | |
1435 | ||
f10522c0 TT |
1436 | } /* namespace expr */ |
1437 | ||
6fa9831f TT |
1438 | /* A helper function for UNOP_COMPLEMENT. */ |
1439 | ||
6fab4359 | 1440 | struct value * |
6fa9831f TT |
1441 | eval_op_rust_complement (struct type *expect_type, struct expression *exp, |
1442 | enum noside noside, | |
6fab4359 | 1443 | enum exp_opcode opcode, |
6fa9831f TT |
1444 | struct value *value) |
1445 | { | |
d0c97917 TT |
1446 | if (value->type ()->code () == TYPE_CODE_BOOL) |
1447 | return value_from_longest (value->type (), value_logical_not (value)); | |
6fa9831f TT |
1448 | return value_complement (value); |
1449 | } | |
1450 | ||
05104233 TT |
1451 | /* A helper function for OP_ARRAY. */ |
1452 | ||
6fab4359 | 1453 | struct value * |
05104233 TT |
1454 | eval_op_rust_array (struct type *expect_type, struct expression *exp, |
1455 | enum noside noside, | |
6fab4359 | 1456 | enum exp_opcode opcode, |
05104233 TT |
1457 | struct value *elt, struct value *ncopies) |
1458 | { | |
1459 | int copies = value_as_long (ncopies); | |
1460 | if (copies < 0) | |
1461 | error (_("Array with negative number of elements")); | |
1462 | ||
1463 | if (noside == EVAL_NORMAL) | |
7c651c5f | 1464 | return value_array (0, std::vector<value *> (copies, elt)); |
05104233 TT |
1465 | else |
1466 | { | |
1467 | struct type *arraytype | |
d0c97917 | 1468 | = lookup_array_range_type (elt->type (), 0, copies - 1); |
317c3ed9 | 1469 | return value::allocate (arraytype); |
05104233 TT |
1470 | } |
1471 | } | |
1472 | ||
f10522c0 TT |
1473 | namespace expr |
1474 | { | |
575cae23 | 1475 | |
e4407a20 | 1476 | struct value * |
f10522c0 TT |
1477 | rust_struct_anon::evaluate (struct type *expect_type, |
1478 | struct expression *exp, | |
1479 | enum noside noside) | |
575cae23 | 1480 | { |
f10522c0 TT |
1481 | value *lhs = std::get<1> (m_storage)->evaluate (nullptr, exp, noside); |
1482 | int field_number = std::get<0> (m_storage); | |
1483 | ||
d0c97917 | 1484 | struct type *type = lhs->type (); |
575cae23 TT |
1485 | |
1486 | if (type->code () == TYPE_CODE_STRUCT) | |
1487 | { | |
1488 | struct type *outer_type = NULL; | |
1489 | ||
1490 | if (rust_enum_p (type)) | |
1491 | { | |
efaf1ae0 | 1492 | type = resolve_dynamic_type (type, lhs->contents (), |
9feb2d07 | 1493 | lhs->address ()); |
575cae23 TT |
1494 | |
1495 | if (rust_empty_enum_p (type)) | |
1496 | error (_("Cannot access field %d of empty enum %s"), | |
1497 | field_number, type->name ()); | |
1498 | ||
1499 | int fieldno = rust_enum_variant (type); | |
6c49729e | 1500 | lhs = lhs->primitive_field (0, fieldno, type); |
575cae23 | 1501 | outer_type = type; |
d0c97917 | 1502 | type = lhs->type (); |
575cae23 TT |
1503 | } |
1504 | ||
1505 | /* Tuples and tuple structs */ | |
1506 | int nfields = type->num_fields (); | |
1507 | ||
1508 | if (field_number >= nfields || field_number < 0) | |
1509 | { | |
1510 | if (outer_type != NULL) | |
1511 | error(_("Cannot access field %d of variant %s::%s, " | |
1512 | "there are only %d fields"), | |
1513 | field_number, outer_type->name (), | |
1514 | rust_last_path_segment (type->name ()), | |
1515 | nfields); | |
1516 | else | |
1517 | error(_("Cannot access field %d of %s, " | |
1518 | "there are only %d fields"), | |
1519 | field_number, type->name (), nfields); | |
1520 | } | |
1521 | ||
1522 | /* Tuples are tuple structs too. */ | |
1523 | if (!rust_tuple_struct_type_p (type)) | |
1524 | { | |
1525 | if (outer_type != NULL) | |
1526 | error(_("Variant %s::%s is not a tuple variant"), | |
1527 | outer_type->name (), | |
1528 | rust_last_path_segment (type->name ())); | |
1529 | else | |
1530 | error(_("Attempting to access anonymous field %d " | |
1531 | "of %s, which is not a tuple, tuple struct, or " | |
1532 | "tuple-like variant"), | |
1533 | field_number, type->name ()); | |
1534 | } | |
1535 | ||
6c49729e | 1536 | return lhs->primitive_field (0, field_number, type); |
575cae23 TT |
1537 | } |
1538 | else | |
1539 | error(_("Anonymous field access is only allowed on tuples, \ | |
1540 | tuple structs, and tuple-like enum variants")); | |
1541 | } | |
1542 | ||
e4407a20 | 1543 | struct value * |
f10522c0 TT |
1544 | rust_structop::evaluate (struct type *expect_type, |
1545 | struct expression *exp, | |
1546 | enum noside noside) | |
1fa41fc7 | 1547 | { |
f10522c0 TT |
1548 | value *lhs = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); |
1549 | const char *field_name = std::get<1> (m_storage).c_str (); | |
1550 | ||
1fa41fc7 | 1551 | struct value *result; |
d0c97917 | 1552 | struct type *type = lhs->type (); |
1fa41fc7 TT |
1553 | if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type)) |
1554 | { | |
efaf1ae0 | 1555 | type = resolve_dynamic_type (type, lhs->contents (), |
9feb2d07 | 1556 | lhs->address ()); |
1fa41fc7 TT |
1557 | |
1558 | if (rust_empty_enum_p (type)) | |
1559 | error (_("Cannot access field %s of empty enum %s"), | |
1560 | field_name, type->name ()); | |
1561 | ||
1562 | int fieldno = rust_enum_variant (type); | |
6c49729e | 1563 | lhs = lhs->primitive_field (0, fieldno, type); |
1fa41fc7 TT |
1564 | |
1565 | struct type *outer_type = type; | |
d0c97917 | 1566 | type = lhs->type (); |
1fa41fc7 TT |
1567 | if (rust_tuple_type_p (type) || rust_tuple_struct_type_p (type)) |
1568 | error (_("Attempting to access named field %s of tuple " | |
1569 | "variant %s::%s, which has only anonymous fields"), | |
1570 | field_name, outer_type->name (), | |
1571 | rust_last_path_segment (type->name ())); | |
1572 | ||
1573 | try | |
1574 | { | |
158cc4fe | 1575 | result = value_struct_elt (&lhs, {}, field_name, |
1fa41fc7 TT |
1576 | NULL, "structure"); |
1577 | } | |
1578 | catch (const gdb_exception_error &except) | |
1579 | { | |
1580 | error (_("Could not find field %s of struct variant %s::%s"), | |
1581 | field_name, outer_type->name (), | |
1582 | rust_last_path_segment (type->name ())); | |
1583 | } | |
1584 | } | |
1585 | else | |
b0dd661f TT |
1586 | { |
1587 | if (rust_slice_type_p (type)) | |
1588 | lhs = convert_slice (lhs); | |
1589 | result = value_struct_elt (&lhs, {}, field_name, NULL, "structure"); | |
1590 | } | |
1fa41fc7 | 1591 | if (noside == EVAL_AVOID_SIDE_EFFECTS) |
736355f2 | 1592 | result = value::zero (result->type (), result->lval ()); |
1fa41fc7 TT |
1593 | return result; |
1594 | } | |
1595 | ||
5947d337 TT |
1596 | value * |
1597 | rust_aggregate_operation::evaluate (struct type *expect_type, | |
1598 | struct expression *exp, | |
1599 | enum noside noside) | |
1600 | { | |
1601 | struct type *type = std::get<0> (m_storage); | |
1602 | CORE_ADDR addr = 0; | |
1603 | struct value *addrval = NULL; | |
1604 | value *result; | |
1605 | ||
1606 | if (noside == EVAL_NORMAL) | |
1607 | { | |
df86565b | 1608 | addrval = value_allocate_space_in_inferior (type->length ()); |
5947d337 TT |
1609 | addr = value_as_long (addrval); |
1610 | result = value_at_lazy (type, addr); | |
1611 | } | |
1612 | ||
1613 | if (std::get<1> (m_storage) != nullptr) | |
1614 | { | |
1615 | struct value *init = std::get<1> (m_storage)->evaluate (nullptr, exp, | |
1616 | noside); | |
1617 | ||
1618 | if (noside == EVAL_NORMAL) | |
1619 | { | |
1620 | /* This isn't quite right but will do for the time | |
1621 | being, seeing that we can't implement the Copy | |
1622 | trait anyway. */ | |
1623 | value_assign (result, init); | |
1624 | } | |
1625 | } | |
1626 | ||
1627 | for (const auto &item : std::get<2> (m_storage)) | |
1628 | { | |
1629 | value *val = item.second->evaluate (nullptr, exp, noside); | |
1630 | if (noside == EVAL_NORMAL) | |
1631 | { | |
1632 | const char *fieldname = item.first.c_str (); | |
158cc4fe | 1633 | value *field = value_struct_elt (&result, {}, fieldname, |
5947d337 TT |
1634 | nullptr, "structure"); |
1635 | value_assign (field, val); | |
1636 | } | |
1637 | } | |
1638 | ||
aa1da9ed | 1639 | if (noside == EVAL_AVOID_SIDE_EFFECTS) |
317c3ed9 | 1640 | result = value::allocate (type); |
5947d337 TT |
1641 | else |
1642 | result = value_at_lazy (type, addr); | |
1643 | ||
1644 | return result; | |
1645 | } | |
1646 | ||
638fd74a TT |
1647 | value * |
1648 | rust_structop::evaluate_funcall (struct type *expect_type, | |
1649 | struct expression *exp, | |
1650 | enum noside noside, | |
1651 | const std::vector<operation_up> &ops) | |
1652 | { | |
1653 | std::vector<struct value *> args (ops.size () + 1); | |
1654 | ||
1655 | /* Evaluate the argument to STRUCTOP_STRUCT, then find its | |
1656 | type in order to look up the method. */ | |
1657 | args[0] = std::get<0> (m_storage)->evaluate (nullptr, exp, noside); | |
1658 | /* We don't yet implement real Deref semantics. */ | |
d0c97917 | 1659 | while (args[0]->type ()->code () == TYPE_CODE_PTR) |
638fd74a TT |
1660 | args[0] = value_ind (args[0]); |
1661 | ||
d0c97917 | 1662 | struct type *type = args[0]->type (); |
638fd74a TT |
1663 | if ((type->code () != TYPE_CODE_STRUCT |
1664 | && type->code () != TYPE_CODE_UNION | |
1665 | && type->code () != TYPE_CODE_ENUM) | |
1666 | || rust_tuple_type_p (type)) | |
1667 | error (_("Method calls only supported on struct or enum types")); | |
1668 | if (type->name () == NULL) | |
1669 | error (_("Method call on nameless type")); | |
1670 | ||
1671 | std::string name = (std::string (type->name ()) + "::" | |
1672 | + std::get<1> (m_storage)); | |
1673 | ||
1674 | const struct block *block = get_selected_block (0); | |
1675 | struct block_symbol sym = lookup_symbol (name.c_str (), block, | |
6cd92f3b | 1676 | SEARCH_FUNCTION_DOMAIN, |
ccf41c24 | 1677 | nullptr); |
638fd74a TT |
1678 | if (sym.symbol == NULL) |
1679 | error (_("Could not find function named '%s'"), name.c_str ()); | |
1680 | ||
5f9c5a63 | 1681 | struct type *fn_type = sym.symbol->type (); |
638fd74a TT |
1682 | if (fn_type->num_fields () == 0) |
1683 | error (_("Function '%s' takes no arguments"), name.c_str ()); | |
1684 | ||
1685 | if (fn_type->field (0).type ()->code () == TYPE_CODE_PTR) | |
1686 | args[0] = value_addr (args[0]); | |
1687 | ||
1688 | value *function = address_of_variable (sym.symbol, block); | |
1689 | ||
1690 | for (int i = 0; i < ops.size (); ++i) | |
1691 | args[i + 1] = ops[i]->evaluate (nullptr, exp, noside); | |
1692 | ||
1693 | if (noside == EVAL_AVOID_SIDE_EFFECTS) | |
ee7bb294 | 1694 | return value::zero (fn_type->target_type (), not_lval); |
638fd74a TT |
1695 | return call_function_by_hand (function, NULL, args); |
1696 | } | |
1697 | ||
5947d337 TT |
1698 | } |
1699 | ||
c44af4eb TT |
1700 | \f |
1701 | ||
1c485265 | 1702 | /* See language.h. */ |
0874fd07 | 1703 | |
1c485265 AB |
1704 | void |
1705 | rust_language::language_arch_info (struct gdbarch *gdbarch, | |
1706 | struct language_arch_info *lai) const | |
0874fd07 | 1707 | { |
1c485265 | 1708 | const struct builtin_type *builtin = builtin_type (gdbarch); |
87afa652 | 1709 | |
1c485265 AB |
1710 | /* Helper function to allow shorter lines below. */ |
1711 | auto add = [&] (struct type * t) -> struct type * | |
87afa652 | 1712 | { |
1c485265 AB |
1713 | lai->add_primitive_type (t); |
1714 | return t; | |
1715 | }; | |
1716 | ||
2d39ccd3 | 1717 | type_allocator alloc (gdbarch); |
1c485265 | 1718 | struct type *bool_type |
46c04ea3 | 1719 | = add (init_boolean_type (alloc, 8, 1, "bool")); |
f50b437c | 1720 | add (init_character_type (alloc, 32, 1, "char")); |
2d39ccd3 | 1721 | add (init_integer_type (alloc, 8, 0, "i8")); |
1c485265 | 1722 | struct type *u8_type |
2d39ccd3 TT |
1723 | = add (init_integer_type (alloc, 8, 1, "u8")); |
1724 | add (init_integer_type (alloc, 16, 0, "i16")); | |
1725 | add (init_integer_type (alloc, 16, 1, "u16")); | |
1726 | add (init_integer_type (alloc, 32, 0, "i32")); | |
1727 | add (init_integer_type (alloc, 32, 1, "u32")); | |
1728 | add (init_integer_type (alloc, 64, 0, "i64")); | |
1729 | add (init_integer_type (alloc, 64, 1, "u64")); | |
d760ae22 TT |
1730 | add (init_integer_type (alloc, 128, 0, "i128")); |
1731 | add (init_integer_type (alloc, 128, 1, "u128")); | |
1c485265 | 1732 | |
df86565b | 1733 | unsigned int length = 8 * builtin->builtin_data_ptr->length (); |
2d39ccd3 | 1734 | add (init_integer_type (alloc, length, 0, "isize")); |
1c485265 | 1735 | struct type *usize_type |
2d39ccd3 | 1736 | = add (init_integer_type (alloc, length, 1, "usize")); |
1c485265 | 1737 | |
77c5f496 TT |
1738 | add (init_float_type (alloc, 32, "f32", floatformats_ieee_single)); |
1739 | add (init_float_type (alloc, 64, "f64", floatformats_ieee_double)); | |
2d39ccd3 | 1740 | add (init_integer_type (alloc, 0, 1, "()")); |
1c485265 AB |
1741 | |
1742 | struct type *tem = make_cv_type (1, 0, u8_type, NULL); | |
1743 | add (rust_slice_type ("&str", tem, usize_type)); | |
1744 | ||
1745 | lai->set_bool_type (bool_type); | |
1746 | lai->set_string_char_type (u8_type); | |
1747 | } | |
39e7ecca | 1748 | |
1c485265 | 1749 | /* See language.h. */ |
efdf6a73 | 1750 | |
1c485265 AB |
1751 | void |
1752 | rust_language::print_type (struct type *type, const char *varstring, | |
1753 | struct ui_file *stream, int show, int level, | |
1754 | const struct type_print_options *flags) const | |
1755 | { | |
fbb46296 | 1756 | print_offset_data podata (flags); |
1c485265 AB |
1757 | rust_internal_print_type (type, varstring, stream, show, level, |
1758 | flags, false, &podata); | |
1759 | } | |
efdf6a73 | 1760 | |
1c485265 | 1761 | /* See language.h. */ |
5aba6ebe | 1762 | |
1c485265 AB |
1763 | void |
1764 | rust_language::emitchar (int ch, struct type *chtype, | |
1765 | struct ui_file *stream, int quoter) const | |
1766 | { | |
1767 | if (!rust_chartype_p (chtype)) | |
1768 | generic_emit_char (ch, chtype, stream, quoter, | |
8ee511af | 1769 | target_charset (chtype->arch ())); |
1c485265 | 1770 | else if (ch == '\\' || ch == quoter) |
6cb06a8c | 1771 | gdb_printf (stream, "\\%c", ch); |
1c485265 | 1772 | else if (ch == '\n') |
0426ad51 | 1773 | gdb_puts ("\\n", stream); |
1c485265 | 1774 | else if (ch == '\r') |
0426ad51 | 1775 | gdb_puts ("\\r", stream); |
1c485265 | 1776 | else if (ch == '\t') |
0426ad51 | 1777 | gdb_puts ("\\t", stream); |
1c485265 | 1778 | else if (ch == '\0') |
0426ad51 | 1779 | gdb_puts ("\\0", stream); |
1c485265 | 1780 | else if (ch >= 32 && ch <= 127 && isprint (ch)) |
a11ac3b3 | 1781 | gdb_putc (ch, stream); |
1c485265 | 1782 | else if (ch <= 255) |
6cb06a8c | 1783 | gdb_printf (stream, "\\x%02x", ch); |
1c485265 | 1784 | else |
6cb06a8c | 1785 | gdb_printf (stream, "\\u{%06x}", ch); |
1c485265 | 1786 | } |
5aba6ebe | 1787 | |
1c485265 | 1788 | /* See language.h. */ |
b7c6e27d | 1789 | |
b0dd661f TT |
1790 | bool |
1791 | rust_language::is_array_like (struct type *type) const | |
1792 | { | |
1793 | if (!rust_slice_type_p (type)) | |
1794 | return false; | |
1795 | return rust_array_like_element_type (type) != nullptr; | |
1796 | } | |
1797 | ||
1798 | /* See language.h. */ | |
1799 | ||
1c485265 AB |
1800 | bool |
1801 | rust_language::is_string_type_p (struct type *type) const | |
1802 | { | |
1803 | LONGEST low_bound, high_bound; | |
b7c6e27d | 1804 | |
1c485265 AB |
1805 | type = check_typedef (type); |
1806 | return ((type->code () == TYPE_CODE_STRING) | |
1807 | || (type->code () == TYPE_CODE_PTR | |
27710edb SM |
1808 | && (type->target_type ()->code () == TYPE_CODE_ARRAY |
1809 | && rust_u8_type_p (type->target_type ()->target_type ()) | |
1810 | && get_array_bounds (type->target_type (), &low_bound, | |
1c485265 AB |
1811 | &high_bound))) |
1812 | || (type->code () == TYPE_CODE_STRUCT | |
1813 | && !rust_enum_p (type) | |
1814 | && rust_slice_type_p (type) | |
1815 | && strcmp (type->name (), "&str") == 0)); | |
1816 | } | |
0874fd07 | 1817 | |
e1a482ad TT |
1818 | /* See language.h. */ |
1819 | ||
1820 | struct block_symbol | |
1821 | rust_language::lookup_symbol_nonlocal | |
1822 | (const char *name, const struct block *block, | |
ccf41c24 | 1823 | const domain_search_flags domain) const |
e1a482ad TT |
1824 | { |
1825 | struct block_symbol result = {}; | |
1826 | ||
1827 | const char *scope = block == nullptr ? "" : block->scope (); | |
1828 | symbol_lookup_debug_printf | |
1829 | ("rust_lookup_symbol_non_local (%s, %s (scope %s), %s)", | |
1830 | name, host_address_to_string (block), scope, | |
ccf41c24 | 1831 | domain_name (domain).c_str ()); |
e1a482ad TT |
1832 | |
1833 | /* Look up bare names in the block's scope. */ | |
1834 | std::string scopedname; | |
1835 | if (name[cp_find_first_component (name)] == '\0') | |
1836 | { | |
1837 | if (scope[0] != '\0') | |
1838 | { | |
1839 | scopedname = std::string (scope) + "::" + name; | |
1840 | name = scopedname.c_str (); | |
1841 | } | |
1842 | else | |
1843 | name = NULL; | |
1844 | } | |
1845 | ||
1846 | if (name != NULL) | |
1847 | { | |
1848 | result = lookup_symbol_in_static_block (name, block, domain); | |
1849 | if (result.symbol == NULL) | |
1850 | result = lookup_global_symbol (name, block, domain); | |
1851 | } | |
1852 | return result; | |
1853 | } | |
1854 | ||
0874fd07 AB |
1855 | /* Single instance of the Rust language class. */ |
1856 | ||
1857 | static rust_language rust_language_defn; |