From 490fa27b1c000652f10b797091747d21c6bb9337 Mon Sep 17 00:00:00 2001 From: law Date: Thu, 28 Oct 1999 11:39:31 +0000 Subject: [PATCH] * tree.def (PLACEHOLDER_EXPR): Update comments. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@30241 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 4 ++++ gcc/tree.def | 69 +++++++++++++++++++++++++++++++++-------------------------- 2 files changed, 43 insertions(+), 30 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 66642cd..f8ac988 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,7 @@ +Thu Oct 28 03:37:50 1999 Peter Gerwinski + + * tree.def (PLACEHOLDER_EXPR): Update comments. + Thu Oct 28 06:47:32 1999 Kaveh R. Ghazi * c-common.c (check_format_info): Avoid non-literal format string diff --git a/gcc/tree.def b/gcc/tree.def index af50d7b..9ccc3c5 100644 --- a/gcc/tree.def +++ b/gcc/tree.def @@ -490,39 +490,48 @@ DEFTREECODE (WITH_CLEANUP_EXPR, "with_cleanup_expr", 'e', 3) DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1) /* The following two codes are used in languages that have types where - the position and/or sizes of fields vary from object to object of the - same type, i.e., where some other field in the object contains a value - that is used in the computation of another field's offset or size. - - For example, a record type with a discriminant in Ada is such a type. - This mechanism is also used to create "fat pointers" for unconstrained - array types in Ada; the fat pointer is a structure one of whose fields is - a pointer to the actual array type and the other field is a pointer to a - template, which is a structure containing the bounds of the array. The - bounds in the type pointed to by the first field in the fat pointer refer - to the values in the template. - - These "self-references" are doing using a PLACEHOLDER_EXPR. This is a - node that will later be replaced with the object being referenced. Its type - is that of the object and selects which object to use from a chain of - references (see below). - - When we wish to evaluate a size or offset, we check it is contains a - placeholder. If it does, we construct a WITH_RECORD_EXPR that contains - both the expression we wish to evaluate and an expression within which the - object may be found. The latter expression is the object itself in - the simple case of an Ada record with discriminant, but it can be the - array in the case of an unconstrained array. - - In the latter case, we need the fat pointer, because the bounds of the - array can only be accessed from it. However, we rely here on the fact that - the expression for the array contains the dereference of the fat pointer - that obtained the array pointer. + some field in an object of the type contains a value that is used in + the computation of another field's offset or size and/or the size of + the type. The positions and/or sizes of fields can vary from object + to object of the same type. + + Record types with discriminants in Ada or schema types in Pascal are + examples of such types. This mechanism is also used to create "fat + pointers" for unconstrained array types in Ada; the fat pointer is a + structure one of whose fields is a pointer to the actual array type + and the other field is a pointer to a template, which is a structure + containing the bounds of the array. The bounds in the type pointed + to by the first field in the fat pointer refer to the values in the + template. + + When you wish to construct such a type you need "self-references" + that allow you to reference the object having this type from the + TYPE node, i.e. without having a variable instantiating this type. + + Such a "self-references" is done using a PLACEHOLDER_EXPR. This is + a node that will later be replaced with the object being referenced. + Its type is that of the object and selects which object to use from + a chain of references (see below). No other slots are used in the + PLACEHOLDER_EXPR. + + For example, if your type FOO is a RECORD_TYPE with a field BAR, + and you need the value of .BAR to calculate TYPE_SIZE + (FOO), just substitute above with a PLACEHOLDER_EXPR + what contains both the expression we wish to + evaluate and an expression within which the object may be found. + The latter expression is the object itself in the simple case of an + Ada record with discriminant, but it can be the array in the case of + an unconstrained array. + + In the latter case, we need the fat pointer, because the bounds of + the array can only be accessed from it. However, we rely here on the + fact that the expression for the array contains the dereference of + the fat pointer that obtained the array pointer. Accordingly, when looking for the object to substitute in place of a PLACEHOLDER_EXPR, we look down the first operand of the expression - passed as the second operand to WITH_RECORD_EXPR until we find something - of the desired type or reach a constant. */ + passed as the second operand to WITH_RECORD_EXPR until we find + something of the desired type or reach a constant. */ /* Denotes a record to later be supplied with a WITH_RECORD_EXPR when evaluating this expression. The type of this expression is used to -- 2.7.4