LCOV - code coverage report
Current view: top level - gcc/fortran - constructor.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 106 110 96.4 %
Date: 2020-03-28 11:57:23 Functions: 17 19 89.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Array and structure constructors
       2                 :            :    Copyright (C) 2009-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                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "gfortran.h"
      24                 :            : #include "constructor.h"
      25                 :            : 
      26                 :            : 
      27                 :            : static void
      28                 :    2446220 : node_free (splay_tree_value value)
      29                 :            : {
      30                 :    2446220 :   gfc_constructor *c = (gfc_constructor*)value;
      31                 :            : 
      32                 :    2446220 :   if (c->expr)
      33                 :    2406560 :     gfc_free_expr (c->expr);
      34                 :            : 
      35                 :    2446220 :   if (c->iterator)
      36                 :       5596 :     gfc_free_iterator (c->iterator, 1);
      37                 :            : 
      38                 :    2446220 :   mpz_clear (c->offset);
      39                 :    2446220 :   mpz_clear (c->repeat);
      40                 :            : 
      41                 :    2446220 :   free (c);
      42                 :    2446220 : }
      43                 :            : 
      44                 :            : 
      45                 :            : static gfc_constructor *
      46                 :    1123670 : node_copy (splay_tree_node node, void *base)
      47                 :            : {
      48                 :    1123670 :   gfc_constructor *c, *src = (gfc_constructor*)node->value;
      49                 :            : 
      50                 :    1123670 :   c = XCNEW (gfc_constructor);
      51                 :    1123670 :   c->base = (gfc_constructor_base)base;
      52                 :    1123670 :   c->expr = gfc_copy_expr (src->expr);
      53                 :    1123670 :   c->iterator = gfc_copy_iterator (src->iterator);
      54                 :    1123670 :   c->where = src->where;
      55                 :    1123670 :   c->n.component = src->n.component;
      56                 :            : 
      57                 :    1123670 :   mpz_init_set (c->offset, src->offset);
      58                 :    1123670 :   mpz_init_set (c->repeat, src->repeat);
      59                 :            : 
      60                 :    1123670 :   return c;
      61                 :            : }
      62                 :            : 
      63                 :            : 
      64                 :            : static int
      65                 :    1123670 : node_copy_and_insert (splay_tree_node node, void *base)
      66                 :            : {
      67                 :    1123670 :   int n = mpz_get_si (((gfc_constructor*)node->value)->offset);
      68                 :    1123670 :   gfc_constructor_insert ((gfc_constructor_base*)base,
      69                 :            :                           node_copy (node, base), n);
      70                 :    1123670 :   return 0;
      71                 :            : }
      72                 :            : 
      73                 :            : 
      74                 :            : gfc_constructor *
      75                 :    1346460 : gfc_constructor_get (void)
      76                 :            : {
      77                 :    1346460 :   gfc_constructor *c = XCNEW (gfc_constructor);
      78                 :    1346460 :   c->base = NULL;
      79                 :    1346460 :   c->expr = NULL;
      80                 :    1346460 :   c->iterator = NULL;
      81                 :            : 
      82                 :    1346460 :   mpz_init_set_si (c->offset, 0);
      83                 :    1346460 :   mpz_init_set_si (c->repeat, 1);
      84                 :            : 
      85                 :    1346460 :   return c;
      86                 :            : }
      87                 :            : 
      88                 :      61893 : gfc_constructor_base gfc_constructor_get_base (void)
      89                 :            : {
      90                 :      61893 :   return splay_tree_new (splay_tree_compare_ints, NULL, node_free);
      91                 :            : }
      92                 :            : 
      93                 :            : 
      94                 :            : gfc_constructor_base
      95                 :      62186 : gfc_constructor_copy (gfc_constructor_base base)
      96                 :            : {
      97                 :      62186 :   gfc_constructor_base new_base;
      98                 :            : 
      99                 :      62186 :   if (!base)
     100                 :            :     return NULL;
     101                 :            : 
     102                 :      61893 :   new_base = gfc_constructor_get_base ();
     103                 :      61893 :   splay_tree_foreach (base, node_copy_and_insert, &new_base);
     104                 :            : 
     105                 :      61893 :   return new_base;
     106                 :            : }
     107                 :            : 
     108                 :            : 
     109                 :            : void
     110                 :     249385 : gfc_constructor_free (gfc_constructor_base base)
     111                 :            : {
     112                 :     249385 :   if (base)
     113                 :     246483 :     splay_tree_delete (base);
     114                 :     249385 : }
     115                 :            : 
     116                 :            : 
     117                 :            : gfc_constructor *
     118                 :    1338360 : gfc_constructor_append (gfc_constructor_base *base, gfc_constructor *c)
     119                 :            : {
     120                 :    1338360 :   int offset = 0;
     121                 :    1338360 :   if (*base)
     122                 :    1147430 :     offset = (int)(splay_tree_max (*base)->key) + 1;
     123                 :            : 
     124                 :    1338360 :   return gfc_constructor_insert (base, c, offset);
     125                 :            : }
     126                 :            : 
     127                 :            : 
     128                 :            : gfc_constructor *
     129                 :    1217330 : gfc_constructor_append_expr (gfc_constructor_base *base,
     130                 :            :                              gfc_expr *e, locus *where)
     131                 :            : {
     132                 :    1217330 :   gfc_constructor *c = gfc_constructor_get ();
     133                 :    1217330 :   c->expr = e;
     134                 :    1217330 :   if (where)
     135                 :    1180640 :     c->where = *where;
     136                 :            : 
     137                 :    1217330 :   return gfc_constructor_append (base, c);
     138                 :            : }
     139                 :            : 
     140                 :            : 
     141                 :            : gfc_constructor *
     142                 :    2470130 : gfc_constructor_insert (gfc_constructor_base *base, gfc_constructor *c, int n)
     143                 :            : {
     144                 :    2470130 :   splay_tree_node node;
     145                 :            : 
     146                 :    2470130 :   if (*base == NULL)
     147                 :     191978 :     *base = splay_tree_new (splay_tree_compare_ints, NULL, node_free);
     148                 :            : 
     149                 :    2470130 :   c->base = *base;
     150                 :    2470130 :   mpz_set_si (c->offset, n);
     151                 :            : 
     152                 :    2470130 :   node = splay_tree_insert (*base, (splay_tree_key) n, (splay_tree_value) c);
     153                 :    2470130 :   gcc_assert (node);
     154                 :            : 
     155                 :    2470130 :   return (gfc_constructor*)node->value;
     156                 :            : }
     157                 :            : 
     158                 :            : 
     159                 :            : gfc_constructor *
     160                 :       8109 : gfc_constructor_insert_expr (gfc_constructor_base *base,
     161                 :            :                              gfc_expr *e, locus *where, int n)
     162                 :            : {
     163                 :       8109 :   gfc_constructor *c = gfc_constructor_get ();
     164                 :       8109 :   c->expr = e;
     165                 :       8109 :   if (where)
     166                 :       7585 :     c->where = *where;
     167                 :            : 
     168                 :       8109 :   return gfc_constructor_insert (base, c, n);
     169                 :            : }
     170                 :            : 
     171                 :            : 
     172                 :            : gfc_constructor *
     173                 :      71634 : gfc_constructor_lookup (gfc_constructor_base base, int offset)
     174                 :            : {
     175                 :      71634 :   gfc_constructor *c;
     176                 :      71634 :   splay_tree_node node;
     177                 :            : 
     178                 :      71634 :   if (!base)
     179                 :            :     return NULL;
     180                 :            : 
     181                 :      70650 :   node = splay_tree_lookup (base, (splay_tree_key) offset);
     182                 :      70650 :   if (node)
     183                 :      60689 :     return (gfc_constructor *) node->value;
     184                 :            : 
     185                 :            :   /* Check if the previous node has a repeat count big enough to
     186                 :            :      cover the offset looked for.  */
     187                 :       9961 :   node = splay_tree_predecessor (base, (splay_tree_key) offset);
     188                 :       9961 :   if (!node)
     189                 :            :     return NULL;
     190                 :            : 
     191                 :       9782 :   c = (gfc_constructor *) node->value;
     192                 :       9782 :   if (mpz_cmp_si (c->repeat, 1) > 0)
     193                 :            :     {
     194                 :         29 :       if (mpz_get_si (c->offset) + mpz_get_si (c->repeat) <= offset)
     195                 :         20 :         c = NULL;
     196                 :            :     }
     197                 :            :   else
     198                 :            :     c = NULL;
     199                 :            : 
     200                 :            :   return c;
     201                 :            : }
     202                 :            : 
     203                 :            : 
     204                 :            : gfc_expr *
     205                 :      61477 : gfc_constructor_lookup_expr (gfc_constructor_base base, int offset)
     206                 :            : {
     207                 :      61477 :   gfc_constructor *c = gfc_constructor_lookup (base, offset);
     208                 :      61477 :   return c ? c->expr : NULL;
     209                 :            : }
     210                 :            : 
     211                 :            : 
     212                 :            : int
     213                 :          0 : gfc_constructor_expr_foreach (gfc_constructor *ctor ATTRIBUTE_UNUSED,
     214                 :            :                               int(*f)(gfc_expr *) ATTRIBUTE_UNUSED)
     215                 :            : {
     216                 :          0 :   gcc_assert (0);
     217                 :            :   return 0;
     218                 :            : }
     219                 :            : 
     220                 :            : void
     221                 :          0 : gfc_constructor_swap (gfc_constructor *ctor ATTRIBUTE_UNUSED,
     222                 :            :                       int n ATTRIBUTE_UNUSED, int m ATTRIBUTE_UNUSED)
     223                 :            : {
     224                 :          0 :   gcc_assert (0);
     225                 :            : }
     226                 :            : 
     227                 :            : 
     228                 :            : 
     229                 :            : gfc_constructor *
     230                 :   11075400 : gfc_constructor_first (gfc_constructor_base base)
     231                 :            : {
     232                 :   11075400 :   if (base)
     233                 :            :     {
     234                 :   11070000 :       splay_tree_node node = splay_tree_min (base);
     235                 :   11070000 :       return node ? (gfc_constructor*) node->value : NULL;
     236                 :            :     }
     237                 :            :   else
     238                 :            :     return NULL;
     239                 :            : }
     240                 :            : 
     241                 :            : 
     242                 :            : gfc_constructor *
     243                 :   16629300 : gfc_constructor_next (gfc_constructor *ctor)
     244                 :            : {
     245                 :   16629300 :   if (ctor)
     246                 :            :     {
     247                 :   33258300 :       splay_tree_node node = splay_tree_successor (ctor->base,
     248                 :   16629200 :                                                    mpz_get_si (ctor->offset));
     249                 :   16629200 :       return node ? (gfc_constructor*) node->value : NULL;
     250                 :            :     }
     251                 :            :   else
     252                 :            :     return NULL;
     253                 :            : }
     254                 :            : 
     255                 :            : 
     256                 :            : void
     257                 :         10 : gfc_constructor_remove (gfc_constructor *ctor)
     258                 :            : {
     259                 :         10 :   if (ctor)
     260                 :         10 :     splay_tree_remove (ctor->base, mpz_get_si (ctor->offset));
     261                 :         10 : }
     262                 :            : 
     263                 :            : 
     264                 :            : gfc_constructor *
     265                 :        155 : gfc_constructor_lookup_next (gfc_constructor_base base, int offset)
     266                 :            : {
     267                 :        155 :   splay_tree_node node;
     268                 :            : 
     269                 :        155 :   if (!base)
     270                 :            :     return NULL;
     271                 :            : 
     272                 :         24 :   node = splay_tree_successor (base, (splay_tree_key) offset);
     273                 :         24 :   if (!node)
     274                 :            :     return NULL;
     275                 :            : 
     276                 :          4 :   return (gfc_constructor *) node->value;
     277                 :            : }

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.