pointer-query.h

Go to the documentation of this file.

/* Definitions of the pointer_query and related classes.
 
   Copyright (C) 2020-2024 Free Software Foundation, Inc.
 
   This file is part of GCC.
 
   GCC is free software; you can redistribute it and/or modify it under
   the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 3, or (at your option) any later
   version.
 
   GCC is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   for more details.
 
   You should have received a copy of the GNU General Public License
   along with GCC; see the file COPYING3.  If not see
   <http://www.gnu.org/licenses/>.  */
 
#ifndef GCC_POINTER_QUERY_H
#define GCC_POINTER_QUERY_H
 
/* Describes recursion limits used by functions that follow use-def
   chains of SSA_NAMEs.  */
 
class ssa_name_limit_t
{
  bitmap visited;         /* Bitmap of visited SSA_NAMEs.  */
  unsigned ssa_def_max;   /* Longest chain of SSA_NAMEs to follow.  */
 
  /* Not copyable or assignable.  */
  DISABLE_COPY_AND_ASSIGN (ssa_name_limit_t);
 
public:
 
  ssa_name_limit_t ()
    : visited (),
      ssa_def_max (param_ssa_name_def_chain_limit) { }
 
  /* Set a bit for the PHI in VISITED and return true if it wasn't
     already set.  */
  bool visit_phi (tree);
  /* Clear a bit for the PHI in VISITED.  */
  void leave_phi (tree);
  /* Return false if the SSA_NAME chain length counter has reached
     the limit, otherwise increment the counter and return true.  */
  bool next ();
 
  /* If the SSA_NAME has already been "seen" return a positive value.
     Otherwise add it to VISITED.  If the SSA_NAME limit has been
     reached, return a negative value.  Otherwise return zero.  */
  int next_phi (tree);
 
  ~ssa_name_limit_t ();
};
 
class pointer_query;
 
/* Describes a reference to an object used in an access.  */
struct access_ref
{
  /* Set the bounds of the reference.  */
  access_ref ();
 
  /* Return the PHI node REF refers to or null if it doesn't.  */
  gphi *phi () const;
 
  /* Merge the result for a pointer with *THIS.  */
  void merge_ref (vec<access_ref> *all_refs, tree, gimple *, int, bool,
                  ssa_name_limit_t &, pointer_query &);
 
  /* Return the object to which REF refers.  */
  tree get_ref (vec<access_ref> *, access_ref * = nullptr, int = 1,
                ssa_name_limit_t * = nullptr, pointer_query * = nullptr) const;
 
  /* Return true if OFFRNG is the constant zero.  */
  bool offset_zero () const
  {
    return offrng[0] == 0 && offrng[1] == 0;
  }
 
  /* Return true if OFFRNG is bounded to a subrange of offset values
     valid for the largest possible object.  */
  bool offset_bounded () const;
 
  /* Return the maximum amount of space remaining and if non-null, set
     argument to the minimum.  */
  offset_int size_remaining (offset_int * = nullptr) const;
 
  /* Return true if the offset and object size are in range for SIZE.  */
  bool offset_in_range (const offset_int &) const;
 
  /* Return true if *THIS is an access to a declared object.  */
  bool ref_declared () const
  {
    return DECL_P (ref) && base0 && deref < 1;
  }
 
  /* Set the size range to the maximum.  */
  void set_max_size_range ()
  {
    sizrng[0] = 0;
    sizrng[1] = wi::to_offset (max_object_size ());
  }
 
  /* Add OFF to the offset range.  */
  void add_offset (const offset_int &off)
  {
    add_offset (off, off);
  }
 
  /* Add the range [MIN, MAX] to the offset range.  */
  void add_offset (const offset_int &, const offset_int &);
 
  /* Add the maximum representable offset to the offset range.  */
  void add_max_offset ()
  {
    offset_int maxoff = wi::to_offset (TYPE_MAX_VALUE (ptrdiff_type_node));
    add_offset (-maxoff - 1, maxoff);
  }
 
  /* Issue an informational message describing the target of an access
     with the given mode.  */
  void inform_access (access_mode, int = 1) const;
 
  /* Dump *THIS to a file.  */
  void dump (FILE *) const;
 
  /* Reference to the accessed object(s).  */
  tree ref;
 
  /* Range of byte offsets into and sizes of the object(s).  */
  offset_int offrng[2];
  offset_int sizrng[2];
  /* The minimum and maximum offset computed.  */
  offset_int offmax[2];
 
  /* Used to fold integer expressions when called from front ends.  */
  tree (*eval)(tree);
  /* Positive when REF is dereferenced, negative when its address is
     taken.  */
  int deref;
  /* The following indicates if heuristics interpreted 'ref' is interpreted
     as (offsetted) nullptr.  */
  bool ref_nullptr_p;
  /* Set if trailing one-element arrays should be treated as flexible
     array members.  */
  bool trail1special;
  /* Set if valid offsets must start at zero (for declared and allocated
     objects but not for others referenced by pointers).  */
  bool base0;
  /* Set if REF refers to a function array parameter not declared
     static.  */
  bool parmarray;
};
 
class range_query;
 
