* [PATCH] Handle volatile array types in dwarf2read.c. @ 2014-06-30 21:35 Mark Wielaard 2014-07-01 16:05 ` Tom Tromey 0 siblings, 1 reply; 5+ messages in thread From: Mark Wielaard @ 2014-06-30 21:35 UTC (permalink / raw) To: gdb-patches; +Cc: Tom Tromey, Mark Wielaard read_tag_const_type propagates the cv-qualifier to the array element type, but read_tag_volatile_type didn't. Make sure that both cv-qualifiers that apply to array types are handled the same. gdb/ChangeLog * dwarf2read.c (add_array_cv_type): New function. (read_tag_const_type): Call add_array_cv_type for TYPE_CODE_ARRAY. (read_tag_volatile_type): Likewise. gdb/testsuite/ChangeLog * gdb.base/constvars.c (violent, violet, vips, virgen, vulgar, vulture, vilify, villar): New volatile array constants. (vindictive, vegetation): New const volatile array constants. * gdb.base/volatile.exp: Test volatile and const volatile array types. --- gdb/ChangeLog | 6 ++++ gdb/dwarf2read.c | 55 +++++++++++++++++++++++------------ gdb/testsuite/ChangeLog | 8 +++++ gdb/testsuite/gdb.base/constvars.c | 14 +++++++++ gdb/testsuite/gdb.base/volatile.exp | 24 +++++++++++++++ 5 files changed, 88 insertions(+), 19 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 8d304ac..ccfae0c 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,9 @@ +2014-06-30 Mark Wielaard <mjw@redhat.com> + + * dwarf2read.c (add_array_cv_type): New function. + (read_tag_const_type): Call add_array_cv_type for TYPE_CODE_ARRAY. + (read_tag_volatile_type): Likewise. + 2014-06-30 Tom Tromey <tromey@redhat.com> * symtab.c (operator_chars): Make parameters and return type diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index fc4f7cb..f36c67a 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -14097,6 +14097,35 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu) return set_die_type (die, type, cu); } +/* Add the given cv-qualifiers to the element type of the array. GCC + outputs DWARF type qualifiers that apply to an array, not the + element type. But GDB relies on the array element type to carry + the cv-qualifiers. This is mimics section 6.7.3 of the C99 + specification. */ +static struct type * +add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu, + struct type *base_type, int cnst, int voltl) +{ + struct type *el_type, *inner_array; + + base_type = copy_type (base_type); + inner_array = base_type; + + while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) + { + TYPE_TARGET_TYPE (inner_array) = + copy_type (TYPE_TARGET_TYPE (inner_array)); + inner_array = TYPE_TARGET_TYPE (inner_array); + } + + el_type = TYPE_TARGET_TYPE (inner_array); + cnst |= TYPE_CONST (el_type); + voltl |= TYPE_VOLATILE (el_type); + TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL); + + return set_die_type (die, base_type, cu); +} + static struct type * read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) { @@ -14112,25 +14141,7 @@ read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) /* In case the const qualifier is applied to an array type, the element type is so qualified, not the array type (section 6.7.3 of C99). */ if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) - { - struct type *el_type, *inner_array; - - base_type = copy_type (base_type); - inner_array = base_type; - - while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) - { - TYPE_TARGET_TYPE (inner_array) = - copy_type (TYPE_TARGET_TYPE (inner_array)); - inner_array = TYPE_TARGET_TYPE (inner_array); - } - - el_type = TYPE_TARGET_TYPE (inner_array); - TYPE_TARGET_TYPE (inner_array) = - make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL); - - return set_die_type (die, base_type, cu); - } + return add_array_cv_type (die, cu, base_type, 1, 0); cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0); return set_die_type (die, cv_type, cu); @@ -14148,6 +14159,12 @@ read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu) if (cv_type) return cv_type; + /* In case the volatile qualifier is applied to an array type, the + element type is so qualified, not the array type (section 6.7.3 + of C99). */ + if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) + return add_array_cv_type (die, cu, base_type, 0, 1); + cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0); return set_die_type (die, cv_type, cu); } diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 751848f..90be171 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2014-06-30 Mark Wielaard <mjw@redhat.com> + + * gdb.base/constvars.c (violent, violet, vips, virgen, vulgar, + vulture, vilify, villar): New volatile array constants. + (vindictive, vegetation): New const volatile array constants. + * gdb.base/volatile.exp: Test volatile and const volatile array + types. + 2014-06-30 Andreas Arnez <arnez@linux.vnet.ibm.com> * gdb.base/watchpoint-reuse-slot.exp: Handle the case that the diff --git a/gdb/testsuite/gdb.base/constvars.c b/gdb/testsuite/gdb.base/constvars.c index 4228822..60cca2a 100644 --- a/gdb/testsuite/gdb.base/constvars.c +++ b/gdb/testsuite/gdb.base/constvars.c @@ -127,6 +127,16 @@ main (void) volatile float * volatile vitality = &vacuity; volatile double * volatile voracity = &vertigo; + /* volatile arrays */ + volatile char violent[2] = {vox, vox}; + volatile unsigned char violet[2] = {victuals, victuals}; + volatile short vips[2] = {vixen, vixen}; + volatile unsigned short virgen[2] = {vitriol, vitriol}; + volatile long vulgar[2] = {vellum, vellum}; + volatile unsigned long vulture[2] = {valve, valve}; + volatile float vilify[2] = {vacuity, vacuity}; + volatile double villar[2] = {vertigo, vertigo}; + /* const volatile vars */ const volatile char victor = 'Y'; @@ -177,6 +187,10 @@ main (void) const volatile char * const volatile vagary = &victor; const volatile unsigned char * const volatile vendor = &vicar; + /* const volatile arrays */ + const volatile char vindictive[2] = {victor, victor}; + const volatile unsigned char vegetation[2] = {vicar, vicar}; + /* various structs with const members */ struct crass { char * const ptr; } crass = { lamprey }; diff --git a/gdb/testsuite/gdb.base/volatile.exp b/gdb/testsuite/gdb.base/volatile.exp index 7cd7254..0e106fc 100644 --- a/gdb/testsuite/gdb.base/volatile.exp +++ b/gdb/testsuite/gdb.base/volatile.exp @@ -229,6 +229,30 @@ gdb_test "ptype vagary" "type = const volatile char \\* const volatile.*" local_compiler_xfail_check gdb_test "ptype vendor" "type = const volatile unsigned char \\* const volatile.*" +# volatile arrays +local_compiler_xfail_check +gdb_test "ptype violent" "type = volatile char \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype violet" "type = volatile unsigned char \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vips" "type = volatile short( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype virgen" "type = volatile (unsigned short|short unsigned)( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vulgar" "type = volatile long( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vulture" "type = volatile (unsigned long|long unsigned)( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vilify" "type = volatile float \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype villar" "type = volatile double \\\[2\\\]" + +# const volatile arrays +local_compiler_xfail_check +gdb_test "ptype vindictive" "type = const volatile char \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vegetation" "type = const volatile unsigned char \\\[2\\\]" + # test function parameters local_compiler_xfail_check local_compiler_xfail_check_2 -- 1.7.1 ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] Handle volatile array types in dwarf2read.c. 2014-06-30 21:35 [PATCH] Handle volatile array types in dwarf2read.c Mark Wielaard @ 2014-07-01 16:05 ` Tom Tromey 2014-07-01 18:11 ` Mark Wielaard 0 siblings, 1 reply; 5+ messages in thread From: Tom Tromey @ 2014-07-01 16:05 UTC (permalink / raw) To: Mark Wielaard; +Cc: gdb-patches >>>>> "Mark" == Mark Wielaard <mjw@redhat.com> writes: Mark> read_tag_const_type propagates the cv-qualifier to the array Mark> element type, but read_tag_volatile_type didn't. Make sure that Mark> both cv-qualifiers that apply to array types are handled the same. Thanks Mark. Mark> * gdb.base/constvars.c (violent, violet, vips, virgen, vulgar, Mark> vulture, vilify, villar): New volatile array constants. Mark> (vindictive, vegetation): New const volatile array constants. Lovely names. Mark> + the cv-qualifiers. This is mimics section 6.7.3 of the C99 Mark> + specification. */ "This is" -> "This". Mark> +static struct type * Mark> +add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu, Mark> + struct type *base_type, int cnst, int voltl) gdb usually puts a blank line between the intro comment and the function head. Mark> + while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) Mark> + { Mark> + TYPE_TARGET_TYPE (inner_array) = Mark> + copy_type (TYPE_TARGET_TYPE (inner_array)); Mark> + inner_array = TYPE_TARGET_TYPE (inner_array); Mark> + } I think this may be overly eager in the case where the underlying type already has the needed qualifications. Mark> + cnst |= TYPE_CONST (el_type); Mark> + voltl |= TYPE_VOLATILE (el_type); Mark> + TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL); make_cv_type preserves the already existing qualifiers so you don't need to track "cnst" and "voltl". You can just pass in the ones you want to add. Mark> + /* In case the volatile qualifier is applied to an array type, the Mark> + element type is so qualified, not the array type (section 6.7.3 Mark> + of C99). */ Mark> + if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) Mark> + return add_array_cv_type (die, cu, base_type, 0, 1); I wonder about typedefs to array type. Calling check_typedef here is probably not so great but I assume we can just ignore incomplete types. Tom ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] Handle volatile array types in dwarf2read.c. 2014-07-01 16:05 ` Tom Tromey @ 2014-07-01 18:11 ` Mark Wielaard 2014-07-01 18:25 ` Tom Tromey 0 siblings, 1 reply; 5+ messages in thread From: Mark Wielaard @ 2014-07-01 18:11 UTC (permalink / raw) To: Tom Tromey; +Cc: gdb-patches [-- Attachment #1: Type: text/plain, Size: 2620 bytes --] On Tue, 2014-07-01 at 10:04 -0600, Tom Tromey wrote: > Mark> + the cv-qualifiers. This is mimics section 6.7.3 of the C99 > Mark> + specification. */ > > "This is" -> "This". Fixed. > Mark> +static struct type * > Mark> +add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu, > Mark> + struct type *base_type, int cnst, int voltl) > > gdb usually puts a blank line between the intro comment and the function > head. Fixed. > Mark> + while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) > Mark> + { > Mark> + TYPE_TARGET_TYPE (inner_array) = > Mark> + copy_type (TYPE_TARGET_TYPE (inner_array)); > Mark> + inner_array = TYPE_TARGET_TYPE (inner_array); > Mark> + } > > I think this may be overly eager in the case where the underlying type > already has the needed qualifications. But we have to look anyway. This is just the existing code, moved into its own function. What do you suggest should be changed? > Mark> + cnst |= TYPE_CONST (el_type); > Mark> + voltl |= TYPE_VOLATILE (el_type); > Mark> + TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL); > > make_cv_type preserves the already existing qualifiers so you don't need > to track "cnst" and "voltl". You can just pass in the ones you want to > add. The original code already did it this way. And I don't think it is true that make_cv_type preserves existing const or volatile qualifiers. The first thing make_cv_type does is mask away the old const and volatile flags. Without explicitly preserving the existing flags 2 of the new testcases, the const volatile arrays tests, fail (note one of the qualifiers is missing): ptype vindictive type = const char [2] (gdb) FAIL: gdb.base/volatile.exp: ptype vindictive ptype vegetation type = const unsigned char [2] (gdb) FAIL: gdb.base/volatile.exp: ptype vegetation > Mark> + /* In case the volatile qualifier is applied to an array type, the > Mark> + element type is so qualified, not the array type (section 6.7.3 > Mark> + of C99). */ > Mark> + if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) > Mark> + return add_array_cv_type (die, cu, base_type, 0, 1); > > I wonder about typedefs to array type. > Calling check_typedef here is probably not so great but I assume we can > just ignore incomplete types. I am not sure I understand precisely what you are wondering about. Do you have an example? Then I can add a testcase for it. This is just precisely as is done for the const case. So the issue you are thinking about is probably the same for both cases and might already be existing. Thanks, Mark [-- Attachment #2: cv-array.patch --] [-- Type: text/x-patch, Size: 7681 bytes --] commit 8782e0bef99e1c282364d283f5cbf6cc32f437ee Author: Mark Wielaard <mjw@redhat.com> Date: Mon Jun 30 23:21:52 2014 +0200 Handle volatile array types in dwarf2read.c. read_tag_const_type propagates the cv-qualifier to the array element type, but read_tag_volatile_type didn't. Make sure that both cv-qualifiers that apply to array types are handled the same. gdb/ChangeLog * dwarf2read.c (add_array_cv_type): New function. (read_tag_const_type): Call add_array_cv_type for TYPE_CODE_ARRAY. (read_tag_volatile_type): Likewise. gdb/testsuite/ChangeLog * gdb.base/constvars.c (violent, violet, vips, virgen, vulgar, vulture, vilify, villar): New volatile array constants. (vindictive, vegetation): New const volatile array constants. * gdb.base/volatile.exp: Test volatile and const volatile array types. diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 8d304ac..ccfae0c 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,9 @@ +2014-06-30 Mark Wielaard <mjw@redhat.com> + + * dwarf2read.c (add_array_cv_type): New function. + (read_tag_const_type): Call add_array_cv_type for TYPE_CODE_ARRAY. + (read_tag_volatile_type): Likewise. + 2014-06-30 Tom Tromey <tromey@redhat.com> * symtab.c (operator_chars): Make parameters and return type diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index fc4f7cb..8b600fb 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -14097,6 +14097,36 @@ read_tag_reference_type (struct die_info *die, struct dwarf2_cu *cu) return set_die_type (die, type, cu); } +/* Add the given cv-qualifiers to the element type of the array. GCC + outputs DWARF type qualifiers that apply to an array, not the + element type. But GDB relies on the array element type to carry + the cv-qualifiers. This mimics section 6.7.3 of the C99 + specification. */ + +static struct type * +add_array_cv_type (struct die_info *die, struct dwarf2_cu *cu, + struct type *base_type, int cnst, int voltl) +{ + struct type *el_type, *inner_array; + + base_type = copy_type (base_type); + inner_array = base_type; + + while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) + { + TYPE_TARGET_TYPE (inner_array) = + copy_type (TYPE_TARGET_TYPE (inner_array)); + inner_array = TYPE_TARGET_TYPE (inner_array); + } + + el_type = TYPE_TARGET_TYPE (inner_array); + cnst |= TYPE_CONST (el_type); + voltl |= TYPE_VOLATILE (el_type); + TYPE_TARGET_TYPE (inner_array) = make_cv_type (cnst, voltl, el_type, NULL); + + return set_die_type (die, base_type, cu); +} + static struct type * read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) { @@ -14112,25 +14142,7 @@ read_tag_const_type (struct die_info *die, struct dwarf2_cu *cu) /* In case the const qualifier is applied to an array type, the element type is so qualified, not the array type (section 6.7.3 of C99). */ if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) - { - struct type *el_type, *inner_array; - - base_type = copy_type (base_type); - inner_array = base_type; - - while (TYPE_CODE (TYPE_TARGET_TYPE (inner_array)) == TYPE_CODE_ARRAY) - { - TYPE_TARGET_TYPE (inner_array) = - copy_type (TYPE_TARGET_TYPE (inner_array)); - inner_array = TYPE_TARGET_TYPE (inner_array); - } - - el_type = TYPE_TARGET_TYPE (inner_array); - TYPE_TARGET_TYPE (inner_array) = - make_cv_type (1, TYPE_VOLATILE (el_type), el_type, NULL); - - return set_die_type (die, base_type, cu); - } + return add_array_cv_type (die, cu, base_type, 1, 0); cv_type = make_cv_type (1, TYPE_VOLATILE (base_type), base_type, 0); return set_die_type (die, cv_type, cu); @@ -14148,6 +14160,12 @@ read_tag_volatile_type (struct die_info *die, struct dwarf2_cu *cu) if (cv_type) return cv_type; + /* In case the volatile qualifier is applied to an array type, the + element type is so qualified, not the array type (section 6.7.3 + of C99). */ + if (TYPE_CODE (base_type) == TYPE_CODE_ARRAY) + return add_array_cv_type (die, cu, base_type, 0, 1); + cv_type = make_cv_type (TYPE_CONST (base_type), 1, base_type, 0); return set_die_type (die, cv_type, cu); } diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 751848f..90be171 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2014-06-30 Mark Wielaard <mjw@redhat.com> + + * gdb.base/constvars.c (violent, violet, vips, virgen, vulgar, + vulture, vilify, villar): New volatile array constants. + (vindictive, vegetation): New const volatile array constants. + * gdb.base/volatile.exp: Test volatile and const volatile array + types. + 2014-06-30 Andreas Arnez <arnez@linux.vnet.ibm.com> * gdb.base/watchpoint-reuse-slot.exp: Handle the case that the diff --git a/gdb/testsuite/gdb.base/constvars.c b/gdb/testsuite/gdb.base/constvars.c index 4228822..60cca2a 100644 --- a/gdb/testsuite/gdb.base/constvars.c +++ b/gdb/testsuite/gdb.base/constvars.c @@ -127,6 +127,16 @@ main (void) volatile float * volatile vitality = &vacuity; volatile double * volatile voracity = &vertigo; + /* volatile arrays */ + volatile char violent[2] = {vox, vox}; + volatile unsigned char violet[2] = {victuals, victuals}; + volatile short vips[2] = {vixen, vixen}; + volatile unsigned short virgen[2] = {vitriol, vitriol}; + volatile long vulgar[2] = {vellum, vellum}; + volatile unsigned long vulture[2] = {valve, valve}; + volatile float vilify[2] = {vacuity, vacuity}; + volatile double villar[2] = {vertigo, vertigo}; + /* const volatile vars */ const volatile char victor = 'Y'; @@ -177,6 +187,10 @@ main (void) const volatile char * const volatile vagary = &victor; const volatile unsigned char * const volatile vendor = &vicar; + /* const volatile arrays */ + const volatile char vindictive[2] = {victor, victor}; + const volatile unsigned char vegetation[2] = {vicar, vicar}; + /* various structs with const members */ struct crass { char * const ptr; } crass = { lamprey }; diff --git a/gdb/testsuite/gdb.base/volatile.exp b/gdb/testsuite/gdb.base/volatile.exp index 7cd7254..0e106fc 100644 --- a/gdb/testsuite/gdb.base/volatile.exp +++ b/gdb/testsuite/gdb.base/volatile.exp @@ -229,6 +229,30 @@ gdb_test "ptype vagary" "type = const volatile char \\* const volatile.*" local_compiler_xfail_check gdb_test "ptype vendor" "type = const volatile unsigned char \\* const volatile.*" +# volatile arrays +local_compiler_xfail_check +gdb_test "ptype violent" "type = volatile char \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype violet" "type = volatile unsigned char \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vips" "type = volatile short( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype virgen" "type = volatile (unsigned short|short unsigned)( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vulgar" "type = volatile long( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vulture" "type = volatile (unsigned long|long unsigned)( int)? \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vilify" "type = volatile float \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype villar" "type = volatile double \\\[2\\\]" + +# const volatile arrays +local_compiler_xfail_check +gdb_test "ptype vindictive" "type = const volatile char \\\[2\\\]" +local_compiler_xfail_check +gdb_test "ptype vegetation" "type = const volatile unsigned char \\\[2\\\]" + # test function parameters local_compiler_xfail_check local_compiler_xfail_check_2 ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] Handle volatile array types in dwarf2read.c. 2014-07-01 18:11 ` Mark Wielaard @ 2014-07-01 18:25 ` Tom Tromey 2014-07-01 20:15 ` Mark Wielaard 0 siblings, 1 reply; 5+ messages in thread From: Tom Tromey @ 2014-07-01 18:25 UTC (permalink / raw) To: Mark Wielaard; +Cc: gdb-patches Mark> But we have to look anyway. This is just the existing code, moved into Mark> its own function. What do you suggest should be changed? It's fine to leave it. Tom> make_cv_type preserves the already existing qualifiers so you don't need Tom> to track "cnst" and "voltl". You can just pass in the ones you want to Tom> add. Mark> The original code already did it this way. And I don't think it is true Mark> that make_cv_type preserves existing const or volatile qualifiers. Wow, I wonder how long I've had the incorrect view of make_cv_type. Hopefully not too long. Thanks for pointing that out. Tom> I wonder about typedefs to array type. Tom> Calling check_typedef here is probably not so great but I assume we can Tom> just ignore incomplete types. Mark> I am not sure I understand precisely what you are wondering about. Do Mark> you have an example? Then I can add a testcase for it. This is just Mark> precisely as is done for the const case. So the issue you are thinking Mark> about is probably the same for both cases and might already be existing. Well, I was thinking this: typedef int atype[23]; const atype a; However, gcc omits the typedef from the DWARF, so I suppose some hand-crafted DWARF would have to be written. This patch is ok. If there's a further bug and you want to fix it, it's fine to do that separately. Tom ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] Handle volatile array types in dwarf2read.c. 2014-07-01 18:25 ` Tom Tromey @ 2014-07-01 20:15 ` Mark Wielaard 0 siblings, 0 replies; 5+ messages in thread From: Mark Wielaard @ 2014-07-01 20:15 UTC (permalink / raw) To: Tom Tromey; +Cc: gdb-patches On Tue, 2014-07-01 at 12:24 -0600, Tom Tromey wrote: > This patch is ok. Thanks, pushed. > Well, I was thinking this: > > typedef int atype[23]; > const atype a; > > However, gcc omits the typedef from the DWARF, so I suppose some > hand-crafted DWARF would have to be written. I tried in a couple of ways, but GCC always happily optimizes the unnecessary typedefs away from the DWARF, so it probably is not an issue in practice if GDB doesn't completely handle that case. Cheers, Mark ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2014-07-01 20:15 UTC | newest] Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2014-06-30 21:35 [PATCH] Handle volatile array types in dwarf2read.c Mark Wielaard 2014-07-01 16:05 ` Tom Tromey 2014-07-01 18:11 ` Mark Wielaard 2014-07-01 18:25 ` Tom Tromey 2014-07-01 20:15 ` Mark Wielaard
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox