sdcc/support/cpp/gcc/attribs.h

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