gcc/attribs.h

   1 /* Declarations and definitions dealing with attribute handling.
   2    Copyright (C) 2013-2021 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_ATTRIBS_H
  21 #define GCC_ATTRIBS_H
  22
  23 extern const struct attribute_spec *lookup_attribute_spec (const_tree);
  24 extern void free_attr_data ();
  25 extern void init_attributes (void);
  26
  27 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
  28    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
  29    it should be modified in place; if a TYPE, a copy should be created
  30    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
  31    information, in the form of a bitwise OR of flags in enum attribute_flags
  32    from tree.h.  Depending on these flags, some attributes may be
  33    returned to be applied at a later stage (for example, to apply
  34    a decl attribute to the declaration rather than to its type).  */
  35 extern tree decl_attributes (tree *, tree, int, tree = NULL_TREE);
  36
  37 extern bool cxx11_attribute_p (const_tree);
  38 extern tree get_attribute_name (const_tree);
  39 extern tree get_attribute_namespace (const_tree);
  40 extern void apply_tm_attr (tree, tree);
  41 extern tree make_attribute (const char *, const char *, tree);
  42
  43 extern struct scoped_attributes* register_scoped_attributes (const struct attribute_spec *,
  44                                                              const char *,
  45                                                              bool = false);
  46
  47 extern char *sorted_attr_string (tree);
  48 extern bool common_function_versions (tree, tree);
  49 extern tree make_dispatcher_decl (const tree);
  50 extern bool is_function_default_version (const tree);
  51 extern void handle_ignored_attributes_option (vec<char *> *);
  52
  53 /* Return a type like TTYPE except that its TYPE_ATTRIBUTES
  54    is ATTRIBUTE.
  55
  56    Such modified types already made are recorded so that duplicates
  57    are not made.  */
  58
  59 extern tree build_type_attribute_variant (tree, tree);
  60 extern tree build_decl_attribute_variant (tree, tree);
  61 extern tree build_type_attribute_qual_variant (tree, tree, int);
  62
  63 extern bool simple_cst_list_equal (const_tree, const_tree);
  64 extern bool attribute_value_equal (const_tree, const_tree);
  65
  66 /* Return 0 if the attributes for two types are incompatible, 1 if they
  67    are compatible, and 2 if they are nearly compatible (which causes a
  68    warning to be generated).  */
  69 extern int comp_type_attributes (const_tree, const_tree);
  70
  71 extern tree affects_type_identity_attributes (tree, bool = true);
  72 extern tree restrict_type_identity_attributes_to (tree, tree);
  73
  74 /* Default versions of target-overridable functions.  */
  75 extern tree merge_decl_attributes (tree, tree);
  76 extern tree merge_type_attributes (tree, tree);
  77
  78 /* Remove any instances of attribute ATTR_NAME in LIST and return the
  79    modified list.  */
  80
  81 extern tree remove_attribute (const char *, tree);
  82
  83 /* Given two attributes lists, return a list of their union.  */
  84
  85 extern tree merge_attributes (tree, tree);
  86
  87 /* Duplicate all attributes with name NAME in ATTR list to *ATTRS if
  88    they are missing there.  */
  89
  90 extern void duplicate_one_attribute (tree *, tree, const char *);
  91
  92 /* Duplicate all attributes from user DECL to the corresponding
  93    builtin that should be propagated.  */
  94
  95 extern void copy_attributes_to_builtin (tree);
  96
  97 /* Given two Windows decl attributes lists, possibly including
  98    dllimport, return a list of their union .  */
  99 extern tree merge_dllimport_decl_attributes (tree, tree);
 100
 101 /* Handle a "dllimport" or "dllexport" attribute.  */
 102 extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
 103
 104 extern int attribute_list_equal (const_tree, const_tree);
 105 extern int attribute_list_contained (const_tree, const_tree);
 106
 107 /* The backbone of lookup_attribute().  ATTR_LEN is the string length
 108    of ATTR_NAME, and LIST is not NULL_TREE.
 109
 110    The function is called from lookup_attribute in order to optimize
 111    for size.  */
 112 extern tree private_lookup_attribute (const char *attr_name, size_t attr_len,
 113                                       tree list);
 114
 115 extern unsigned decls_mismatched_attributes (tree, tree, tree,
 116                                              const char* const[],
 117                                              pretty_printer*);
 118
 119 extern void maybe_diag_alias_attributes (tree, tree);
 120
 121 /* For a given string S of length L, strip leading and trailing '_' characters
 122    so that we have a canonical form of attribute names.  NB: This function may
 123    change S and L.  */
 124
 125 template <typename T>
 126 inline bool
 127 canonicalize_attr_name (const char *&s, T &l)
 128 {
 129   if (l > 4 && s[0] == '_' && s[1] == '_' && s[l - 1] == '_' && s[l - 2] == '_')
 130     {
 131       s += 2;
 132       l -= 4;
 133       return true;
 134     }
 135   return false;
 136 }
 137
 138 /* For a given IDENTIFIER_NODE, strip leading and trailing '_' characters
 139    so that we have a canonical form of attribute names.  */
 140
 141 static inline tree
 142 canonicalize_attr_name (tree attr_name)
 143 {
 144   size_t l = IDENTIFIER_LENGTH (attr_name);
 145   const char *s = IDENTIFIER_POINTER (attr_name);
 146
 147   if (canonicalize_attr_name (s, l))
 148     return get_identifier_with_length (s, l);
 149
 150   return attr_name;
 151 }
 152
 153 /* Compare attribute identifiers ATTR1 and ATTR2 with length ATTR1_LEN and
 154    ATTR2_LEN.  */
 155
 156 static inline bool
 157 cmp_attribs (const char *attr1, size_t attr1_len,
 158              const char *attr2, size_t attr2_len)
 159 {
 160   return attr1_len == attr2_len && strncmp (attr1, attr2, attr1_len) == 0;
 161 }
 162
 163 /* Compare attribute identifiers ATTR1 and ATTR2.  */
 164
 165 static inline bool
 166 cmp_attribs (const char *attr1, const char *attr2)
 167 {
 168   return cmp_attribs (attr1, strlen (attr1), attr2, strlen (attr2));
 169 }
 170
 171 /* Given an identifier node IDENT and a string ATTR_NAME, return true
 172    if the identifier node is a valid attribute name for the string.  */
 173
 174 static inline bool
 175 is_attribute_p (const char *attr_name, const_tree ident)
 176 {
 177   return cmp_attribs (attr_name, strlen (attr_name),
 178                       IDENTIFIER_POINTER (ident), IDENTIFIER_LENGTH (ident));
 179 }
 180
 181 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
 182    return a pointer to the attribute's list element if the attribute
 183    is part of the list, or NULL_TREE if not found.  If the attribute
 184    appears more than once, this only returns the first occurrence; the
 185    TREE_CHAIN of the return value should be passed back in if further
 186    occurrences are wanted.  ATTR_NAME must be in the form 'text' (not
 187    '__text__').  */
 188
 189 static inline tree
 190 lookup_attribute (const char *attr_name, tree list)
 191 {
 192   if (CHECKING_P && attr_name[0] != '_')
 193     {
 194       size_t attr_len = strlen (attr_name);
 195       gcc_checking_assert (!canonicalize_attr_name (attr_name, attr_len));
 196     }
 197   /* In most cases, list is NULL_TREE.  */
 198   if (list == NULL_TREE)
 199     return NULL_TREE;
 200   else
 201     {
 202       size_t attr_len = strlen (attr_name);
 203       /* Do the strlen() before calling the out-of-line implementation.
 204          In most cases attr_name is a string constant, and the compiler
 205          will optimize the strlen() away.  */
 206       return private_lookup_attribute (attr_name, attr_len, list);
 207     }
 208 }
 209
 210 /* Given an attribute name ATTR_NAME and a list of attributes LIST,
 211    return a pointer to the attribute's list first element if the attribute
 212    starts with ATTR_NAME.  ATTR_NAME must be in the form 'text' (not
 213    '__text__').  */
 214
 215 static inline tree
 216 lookup_attribute_by_prefix (const char *attr_name, tree list)
 217 {
 218   gcc_checking_assert (attr_name[0] != '_');
 219   /* In most cases, list is NULL_TREE.  */
 220   if (list == NULL_TREE)
 221     return NULL_TREE;
 222   else
 223     {
 224       size_t attr_len = strlen (attr_name);
 225       while (list)
 226         {
 227           tree name = get_attribute_name (list);
 228           size_t ident_len = IDENTIFIER_LENGTH (name);
 229
 230           if (attr_len > ident_len)
 231             {
 232               list = TREE_CHAIN (list);
 233               continue;
 234             }
 235
 236           const char *p = IDENTIFIER_POINTER (name);
 237           gcc_checking_assert (attr_len == 0 || p[0] != '_');
 238
 239           if (strncmp (attr_name, p, attr_len) == 0)
 240             break;
 241
 242           list = TREE_CHAIN (list);
 243         }
 244
 245       return list;
 246     }
 247 }
 248
 249 /* Description of a function argument declared with attribute access.
 250    Used as an "iterator" over all such arguments in a function declaration
 251    or call.  */
 252
 253 struct attr_access
 254 {
 255   /* The beginning and end of the internal string representation.  */
 256   const char *str, *end;
 257   /* The attribute pointer argument.  */
 258   tree ptr;
 259   /* For a declaration, a TREE_CHAIN of VLA bound expressions stored
 260      in TREE_VALUE and their positions in the argument list (stored
 261      in TREE_PURPOSE).  Each expression may be a PARM_DECL or some
 262      other DECL (for ordinary variables), or an EXPR for other
 263      expressions (e.g., funcion calls).  */
 264   tree size;
 265
 266   /* The zero-based position of each of the formal function arguments.
 267      For the optional SIZARG, UINT_MAX when not specified.  For VLAs
 268      with multiple variable bounds, SIZARG is the position corresponding
 269      to the most significant bound in the argument list.  Positions of
 270      subsequent bounds are in the TREE_PURPOSE field of the SIZE chain.  */
 271   unsigned ptrarg;
 272   unsigned sizarg;
 273   /* For internal specifications only, the constant minimum size of
 274      the array, zero if not specified, and HWI_M1U for the unspecified
 275      VLA [*] notation.  Meaningless for external (explicit) access
 276      specifications.  */
 277   unsigned HOST_WIDE_INT minsize;
 278
 279   /* The access mode.  */
 280   access_mode mode;
 281
 282   /* Set for an attribute added internally rather than by an explicit
 283      declaration. */
 284   bool internal_p;
 285   /* Set for the T[static MINSIZE] array notation for nonzero MINSIZE
 286      less than HWI_M1U.  */
 287   bool static_p;
 288
 289   /* Return the number of specified VLA bounds.  */
 290   unsigned vla_bounds (unsigned *) const;
 291
 292   /* Return internal representation as STRING_CST.  */
 293   tree to_internal_string () const;
 294
 295   /* Return the human-readable representation of the external attribute
 296      specification (as it might appear in the source code) as STRING_CST.  */
 297   tree to_external_string () const;
 298
 299   /* Return argument of array type formatted as a readable string.  */
 300   std::string array_as_string (tree) const;
 301
 302   /* Return the access mode corresponding to the character code.  */
 303   static access_mode from_mode_char (char);
 304
 305   /* Reset front end-specific attribute access data from attributes.  */
 306   static void free_lang_data (tree);
 307
 308   /* The character codes corresponding to all the access modes.  */
 309   static constexpr char mode_chars[5] = { '-', 'r', 'w', 'x', '^' };
 310
 311   /* The strings corresponding to just the external access modes.  */
 312   static constexpr char mode_names[4][11] =
 313     {
 314      "none", "read_only", "write_only", "read_write"
 315     };
 316 };
 317
 318 inline access_mode
 319 attr_access::from_mode_char (char c)
 320 {
 321   switch (c)
 322     {
 323     case mode_chars[access_none]: return access_none;
 324     case mode_chars[access_read_only]: return access_read_only;
 325     case mode_chars[access_write_only]: return access_write_only;
 326     case mode_chars[access_read_write]: return access_read_write;
 327     case mode_chars[access_deferred]: return access_deferred;
 328     }
 329   gcc_unreachable ();
 330 }
 331
 332 /* Used to define rdwr_map below.  */
 333 struct rdwr_access_hash: int_hash<int, -1> { };
 334
 335 /* A mapping between argument number corresponding to attribute access
 336    mode (read_only, write_only, or read_write) and operands.  */
 337 struct attr_access;
 338 typedef hash_map<rdwr_access_hash, attr_access> rdwr_map;
 339
 340 extern void init_attr_rdwr_indices (rdwr_map *, tree);
 341 extern attr_access *get_parm_access (rdwr_map &, tree,
 342                                      tree = current_function_decl);
 343
 344 #endif // GCC_ATTRIBS_H