diff options
Diffstat (limited to 'lib/gcc/arm-none-eabi/13.2.1/plugin/include/pointer-query.h')
| -rw-r--r-- | lib/gcc/arm-none-eabi/13.2.1/plugin/include/pointer-query.h | 297 |
1 files changed, 297 insertions, 0 deletions
diff --git a/lib/gcc/arm-none-eabi/13.2.1/plugin/include/pointer-query.h b/lib/gcc/arm-none-eabi/13.2.1/plugin/include/pointer-query.h new file mode 100644 index 0000000..2522ac9 --- /dev/null +++ b/lib/gcc/arm-none-eabi/13.2.1/plugin/include/pointer-query.h @@ -0,0 +1,297 @@ +/* Definitions of the pointer_query and related classes. + + Copyright (C) 2020-2023 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 |