LCOV - code coverage report
Current view: top level - gcc - attribs.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 31 31 100.0 %
Date: 2020-03-28 11:57:23 Functions: 5 5 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Declarations and definitions dealing with attribute handling.
       2                 :            :    Copyright (C) 2013-2020 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 init_attributes (void);
      25                 :            : 
      26                 :            : /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
      27                 :            :    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
      28                 :            :    it should be modified in place; if a TYPE, a copy should be created
      29                 :            :    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
      30                 :            :    information, in the form of a bitwise OR of flags in enum attribute_flags
      31                 :            :    from tree.h.  Depending on these flags, some attributes may be
      32                 :            :    returned to be applied at a later stage (for example, to apply
      33                 :            :    a decl attribute to the declaration rather than to its type).  */
      34                 :            : extern tree decl_attributes (tree *, tree, int, tree = NULL_TREE);
      35                 :            : 
      36                 :            : extern bool cxx11_attribute_p (const_tree);
      37                 :            : extern tree get_attribute_name (const_tree);
      38                 :            : extern tree get_attribute_namespace (const_tree);
      39                 :            : extern void apply_tm_attr (tree, tree);
      40                 :            : extern tree make_attribute (const char *, const char *, tree);
      41                 :            : 
      42                 :            : extern struct scoped_attributes* register_scoped_attributes (const struct attribute_spec *,
      43                 :            :                                                              const char *);
      44                 :            : 
      45                 :            : extern char *sorted_attr_string (tree);
      46                 :            : extern bool common_function_versions (tree, tree);
      47                 :            : extern char *make_unique_name (tree, const char *, bool);
      48                 :            : extern tree make_dispatcher_decl (const tree);
      49                 :            : extern bool is_function_default_version (const tree);
      50                 :            : 
      51                 :            : /* Return a type like TTYPE except that its TYPE_ATTRIBUTES
      52                 :            :    is ATTRIBUTE.
      53                 :            : 
      54                 :            :    Such modified types already made are recorded so that duplicates
      55                 :            :    are not made.  */
      56                 :            : 
      57                 :            : extern tree build_type_attribute_variant (tree, tree);
      58                 :            : extern tree build_decl_attribute_variant (tree, tree);
      59                 :            : extern tree build_type_attribute_qual_variant (tree, tree, int);
      60                 :            : 
      61                 :            : extern bool attribute_value_equal (const_tree, const_tree);
      62                 :            : 
      63                 :            : /* Return 0 if the attributes for two types are incompatible, 1 if they
      64                 :            :    are compatible, and 2 if they are nearly compatible (which causes a
      65                 :            :    warning to be generated).  */
      66                 :            : extern int comp_type_attributes (const_tree, const_tree);
      67                 :            : 
      68                 :            : /* Default versions of target-overridable functions.  */
      69                 :            : extern tree merge_decl_attributes (tree, tree);
      70                 :            : extern tree merge_type_attributes (tree, tree);
      71                 :            : 
      72                 :            : /* Remove any instances of attribute ATTR_NAME in LIST and return the
      73                 :            :    modified list.  */
      74                 :            : 
      75                 :            : extern tree remove_attribute (const char *, tree);
      76                 :            : 
      77                 :            : /* Given two attributes lists, return a list of their union.  */
      78                 :            : 
      79                 :            : extern tree merge_attributes (tree, tree);
      80                 :            : 
      81                 :            : /* Duplicate all attributes with name NAME in ATTR list to *ATTRS if
      82                 :            :    they are missing there.  */
      83                 :            : 
      84                 :            : extern void duplicate_one_attribute (tree *, tree, const char *);
      85                 :            : 
      86                 :            : /* Duplicate all attributes from user DECL to the corresponding
      87                 :            :    builtin that should be propagated.  */
      88                 :            : 
      89                 :            : extern void copy_attributes_to_builtin (tree);
      90                 :            : 
      91                 :            : /* Given two Windows decl attributes lists, possibly including
      92                 :            :    dllimport, return a list of their union .  */
      93                 :            : extern tree merge_dllimport_decl_attributes (tree, tree);
      94                 :            : 
      95                 :            : /* Handle a "dllimport" or "dllexport" attribute.  */
      96                 :            : extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
      97                 :            : 
      98                 :            : extern int attribute_list_equal (const_tree, const_tree);
      99                 :            : extern int attribute_list_contained (const_tree, const_tree);
     100                 :            : 
     101                 :            : /* The backbone of lookup_attribute().  ATTR_LEN is the string length
     102                 :            :    of ATTR_NAME, and LIST is not NULL_TREE.
     103                 :            : 
     104                 :            :    The function is called from lookup_attribute in order to optimize
     105                 :            :    for size.  */
     106                 :            : extern tree private_lookup_attribute (const char *attr_name, size_t attr_len,
     107                 :            :                                       tree list);
     108                 :            : 
     109                 :            : extern unsigned decls_mismatched_attributes (tree, tree, tree,
     110                 :            :                                              const char* const[],
     111                 :            :                                              pretty_printer*);
     112                 :            : 
     113                 :            : extern void maybe_diag_alias_attributes (tree, tree);
     114                 :            : 
     115                 :            : /* For a given IDENTIFIER_NODE, strip leading and trailing '_' characters
     116                 :            :    so that we have a canonical form of attribute names.  */
     117                 :            : 
     118                 :            : static inline tree
     119                 :   90895808 : canonicalize_attr_name (tree attr_name)
     120                 :            : {
     121                 :   90895808 :   const size_t l = IDENTIFIER_LENGTH (attr_name);
     122                 :   90895808 :   const char *s = IDENTIFIER_POINTER (attr_name);
     123                 :            : 
     124                 :   90895808 :   if (l > 4 && s[0] == '_' && s[1] == '_' && s[l - 1] == '_' && s[l - 2] == '_')
     125                 :   81619721 :     return get_identifier_with_length (s + 2, l - 4);
     126                 :            : 
     127                 :            :   return attr_name;
     128                 :            : }
     129                 :            : 
     130                 :            : /* Compare attribute identifiers ATTR1 and ATTR2 with length ATTR1_LEN and
     131                 :            :    ATTR2_LEN.  */
     132                 :            : 
     133                 :            : static inline bool
     134                 : 6173207985 : cmp_attribs (const char *attr1, size_t attr1_len,
     135                 :            :              const char *attr2, size_t attr2_len)
     136                 :            : {
     137                 : 6158645425 :   return attr1_len == attr2_len && strncmp (attr1, attr2, attr1_len) == 0;
     138                 :            : }
     139                 :            : 
     140                 :            : /* Compare attribute identifiers ATTR1 and ATTR2.  */
     141                 :            : 
     142                 :            : static inline bool
     143                 :   22394900 : cmp_attribs (const char *attr1, const char *attr2)
     144                 :            : {
     145                 :   22394900 :   return cmp_attribs (attr1, strlen (attr1), attr2, strlen (attr2));
     146                 :            : }
     147                 :            : 
     148                 :            : /* Given an identifier node IDENT and a string ATTR_NAME, return true
     149                 :            :    if the identifier node is a valid attribute name for the string.  */
     150                 :            : 
     151                 :            : static inline bool
     152                 :  808125917 : is_attribute_p (const char *attr_name, const_tree ident)
     153                 :            : {
     154                 :  808125917 :   return cmp_attribs (attr_name, strlen (attr_name),
     155                 :  808125917 :                       IDENTIFIER_POINTER (ident), IDENTIFIER_LENGTH (ident));
     156                 :            : }
     157                 :            : 
     158                 :            : /* Given an attribute name ATTR_NAME and a list of attributes LIST,
     159                 :            :    return a pointer to the attribute's list element if the attribute
     160                 :            :    is part of the list, or NULL_TREE if not found.  If the attribute
     161                 :            :    appears more than once, this only returns the first occurrence; the
     162                 :            :    TREE_CHAIN of the return value should be passed back in if further
     163                 :            :    occurrences are wanted.  ATTR_NAME must be in the form 'text' (not
     164                 :            :    '__text__').  */
     165                 :            : 
     166                 :            : static inline tree
     167                 : 8479219905 : lookup_attribute (const char *attr_name, tree list)
     168                 :            : {
     169                 : 8479219905 :   gcc_checking_assert (attr_name[0] != '_');
     170                 :            :   /* In most cases, list is NULL_TREE.  */
     171                 : 8479219905 :   if (list == NULL_TREE)
     172                 :            :     return NULL_TREE;
     173                 :            :   else
     174                 :            :     {
     175                 : 2573737619 :       size_t attr_len = strlen (attr_name);
     176                 :            :       /* Do the strlen() before calling the out-of-line implementation.
     177                 :            :          In most cases attr_name is a string constant, and the compiler
     178                 :            :          will optimize the strlen() away.  */
     179                 : 2573737619 :       return private_lookup_attribute (attr_name, attr_len, list);
     180                 :            :     }
     181                 :            : }
     182                 :            : 
     183                 :            : /* Given an attribute name ATTR_NAME and a list of attributes LIST,
     184                 :            :    return a pointer to the attribute's list first element if the attribute
     185                 :            :    starts with ATTR_NAME.  ATTR_NAME must be in the form 'text' (not
     186                 :            :    '__text__').  */
     187                 :            : 
     188                 :            : static inline tree
     189                 :    1570440 : lookup_attribute_by_prefix (const char *attr_name, tree list)
     190                 :            : {
     191                 :    1570440 :   gcc_checking_assert (attr_name[0] != '_');
     192                 :            :   /* In most cases, list is NULL_TREE.  */
     193                 :    1570440 :   if (list == NULL_TREE)
     194                 :            :     return NULL_TREE;
     195                 :            :   else
     196                 :            :     {
     197                 :     360611 :       size_t attr_len = strlen (attr_name);
     198                 :     965128 :       while (list)
     199                 :            :         {
     200                 :     619250 :           size_t ident_len = IDENTIFIER_LENGTH (get_attribute_name (list));
     201                 :            : 
     202                 :     619250 :           if (attr_len > ident_len)
     203                 :            :             {
     204                 :       3880 :               list = TREE_CHAIN (list);
     205                 :       3880 :               continue;
     206                 :            :             }
     207                 :            : 
     208                 :     615370 :           const char *p = IDENTIFIER_POINTER (get_attribute_name (list));
     209                 :     615370 :           gcc_checking_assert (attr_len == 0 || p[0] != '_');
     210                 :            : 
     211                 :     615370 :           if (strncmp (attr_name, p, attr_len) == 0)
     212                 :            :             break;
     213                 :            : 
     214                 :     600637 :           list = TREE_CHAIN (list);
     215                 :            :         }
     216                 :            : 
     217                 :     360611 :       return list;
     218                 :            :     }
     219                 :            : }
     220                 :            : 
     221                 :            : /* Description of a function argument declared with attribute access.
     222                 :            :    Used as an "iterator" over all such arguments in a function declaration
     223                 :            :    or call.  */
     224                 :            : 
     225                 :            : struct attr_access
     226                 :            : {
     227                 :            :   /* The attribute pointer argument.  */
     228                 :            :   tree ptr;
     229                 :            :   /* The size of the pointed-to object or NULL when not specified.  */
     230                 :            :   tree size;
     231                 :            : 
     232                 :            :   /* The zero-based number of each of the formal function arguments.  */
     233                 :            :   unsigned ptrarg;
     234                 :            :   unsigned sizarg;
     235                 :            : 
     236                 :            :   /* The access mode.  */
     237                 :            :   enum access_mode { read_only, write_only, read_write };
     238                 :            :   access_mode mode;
     239                 :            : };
     240                 :            : 
     241                 :            : #endif // GCC_ATTRIBS_H

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.