Re: [PATCH v10 2/5] Convert references with "counted_by" attributes to/from .ACCESS_WITH_SIZE.

[Qing Zhao <qing.zhao@oracle.com>]

> On May 31, 2024, at 08:58, Richard Biener <rguenther@suse.de> wrote:
> 
> On Thu, 30 May 2024, Qing Zhao wrote:
> 
>> Including the following changes:
>> * The definition of the new internal function .ACCESS_WITH_SIZE
>>  in internal-fn.def.
>> * C FE converts every reference to a FAM with a "counted_by" attribute
>>  to a call to the internal function .ACCESS_WITH_SIZE.
>>  (build_component_ref in c_typeck.cc)
>> 
>>  This includes the case when the object is statically allocated and
>>  initialized.
>>  In order to make this working, the routine digest_init in c-typeck.cc
>>  is updated to fold calls to .ACCESS_WITH_SIZE to its first argument
>>  when require_constant is TRUE.
>> 
>>  However, for the reference inside "offsetof", the "counted_by" attribute is
>>  ignored since it's not useful at all.
>>  (c_parser_postfix_expression in c/c-parser.cc)
>> 
>>  In addtion to "offsetof", for the reference inside operator "typeof" and
>>  "alignof", we ignore counted_by attribute too.
>> 
>>  When building ADDR_EXPR for the .ACCESS_WITH_SIZE in C FE,
>>  replace the call with its first argument.
>> 
>> * Convert every call to .ACCESS_WITH_SIZE to its first argument.
>>  (expand_ACCESS_WITH_SIZE in internal-fn.cc)
>> * Provide the utility routines to check the call is .ACCESS_WITH_SIZE and
>>  get the reference from the call to .ACCESS_WITH_SIZE.
>>  (is_access_with_size_p and get_ref_from_access_with_size in tree.cc)
> 
> The middle-end parts of this revised patch are OK.

Thanks a lot for the review.
Will commit the patch set soon.