/* Queries and caches compute_objsize results.  */
class pointer_query
{
  DISABLE_COPY_AND_ASSIGN (pointer_query);
 
  /* Type of the two-level cache object defined by clients of the class
     to have pointer SSA_NAMEs cached for speedy access.  */
  struct cache_type
  {
    /* 1-based indices into cache.  */
    auto_vec<unsigned> indices;
    /* The cache itself.  */
    auto_vec<access_ref> access_refs;
  };
 
public:
  /* Construct an object with the given Ranger instance.  */
  explicit pointer_query (range_query * = nullptr);
 
  /* Retrieve the access_ref for a variable from cache if it's there.  */
  const access_ref* get_ref (tree, int = 1) const;
 
  /* Retrieve the access_ref for a variable from cache or compute it.  */
  bool get_ref (tree, gimple *, access_ref*, int = 1);
 
  /* Add an access_ref for the SSA_NAME to the cache.  */
  void put_ref (tree, const access_ref&, int = 1);
 
  /* Flush the cache.  */
  void flush_cache ();
 
  /* Dump statistics and optionally cache contents to DUMP_FILE.  */
  void dump (FILE *, bool = false);
 
  /* A Ranger instance.  May be null to use global ranges.  */
  range_query *rvals;
 
  /* Cache performance counters.  */
  mutable unsigned hits;
  mutable unsigned misses;
  mutable unsigned failures;
  mutable unsigned depth;
  mutable unsigned max_depth;
 
private:
  /* Cache of SSA_NAMEs.  May be null to disable caching.  */
  cache_type var_cache;
};
 
/* Describes a pair of references used in an access by built-in
   functions like memcpy.  */
struct access_data
{
  /* Set the access to at most MAXWRITE and MAXREAD bytes, and
     at least 1 when MINWRITE or MINREAD, respectively, is set.  */
  access_data (range_query *, gimple *, access_mode,
               tree = NULL_TREE, bool = false,
               tree = NULL_TREE, bool = false);
 
  /* Set the access to at most MAXWRITE and MAXREAD bytes, and
     at least 1 when MINWRITE or MINREAD, respectively, is set.  */
  access_data (range_query *, tree, access_mode,
               tree = NULL_TREE, bool = false,
               tree = NULL_TREE, bool = false);
 
  /* Constructor helper.  */
  static void set_bound (offset_int[2], tree, bool, range_query *, gimple *);
 
  /* Access statement.  */
  gimple *stmt;
  /* Built-in function call.  */
  tree call;
  /* Destination and source of the access.  */
  access_ref dst, src;
 
  /* Range of the bound of the access: denotes that the access is at
     least XXX_BNDRNG[0] bytes but no more than XXX_BNDRNG[1].  For
     string functions the size of the actual access is further
     constrained by the length of the string.  */
  offset_int dst_bndrng[2];
  offset_int src_bndrng[2];
 
  /* Read-only for functions like memcmp or strlen, write-only
     for memset, read-write for memcpy or strcat.  */
  access_mode mode;
  /* The object size type.  */
  int ostype;
};
 
enum size_range_flags
  {
   /* Set to consider zero a valid range.  */
   SR_ALLOW_ZERO = 1,
   /* Set to use the largest subrange of a set of ranges as opposed
      to the smallest.  */
   SR_USE_LARGEST = 2
  };
extern bool get_size_range (tree, tree[2], int = 0);
extern bool get_size_range (range_query *, tree, gimple *, tree[2], int = 0);
 
class range_query;
extern tree gimple_call_alloc_size (gimple *, wide_int[2] = nullptr,
                                    range_query * = nullptr);
 
/* Compute the size of an object referenced by the first argument in
   a statement given by second argument, using Object Size Type given
   by third argument.  Store result in an access_ref.  */
extern tree compute_objsize (tree, gimple *, int, access_ref *,
                             range_query * = nullptr);
extern tree compute_objsize (tree, gimple *, int, access_ref *,
                             pointer_query *);
inline tree compute_objsize (tree ptr, int ostype, access_ref *pref)
{
  return compute_objsize (ptr, nullptr, ostype, pref, (range_query *)nullptr);
}
 
/* Legacy/transitional API.  Should not be used in new code.  */
extern tree compute_objsize (tree, gimple *, int, tree * = nullptr,
                             tree * = nullptr, range_query * = nullptr);
inline tree compute_objsize (tree ptr, int ostype, tree *pdecl = nullptr,
                             tree *poff = nullptr, range_query *rvals = nullptr)
{
  return compute_objsize (ptr, nullptr, ostype, pdecl, poff, rvals);
}
 
/* Return the field at the constant offset.  */
extern tree field_at_offset (tree, tree, HOST_WIDE_INT,
                             HOST_WIDE_INT * = nullptr,
                             HOST_WIDE_INT * = nullptr);
/* Return the array at the constant offset.  */
extern tree array_elt_at_offset (tree, HOST_WIDE_INT,
                                 HOST_WIDE_INT * = nullptr,
                                 HOST_WIDE_INT * = nullptr);
 
/* Helper to build an array type that can be printed.  */
extern tree build_printable_array_type (tree, unsigned HOST_WIDE_INT);
 
#endif   // GCC_POINTER_QUERY_H