OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix indentation level in ada-lang.c::ada_evaluate_subexp. 

I just happen to notice that a lexical block was missing one
indentation level.

gdb/ChangeLog:

        * ada-lang.c (ada_evaluate_subexp) <OP_VAR_VALUE>: Fix identation
        of lexical block.
This commit is contained in:
Joel Brobecker 2014-08-14 13:26:34 -07:00
parent cb8e01c6bb
commit 0d72a7c318
2 changed files with 46 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
gdb/ChangeLog
View File

@ -1,3 +1,8 @@
2014-08-18 Joel Brobecker <brobecker@adacore.com>
* ada-lang.c (ada_evaluate_subexp) <OP_VAR_VALUE>: Fix identation
of lexical block.
2014-08-15 Siva Chandra Reddy <sivachandra@google.com> 2014-08-15 Siva Chandra Reddy <sivachandra@google.com>
PR c++/17132 PR c++/17132

82
gdb/ada-lang.c
View File

@ -10138,50 +10138,50 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
if (ada_is_tagged_type (type, 0) if (ada_is_tagged_type (type, 0)
|| (TYPE_CODE (type) == TYPE_CODE_REF || (TYPE_CODE (type) == TYPE_CODE_REF
&& ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0))) && ada_is_tagged_type (TYPE_TARGET_TYPE (type), 0)))
{ {
/* Tagged types are a little special in the fact that the real /* Tagged types are a little special in the fact that the real
type is dynamic and can only be determined by inspecting the type is dynamic and can only be determined by inspecting the
object's tag. This means that we need to get the object's object's tag. This means that we need to get the object's
value first (EVAL_NORMAL) and then extract the actual object value first (EVAL_NORMAL) and then extract the actual object
type from its tag. type from its tag.
Note that we cannot skip the final step where we extract Note that we cannot skip the final step where we extract
the object type from its tag, because the EVAL_NORMAL phase the object type from its tag, because the EVAL_NORMAL phase
results in dynamic components being resolved into fixed ones. results in dynamic components being resolved into fixed ones.
This can cause problems when trying to print the type This can cause problems when trying to print the type
description of tagged types whose parent has a dynamic size: description of tagged types whose parent has a dynamic size:
We use the type name of the "_parent" component in order We use the type name of the "_parent" component in order
to print the name of the ancestor type in the type description. to print the name of the ancestor type in the type description.
If that component had a dynamic size, the resolution into If that component had a dynamic size, the resolution into
a fixed type would result in the loss of that type name, a fixed type would result in the loss of that type name,
thus preventing us from printing the name of the ancestor thus preventing us from printing the name of the ancestor
type in the type description. */ type in the type description. */
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL); arg1 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
if (TYPE_CODE (type) != TYPE_CODE_REF) if (TYPE_CODE (type) != TYPE_CODE_REF)
{ {
struct type *actual_type; struct type *actual_type;
actual_type = type_from_tag (ada_value_tag (arg1)); actual_type = type_from_tag (ada_value_tag (arg1));
if (actual_type == NULL) if (actual_type == NULL)
/* If, for some reason, we were unable to determine /* If, for some reason, we were unable to determine
the actual type from the tag, then use the static the actual type from the tag, then use the static
approximation that we just computed as a fallback. approximation that we just computed as a fallback.
This can happen if the debugging information is This can happen if the debugging information is
incomplete, for instance. */ incomplete, for instance. */
actual_type = type; actual_type = type;
return value_zero (actual_type, not_lval); return value_zero (actual_type, not_lval);
} }
else else
{ {
/* In the case of a ref, ada_coerce_ref takes care /* In the case of a ref, ada_coerce_ref takes care
of determining the actual type. But the evaluation of determining the actual type. But the evaluation
should return a ref as it should be valid to ask should return a ref as it should be valid to ask
for its address; so rebuild a ref after coerce. */ for its address; so rebuild a ref after coerce. */
arg1 = ada_coerce_ref (arg1); arg1 = ada_coerce_ref (arg1);
return value_ref (arg1); return value_ref (arg1);
} }
} }
*pos += 4; *pos += 4;
return value_zero (to_static_fixed_type (type), not_lval); return value_zero (to_static_fixed_type (type), not_lval);