Qing
> 
> Thanks,
> Richard.
> 
>> gcc/c/ChangeLog:
>> 
>> * c-parser.cc (c_parser_postfix_expression): Ignore the counted-by
>> attribute when build_component_ref inside offsetof operator.
>> * c-tree.h (build_component_ref): Add one more parameter.
>> * c-typeck.cc (build_counted_by_ref): New function.
>> (build_access_with_size_for_counted_by): New function.
>> (build_component_ref): Check the counted-by attribute and build
>> call to .ACCESS_WITH_SIZE.
>> (build_unary_op): When building ADDR_EXPR for
>>        .ACCESS_WITH_SIZE, use its first argument.
>>        (lvalue_p): Accept call to .ACCESS_WITH_SIZE.
>> (digest_init): Fold call to .ACCESS_WITH_SIZE to its first
>> argument when require_constant is TRUE.
>> 
>> gcc/ChangeLog:
>> 
>> * internal-fn.cc (expand_ACCESS_WITH_SIZE): New function.
>> * internal-fn.def (ACCESS_WITH_SIZE): New internal function.
>> * tree.cc (is_access_with_size_p): New function.
>> (get_ref_from_access_with_size): New function.
>> * tree.h (is_access_with_size_p): New prototype.
>> (get_ref_from_access_with_size): New prototype.
>> 
>> gcc/testsuite/ChangeLog:
>> 
>> * gcc.dg/flex-array-counted-by-2.c: New test.
>> ---
>> gcc/c/c-parser.cc                             |  10 +-
>> gcc/c/c-tree.h                                |   2 +-
>> gcc/c/c-typeck.cc                             | 142 +++++++++++++++++-
>> gcc/internal-fn.cc                            |  34 +++++
>> gcc/internal-fn.def                           |   5 +
>> .../gcc.dg/flex-array-counted-by-2.c          | 112 ++++++++++++++
>> gcc/tree.cc                                   |  22 +++
>> gcc/tree.h                                    |   8 +
>> 8 files changed, 328 insertions(+), 7 deletions(-)
>> create mode 100644 gcc/testsuite/gcc.dg/flex-array-counted-by-2.c
>> 
>> diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
>> index 00f8bf4376e5..2d9e9c0969f0 100644
>> --- a/gcc/c/c-parser.cc
>> +++ b/gcc/c/c-parser.cc
>> @@ -10848,9 +10848,12 @@ c_parser_postfix_expression (c_parser *parser)
>>     if (c_parser_next_token_is (parser, CPP_NAME))
>>       {
>> c_token *comp_tok = c_parser_peek_token (parser);
>> + /* Ignore the counted_by attribute for reference inside
>> +    offsetof since the information is not useful at all.  */
>> offsetof_ref
>>   = build_component_ref (loc, offsetof_ref, comp_tok->value,
>> -  comp_tok->location, UNKNOWN_LOCATION);
>> +  comp_tok->location, UNKNOWN_LOCATION,
>> +  false);
>> c_parser_consume_token (parser);
>> while (c_parser_next_token_is (parser, CPP_DOT)
>>        || c_parser_next_token_is (parser,
>> @@ -10877,11 +10880,14 @@ c_parser_postfix_expression (c_parser *parser)
>>     break;
>>   }
>> c_token *comp_tok = c_parser_peek_token (parser);
>> + /* Ignore the counted_by attribute for reference inside
>> +    offsetof since the information is not useful.  */
>> offsetof_ref
>>   = build_component_ref (loc, offsetof_ref,
>>  comp_tok->value,
>>  comp_tok->location,
>> -  UNKNOWN_LOCATION);
>> +  UNKNOWN_LOCATION,
>> +  false);
>> c_parser_consume_token (parser);
>>       }
>>     else
>> diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
>> index 531a7e8742e3..56a33b8156c6 100644
>> --- a/gcc/c/c-tree.h
>> +++ b/gcc/c/c-tree.h
>> @@ -779,7 +779,7 @@ extern void mark_exp_read (tree);
>> extern tree composite_type (tree, tree);
>> extern tree lookup_field (const_tree, tree);
>> extern tree build_component_ref (location_t, tree, tree, location_t,
>> -  location_t);
>> +  location_t, bool = true);
>> extern tree build_array_ref (location_t, tree, tree);
>> extern tree build_omp_array_section (location_t, tree, tree, tree);
>> extern tree build_external_ref (location_t, tree, bool, tree *);
>> diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc
>> index 2375953fdb62..0d9c7a34a0df 100644
>> --- a/gcc/c/c-typeck.cc
>> +++ b/gcc/c/c-typeck.cc
>> @@ -2584,15 +2584,116 @@ should_suggest_deref_p (tree datum_type)
>>     return false;
>> }
>> 
>> +/* For a SUBDATUM field of a structure or union DATUM, generate a REF to
>> +   the object that represents its counted_by per the attribute counted_by
>> +   attached to this field if it's a flexible array member field, otherwise
>> +   return NULL_TREE.
>> +   Set COUNTED_BY_TYPE to the TYPE of the counted_by field.
>> +   For example, if:
>> +
>> +    struct P {
>> +      int k;
>> +      int x[] __attribute__ ((counted_by (k)));
>> +    } *p;
>> +
>> +    for:
>> +    p->x
>> +
>> +    the ref to the object that represents its element count will be:
>> +
>> +    &(p->k)
>> +
>> +*/
>> +static tree
>> +build_counted_by_ref (tree datum, tree subdatum, tree *counted_by_type)
>> +{
>> +  tree type = TREE_TYPE (datum);
>> +  if (!c_flexible_array_member_type_p (TREE_TYPE (subdatum)))
>> +    return NULL_TREE;
>> +
>> +  tree attr_counted_by = lookup_attribute ("counted_by",
>> +    DECL_ATTRIBUTES (subdatum));
>> +  tree counted_by_ref = NULL_TREE;
>> +  *counted_by_type = NULL_TREE;
>> +  if (attr_counted_by)
>> +    {
>> +      tree field_id = TREE_VALUE (TREE_VALUE (attr_counted_by));
>> +      counted_by_ref
>> + = build_component_ref (UNKNOWN_LOCATION,
>> +        datum, field_id,
>> +        UNKNOWN_LOCATION, UNKNOWN_LOCATION);
>> +      counted_by_ref = build_fold_addr_expr (counted_by_ref);
>> +
>> +      /* Get the TYPE of the counted_by field.  */
>> +      tree counted_by_field = lookup_field (type, field_id);
>> +      gcc_assert (counted_by_field);
>> +
>> +      do
>> + {
>> +   *counted_by_type = TREE_TYPE (TREE_VALUE (counted_by_field));
>> +   counted_by_field = TREE_CHAIN (counted_by_field);
>> + }
>> +      while (counted_by_field);
>> +    }
>> +  return counted_by_ref;
>> +}
>> +
>> +/* Given a COMPONENT_REF REF with the location LOC, the corresponding
>> +   COUNTED_BY_REF, and the COUNTED_BY_TYPE, generate an INDIRECT_REF
>> +   to a call to the internal function .ACCESS_WITH_SIZE.
>> +
>> +   REF
>> +
>> +   to:
>> +
>> +   (*.ACCESS_WITH_SIZE (REF, COUNTED_BY_REF, 1, (TYPE_OF_SIZE)0, -1))
>> +
>> +   NOTE: The return type of this function is the POINTER type pointing
>> +   to the original flexible array type.
>> +   Then the type of the INDIRECT_REF is the original flexible array type.
>> +
>> +   The type of the first argument of this function is a POINTER type
>> +   to the original flexible array type.
>> +
>> +   The 4th argument of the call is a constant 0 with the TYPE of the
>> +   object pointed by COUNTED_BY_REF.
>> +
>> +  */
>> +static tree
>> +build_access_with_size_for_counted_by (location_t loc, tree ref,
>> +        tree counted_by_ref,
>> +        tree counted_by_type)
>> +{
>> +  gcc_assert (c_flexible_array_member_type_p (TREE_TYPE (ref)));
>> +  /* The result type of the call is a pointer to the flexible array type.  */
>> +  tree result_type = build_pointer_type (TREE_TYPE (ref));
>> +
>> +  tree call
>> +    = build_call_expr_internal_loc (loc, IFN_ACCESS_WITH_SIZE,
>> +     result_type, 5,
>> +     array_to_pointer_conversion (loc, ref),
>> +     counted_by_ref,
>> +     build_int_cst (integer_type_node, 1),
>> +     build_int_cst (counted_by_type, 0),
>> +     build_int_cst (integer_type_node, -1));
>> +  /* Wrap the call with an INDIRECT_REF with the flexible array type.  */
>> +  call = build1 (INDIRECT_REF, TREE_TYPE (ref), call);
>> +  SET_EXPR_LOCATION (call, loc);
>> +  return call;
>> +}
>> +
>> /* Make an expression to refer to the COMPONENT field of structure or
>>    union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  LOC is the
>>    location of the COMPONENT_REF.  COMPONENT_LOC is the location
>>    of COMPONENT.  ARROW_LOC is the location of the first -> operand if
>> -   it is from -> operator.  */
>> +   it is from -> operator.
>> +   If HANDLE_COUNTED_BY is true, check the counted_by attribute and generate
>> +   a call to .ACCESS_WITH_SIZE.  Otherwise, ignore the attribute.  */
>> 
>> tree
>> build_component_ref (location_t loc, tree datum, tree component,
>> -      location_t component_loc, location_t arrow_loc)
>> +      location_t component_loc, location_t arrow_loc,
>> +      bool handle_counted_by)
>> {
>>   tree type = TREE_TYPE (datum);
>>   enum tree_code code = TREE_CODE (type);
>> @@ -2664,7 +2765,13 @@ build_component_ref (location_t loc, tree datum, tree component,
>>   int quals;
>>   tree subtype;
>>   bool use_datum_quals;
>> -
>> +   tree counted_by_type = NULL_TREE;
>> +   /* Do not handle counted_by when in typeof and alignof operator.  */
>> +   handle_counted_by = handle_counted_by && !in_typeof && !in_alignof;
>> +   tree counted_by_ref = handle_counted_by
>> + ? build_counted_by_ref (datum, subdatum,
>> + &counted_by_type)
>> + : NULL_TREE;
>>   if (TREE_TYPE (subdatum) == error_mark_node)
>>     return error_mark_node;
>> 
>> @@ -2683,6 +2790,12 @@ build_component_ref (location_t loc, tree datum, tree component,
>>   ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
>> NULL_TREE);
>>   SET_EXPR_LOCATION (ref, loc);
>> +
>> +   if (counted_by_ref)
>> +     ref = build_access_with_size_for_counted_by (loc, ref,
>> +  counted_by_ref,
>> +  counted_by_type);
>> +
>>   if (TREE_READONLY (subdatum)
>>       || (use_datum_quals && TREE_READONLY (datum)))
>>     TREE_READONLY (ref) = 1;
>> @@ -5087,7 +5200,11 @@ build_unary_op (location_t location, enum tree_code code, tree xarg,
>>   goto return_build_unary_op;
>> }
>> 
>> -      /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
>> +      /* Ordinary case; arg is a COMPONENT_REF or a decl, or a call to
>> +  .ACCESS_WITH_SIZE.  */
>> +      if (is_access_with_size_p (arg))
>> + arg = TREE_OPERAND (TREE_OPERAND (CALL_EXPR_ARG (arg, 0), 0), 0);
>> +
>>       argtype = TREE_TYPE (arg);
>> 
>>       /* If the lvalue is const or volatile, merge that into the type
>> @@ -5238,6 +5355,9 @@ lvalue_p (const_tree ref)
>>     case BIND_EXPR:
>>       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
>> 
>> +    case CALL_EXPR:
>> +      return is_access_with_size_p (ref);
>> +
>>     default:
>>       return false;
>>     }
>> @@ -8525,6 +8645,20 @@ digest_init (location_t init_loc, tree type, tree init, tree origtype,
>> 
>>   STRIP_TYPE_NOPS (inside_init);
>> 
>> +  /* If require_constant is TRUE,  when the initializer is a call to
>> +     .ACCESS_WITH_SIZE, use the first argument as the initializer.
>> +     For example:
>> +     y = (char *) .ACCESS_WITH_SIZE ((char *) &static_annotated.c,...)
>> +     will be converted to
>> +     y = &static_annotated.c.  */
>> +
>> +  if (require_constant
>> +      && TREE_CODE (inside_init) == NOP_EXPR
>> +      && TREE_CODE (TREE_OPERAND (inside_init, 0)) == CALL_EXPR
>> +      && is_access_with_size_p (TREE_OPERAND (inside_init, 0)))
>> +    inside_init
>> +      = get_ref_from_access_with_size (TREE_OPERAND (inside_init, 0));
>> +
>>   if (!c_in_omp_for)
>>     {
>>       if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
>> diff --git a/gcc/internal-fn.cc b/gcc/internal-fn.cc
>> index 9c09026793fa..eb2c4cd59048 100644
>> --- a/gcc/internal-fn.cc
>> +++ b/gcc/internal-fn.cc
>> @@ -3438,6 +3438,40 @@ expand_DEFERRED_INIT (internal_fn, gcall *stmt)
>>     }
>> }
>> 
>> +/* Expand the IFN_ACCESS_WITH_SIZE function:
>> +   ACCESS_WITH_SIZE (REF_TO_OBJ, REF_TO_SIZE, CLASS_OF_SIZE,
>> +      TYPE_OF_SIZE, ACCESS_MODE)
>> +   which returns the REF_TO_OBJ same as the 1st argument;
>> +
>> +   1st argument REF_TO_OBJ: The reference to the object;
>> +   2nd argument REF_TO_SIZE: The reference to the size of the object,
>> +   3rd argument CLASS_OF_SIZE: The size referenced by the REF_TO_SIZE represents
>> +     0: the number of bytes.
>> +     1: the number of the elements of the object type;
>> +   4th argument TYPE_OF_SIZE: A constant 0 with its TYPE being the same as the TYPE
>> +    of the object referenced by REF_TO_SIZE
>> +   5th argument ACCESS_MODE:
>> +    -1: Unknown access semantics
>> +     0: none
>> +     1: read_only
>> +     2: write_only
>> +     3: read_write
>> +
>> +   Both the return type and the type of the first argument of this
>> +   function have been converted from the incomplete array type to
>> +   the corresponding pointer type.
>> +
>> +   For each call to a .ACCESS_WITH_SIZE, replace it with its 1st argument.  */
>> +
>> +static void
>> +expand_ACCESS_WITH_SIZE (internal_fn, gcall *stmt)
>> +{
>> +  tree lhs = gimple_call_lhs (stmt);
>> +  tree ref_to_obj = gimple_call_arg (stmt, 0);
>> +  if (lhs)
>> +    expand_assignment (lhs, ref_to_obj, false);
>> +}
>> +
>> /* The size of an OpenACC compute dimension.  */
>> 
>> static void
>> diff --git a/gcc/internal-fn.def b/gcc/internal-fn.def
>> index 25badbb86e56..8de1fa882e95 100644
>> --- a/gcc/internal-fn.def
>> +++ b/gcc/internal-fn.def
>> @@ -512,6 +512,11 @@ DEF_INTERNAL_FN (PHI, 0, NULL)
>>    automatic variable.  */
>> DEF_INTERNAL_FN (DEFERRED_INIT, ECF_CONST | ECF_LEAF | ECF_NOTHROW, NULL)
>> 
>> +/* A function to associate the access size and access mode information
>> +   with the corresponding reference to an object.  It only reads from the
>> +   2nd argument.  */
>> +DEF_INTERNAL_FN (ACCESS_WITH_SIZE, ECF_PURE | ECF_LEAF | ECF_NOTHROW, NULL)
>> +
>> /* DIM_SIZE and DIM_POS return the size of a particular compute
>>    dimension and the executing thread's position within that
>>    dimension.  DIM_POS is pure (and not const) so that it isn't
>> diff --git a/gcc/testsuite/gcc.dg/flex-array-counted-by-2.c b/gcc/testsuite/gcc.dg/flex-array-counted-by-2.c
>> new file mode 100644
>> index 000000000000..d4899a63af3c
>> --- /dev/null
>> +++ b/gcc/testsuite/gcc.dg/flex-array-counted-by-2.c
>> @@ -0,0 +1,112 @@
>> +/* Test the code generation for the new attribute counted_by.
>> +   And also the offsetof operator on such array.  */
>> +/* { dg-do run } */
>> +/* { dg-options "-O2 -fdump-tree-original" } */
>> +
>> +#include <stdlib.h>
>> +
>> +struct annotated {
>> +  int b;
>> +  char c[] __attribute__ ((counted_by (b)));
>> +} *array_annotated;
>> +
>> +static struct annotated static_annotated = { sizeof "hello", "hello" };
>> +static char *y = static_annotated.c;
>> +
>> +struct flex {
>> +  int b;
>> +  char c[]; 
>> +}; 
>> +
>> +struct nested_annotated {
>> +  struct {
>> +    union {
>> +      int b;
>> +      float f; 
>> +    };
>> +    int n;
>> +  };
>> +  char c[] __attribute__ ((counted_by (b)));
>> +} *array_nested_annotated;
>> +
>> +static struct nested_annotated nested_static_annotated
>> +  = { sizeof "hello1", 0, "hello1" };
>> +static char *nested_y = nested_static_annotated.c;
>> +
>> +struct nested_flex {
>> +  struct {
>> +    union {
>> +      int b;
>> +      float f; 
>> +    };
>> +    int n;
>> +  };
>> +  char c[];
>> +};
>> +
>> +void __attribute__((__noinline__)) setup (int normal_count, int attr_count)
>> +{
>> +  array_annotated
>> +    = (struct annotated *)malloc (sizeof (struct annotated)
>> +   + attr_count *  sizeof (char));
>> +  array_annotated->b = attr_count;
>> +
>> +  array_nested_annotated
>> +    = (struct nested_annotated *)malloc (sizeof (struct nested_annotated)
>> +  + attr_count *  sizeof (char));
>> +  array_nested_annotated->b = attr_count;
>> +
>> +  return;
>> +}
>> +
>> +void __attribute__((__noinline__)) test (char a, char b)
>> +{
>> +  if (__builtin_offsetof (struct annotated, c[0])
>> +      != __builtin_offsetof (struct flex, c[0]))
>> +    abort ();
>> +  if (__builtin_offsetof (struct annotated, c[1])
>> +      != __builtin_offsetof (struct flex, c[1]))
>> +    abort ();
>> +  if (__builtin_offsetof (struct nested_annotated, c[0]) 
>> +      != __builtin_offsetof (struct nested_flex, c[0])) 
>> +    abort ();
>> +  if (__builtin_offsetof (struct nested_annotated, c[1]) 
>> +      != __builtin_offsetof (struct nested_flex, c[1])) 
>> +    abort ();
>> +
>> +  if (__builtin_types_compatible_p (typeof (array_annotated->c),
>> +     typeof (&(array_annotated->c)[0])))
>> +    abort ();
>> +  if (__builtin_types_compatible_p (typeof (array_nested_annotated->c),
>> +     typeof (&(array_nested_annotated->c)[0])))
>> +    abort ();
>> +
>> +  if (__alignof (array_annotated->c) != __alignof (char))
>> +    abort ();
>> +  if (__alignof (array_nested_annotated->c) != __alignof (char))
>> +    abort ();
>> +
>> +  if ((unsigned long) array_annotated->c != (unsigned long) &array_annotated->c)
>> +    abort ();
>> +  if ((unsigned long) array_nested_annotated->c
>> +       != (unsigned long) &array_nested_annotated->c)
>> +    abort ();
>> +
>> +  array_annotated->c[2] = a;
>> +  array_nested_annotated->c[3] = b;
>> +
>> +  if (y[2] != 'l') abort ();
>> +  if (nested_y[4] !='o') abort ();
>> +
>> +}
>> +
>> +int main(int argc, char *argv[])
>> +{
>> +  setup (10,10);   
>> +  test ('A', 'B');
>> +  if (array_annotated->c[2] != 'A') abort ();
>> +  if (array_nested_annotated->c[3] != 'B') abort ();
>> +  return 0;
>> +}
>> +
>> +/* { dg-final { scan-tree-dump-times "ACCESS_WITH_SIZE" 8 "original" } } */
>> diff --git a/gcc/tree.cc b/gcc/tree.cc
>> index 6564b002dc1a..01572fe70f72 100644
>> --- a/gcc/tree.cc
>> +++ b/gcc/tree.cc
>> @@ -13405,6 +13405,28 @@ component_ref_size (tree ref, special_array_member *sam /* = NULL */)
>>   ? NULL_TREE : size_zero_node);
>> }
>> 
>> +/* Return true if the given node CALL is a call to a .ACCESS_WITH_SIZE
>> +   function.  */
>> +bool
>> +is_access_with_size_p (const_tree call)
>> +{
>> +  if (TREE_CODE (call) != CALL_EXPR)
>> +    return false;
>> +  if (CALL_EXPR_IFN (call) == IFN_ACCESS_WITH_SIZE)
>> +    return true;
>> +  return false;
>> +}
>> +
>> +/* Get the corresponding reference from the call to a .ACCESS_WITH_SIZE.
>> + * i.e the first argument of this call.  Return NULL_TREE otherwise.  */
>> +tree
>> +get_ref_from_access_with_size (tree call)
>> +{
>> +  if (is_access_with_size_p (call))
>> +    return  CALL_EXPR_ARG (call, 0);
>> +  return NULL_TREE;
>> +}
>> +
>> /* Return the machine mode of T.  For vectors, returns the mode of the
>>    inner type.  The main use case is to feed the result to HONOR_NANS,
>>    avoiding the BLKmode that a direct TYPE_MODE (T) might return.  */
>> diff --git a/gcc/tree.h b/gcc/tree.h
>> index ee2aae332a41..604885641184 100644
>> --- a/gcc/tree.h
>> +++ b/gcc/tree.h
>> @@ -5772,6 +5772,14 @@ extern special_array_member component_ref_sam_type (tree);
>>    cannot be determined.  */
>> extern tree component_ref_size (tree, special_array_member * = NULL);
>> 
>> +/* Return true if the given node is a call to a .ACCESS_WITH_SIZE
>> +   function.  */
>> +extern bool is_access_with_size_p (const_tree);
>> +
>> +/* Get the corresponding reference from the call to a .ACCESS_WITH_SIZE,
>> + * i.e. the first argument of this call.  Return NULL_TREE otherwise.  */
>> +extern tree get_ref_from_access_with_size (tree);
>> +
>> extern int tree_map_base_eq (const void *, const void *);
>> extern unsigned int tree_map_base_hash (const void *);
>> extern bool tree_map_base_marked_p (const void *);
>> 
> 
> -- 
> Richard Biener <rguenther@suse.de>
> SUSE Software Solutions Germany GmbH,
> Frankenstrasse 146, 90461 Nuernberg, Germany;
> GF: Ivo Totev, Andrew McDonald, Werner Knoblich; (HRB 36809, AG Nuernberg)