LCOV - code coverage report
Current view: top level - gcc - function-tests.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 276 279 98.9 %
Date: 2020-03-28 11:57:23 Functions: 16 17 94.1 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Unit tests for function-handling.
       2                 :            :    Copyright (C) 2015-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 "tm.h"
      24                 :            : #include "opts.h"
      25                 :            : #include "hash-set.h"
      26                 :            : #include "fixed-value.h"
      27                 :            : #include "alias.h"
      28                 :            : #include "flags.h"
      29                 :            : #include "symtab.h"
      30                 :            : #include "tree-core.h"
      31                 :            : #include "stor-layout.h"
      32                 :            : #include "tree.h"
      33                 :            : #include "stringpool.h"
      34                 :            : #include "stor-layout.h"
      35                 :            : #include "rtl.h"
      36                 :            : #include "predict.h"
      37                 :            : #include "vec.h"
      38                 :            : #include "hashtab.h"
      39                 :            : #include "hash-set.h"
      40                 :            : #include "hard-reg-set.h"
      41                 :            : #include "input.h"
      42                 :            : #include "function.h"
      43                 :            : #include "dominance.h"
      44                 :            : #include "cfg.h"
      45                 :            : #include "cfganal.h"
      46                 :            : #include "basic-block.h"
      47                 :            : #include "tree-ssa-alias.h"
      48                 :            : #include "internal-fn.h"
      49                 :            : #include "gimple-fold.h"
      50                 :            : #include "gimple-expr.h"
      51                 :            : #include "toplev.h"
      52                 :            : #include "print-tree.h"
      53                 :            : #include "tree-iterator.h"
      54                 :            : #include "gimplify.h"
      55                 :            : #include "tree-cfg.h"
      56                 :            : #include "basic-block.h"
      57                 :            : #include "alias.h"
      58                 :            : #include "symtab.h"
      59                 :            : #include "inchash.h"
      60                 :            : #include "tree.h"
      61                 :            : #include "fold-const.h"
      62                 :            : #include "stor-layout.h"
      63                 :            : #include "stmt.h"
      64                 :            : #include "hash-table.h"
      65                 :            : #include "tree-ssa-alias.h"
      66                 :            : #include "internal-fn.h"
      67                 :            : #include "gimple-expr.h"
      68                 :            : #include "is-a.h"
      69                 :            : #include "gimple.h"
      70                 :            : #include "tree-pass.h"
      71                 :            : #include "context.h"
      72                 :            : #include "hash-map.h"
      73                 :            : #include "plugin-api.h"
      74                 :            : #include "ipa-ref.h"
      75                 :            : #include "cgraph.h"
      76                 :            : #include "selftest.h"
      77                 :            : #include "print-rtl.h"
      78                 :            : 
      79                 :            : #if CHECKING_P
      80                 :            : 
      81                 :            : namespace selftest {
      82                 :            : 
      83                 :            : /* Helper function for selftests of function-creation.  */
      84                 :            : 
      85                 :            : tree
      86                 :         22 : make_fndecl (tree return_type,
      87                 :            :              const char *name,
      88                 :            :              vec <tree> &param_types,
      89                 :            :              bool is_variadic)
      90                 :            : {
      91                 :         22 :   tree fn_type;
      92                 :         22 :   if (is_variadic)
      93                 :          0 :     fn_type = build_varargs_function_type_array (return_type,
      94                 :          0 :                                                  param_types.length (),
      95                 :            :                                                  param_types.address ());
      96                 :            :   else
      97                 :         44 :     fn_type = build_function_type_array (return_type,
      98                 :         22 :                                          param_types.length (),
      99                 :            :                                          param_types.address ());
     100                 :            :   /* FIXME: this uses input_location: */
     101                 :         22 :   tree fndecl = build_fn_decl (name, fn_type);
     102                 :            : 
     103                 :         22 :   return fndecl;
     104                 :            : }
     105                 :            : 
     106                 :            : /* Verify creating a function declaration equivalent to the following
     107                 :            :      int test_fndecl_int_void (void);
     108                 :            :    C declaration.  */
     109                 :            : 
     110                 :            : static void
     111                 :          2 : test_fndecl_int_void ()
     112                 :            : {
     113                 :          2 :   auto_vec <tree> param_types;
     114                 :          2 :   const char *name = "test_fndecl_int_void";
     115                 :          2 :   tree fndecl = make_fndecl (integer_type_node,
     116                 :            :                              name,
     117                 :            :                              param_types);
     118                 :          2 :   ASSERT_TRUE (fndecl != NULL);
     119                 :            : 
     120                 :            :   /* Verify name of decl.  */
     121                 :          2 :   tree declname = DECL_NAME (fndecl);
     122                 :          2 :   ASSERT_TRUE (declname != NULL);
     123                 :          2 :   ASSERT_EQ (IDENTIFIER_NODE, TREE_CODE (declname));
     124                 :            :   /* We expect it to use a *copy* of the string we passed in.  */
     125                 :          2 :   const char *identifier_ptr = IDENTIFIER_POINTER (declname);
     126                 :          2 :   ASSERT_NE (name, identifier_ptr);
     127                 :          2 :   ASSERT_EQ (0, strcmp ("test_fndecl_int_void", identifier_ptr));
     128                 :            : 
     129                 :            :   /* Verify type of fndecl.  */
     130                 :          2 :   ASSERT_EQ (FUNCTION_DECL, TREE_CODE (fndecl));
     131                 :          2 :   tree fntype = TREE_TYPE (fndecl);
     132                 :          2 :   ASSERT_EQ (FUNCTION_TYPE, TREE_CODE (fntype));
     133                 :            : 
     134                 :            :   /* Verify return type.  */
     135                 :          2 :   ASSERT_EQ (integer_type_node, TREE_TYPE (fntype));
     136                 :            : 
     137                 :            :   /* Verify "void" args.  */
     138                 :          2 :   tree argtypes = TYPE_ARG_TYPES (fntype);
     139                 :          2 :   ASSERT_EQ (TREE_LIST, TREE_CODE (argtypes));
     140                 :          2 :   ASSERT_EQ (void_type_node, TREE_VALUE (argtypes));
     141                 :          2 :   ASSERT_EQ (NULL, TREE_CHAIN (argtypes));
     142                 :          2 : }
     143                 :            : 
     144                 :            : /* Verify creating a function declaration equivalent to the following
     145                 :            :      float test_fndecl_float_intchar (int, char);
     146                 :            :    C declaration.  */
     147                 :            : 
     148                 :            : static void
     149                 :          2 : test_fndecl_float_intchar ()
     150                 :            : {
     151                 :          2 :   auto_vec <tree> param_types;
     152                 :          2 :   param_types.safe_push (integer_type_node);
     153                 :          2 :   param_types.safe_push (char_type_node);
     154                 :          2 :   const char *name = "test_fndecl_float_intchar";
     155                 :          2 :   tree fndecl = make_fndecl (float_type_node,
     156                 :            :                              name,
     157                 :            :                              param_types);
     158                 :          2 :   ASSERT_TRUE (fndecl != NULL);
     159                 :            : 
     160                 :            :   /* Verify name of decl.  */
     161                 :          2 :   tree declname = DECL_NAME (fndecl);
     162                 :          2 :   ASSERT_TRUE (declname != NULL);
     163                 :          2 :   ASSERT_EQ (IDENTIFIER_NODE, TREE_CODE (declname));
     164                 :            :   /* We expect it to use a *copy* of the string we passed in.  */
     165                 :          2 :   const char *identifier_ptr = IDENTIFIER_POINTER (declname);
     166                 :          2 :   ASSERT_NE (name, identifier_ptr);
     167                 :          2 :   ASSERT_EQ (0, strcmp (name, identifier_ptr));
     168                 :            : 
     169                 :            :   /* Verify type of fndecl.  */
     170                 :          2 :   ASSERT_EQ (FUNCTION_DECL, TREE_CODE (fndecl));
     171                 :          2 :   tree fntype = TREE_TYPE (fndecl);
     172                 :          2 :   ASSERT_EQ (FUNCTION_TYPE, TREE_CODE (fntype));
     173                 :            : 
     174                 :            :   /* Verify return type.  */
     175                 :          2 :   ASSERT_EQ (float_type_node, TREE_TYPE (fntype));
     176                 :            : 
     177                 :            :   /* Verify "(int, char)" args.  */
     178                 :          2 :   tree arg0 = TYPE_ARG_TYPES (fntype);
     179                 :          2 :   ASSERT_EQ (TREE_LIST, TREE_CODE (arg0));
     180                 :          2 :   ASSERT_EQ (integer_type_node, TREE_VALUE (arg0));
     181                 :          2 :   tree arg1 = TREE_CHAIN (arg0);
     182                 :          2 :   ASSERT_TRUE (arg1 != NULL);
     183                 :          2 :   ASSERT_EQ (TREE_LIST, TREE_CODE (arg1));
     184                 :          2 :   ASSERT_EQ (char_type_node, TREE_VALUE (arg1));
     185                 :          2 :   tree argterm = TREE_CHAIN (arg1);
     186                 :          2 :   ASSERT_TRUE (argterm != NULL);
     187                 :          2 :   ASSERT_EQ (TREE_LIST, TREE_CODE (argterm));
     188                 :          2 :   ASSERT_EQ (void_type_node, TREE_VALUE (argterm));
     189                 :          2 :   ASSERT_EQ (NULL, TREE_CHAIN (argterm));
     190                 :          2 : }
     191                 :            : 
     192                 :            : /* The test cases using these helper functions take a trivial function:
     193                 :            : 
     194                 :            :      int test_fn (void) { return 42; }
     195                 :            : 
     196                 :            :    and test various conversions done to it:
     197                 :            : 
     198                 :            :    - gimplification
     199                 :            :    - construction of the CFG
     200                 :            :    - conversion to SSA form
     201                 :            :    - expansion to RTL form
     202                 :            : 
     203                 :            :    In avoid having one overlong test case, this is broken
     204                 :            :    up into separate test cases for each stage, with helper functions
     205                 :            :    to minimize code duplication.
     206                 :            : 
     207                 :            :    Another approach would be to attempt to directly construct a function
     208                 :            :    in the appropriate representation at each stage, though presumably
     209                 :            :    that would exhibit different kinds of failure compared to this
     210                 :            :    approach.  */
     211                 :            : 
     212                 :            : /* Construct this function:
     213                 :            :    int test_fn (void) { return 42; }
     214                 :            :    in generic tree form.  Return the fndecl.  */
     215                 :            : 
     216                 :            : static tree
     217                 :         10 : build_trivial_generic_function ()
     218                 :            : {
     219                 :         10 :   auto_vec <tree> param_types;
     220                 :         10 :   tree fndecl = make_fndecl (integer_type_node,
     221                 :            :                              "test_fn",
     222                 :            :                              param_types);
     223                 :         10 :   ASSERT_TRUE (fndecl != NULL);
     224                 :            : 
     225                 :            :   /* Populate the function.  */
     226                 :         10 :   tree retval = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
     227                 :            :                             NULL_TREE, integer_type_node);
     228                 :         10 :   DECL_ARTIFICIAL (retval) = 1;
     229                 :         10 :   DECL_IGNORED_P (retval) = 1;
     230                 :         10 :   DECL_RESULT (fndecl) = retval;
     231                 :            : 
     232                 :            :   /* Create a BIND_EXPR, and within it, a statement list.  */
     233                 :         10 :   tree stmt_list = alloc_stmt_list ();
     234                 :         10 :   tree_stmt_iterator stmt_iter = tsi_start (stmt_list);
     235                 :         10 :   tree block = make_node (BLOCK);
     236                 :         10 :   tree bind_expr
     237                 :         10 :     = build3 (BIND_EXPR, void_type_node, NULL, stmt_list, block);
     238                 :            : 
     239                 :         10 :   tree modify_retval = build2 (MODIFY_EXPR,
     240                 :            :                                integer_type_node,
     241                 :            :                                retval,
     242                 :         10 :                                build_int_cst (integer_type_node, 42));
     243                 :         10 :   tree return_stmt = build1 (RETURN_EXPR,
     244                 :            :                              integer_type_node,
     245                 :            :                              modify_retval);
     246                 :         10 :   tsi_link_after (&stmt_iter, return_stmt, TSI_CONTINUE_LINKING);
     247                 :            : 
     248                 :         10 :   DECL_INITIAL (fndecl) = block;
     249                 :         10 :   BLOCK_SUPERCONTEXT (block) = fndecl;
     250                 :            : 
     251                 :            :   /* how to add to function? the following appears to be how to
     252                 :            :      set the body of a fndecl: */
     253                 :         10 :   DECL_SAVED_TREE(fndecl) = bind_expr;
     254                 :            : 
     255                 :            :   /* Ensure that locals appear in the debuginfo.  */
     256                 :         10 :   BLOCK_VARS (block) = BIND_EXPR_VARS (bind_expr);
     257                 :            : 
     258                 :         10 :   return fndecl;
     259                 :            : }
     260                 :            : 
     261                 :            : /* Construct this function:
     262                 :            :      int test_fn (void) { return 42; }
     263                 :            :    in "high gimple" form.  Return the fndecl.  */
     264                 :            : 
     265                 :            : static tree
     266                 :          8 : build_trivial_high_gimple_function ()
     267                 :            : {
     268                 :            :   /* Construct a trivial function, and gimplify it: */
     269                 :          0 :   tree fndecl = build_trivial_generic_function ();
     270                 :          8 :   gimplify_function_tree (fndecl);
     271                 :          8 :   return fndecl;
     272                 :            : }
     273                 :            : 
     274                 :            : /* Build a CFG for a function in gimple form.  */
     275                 :            : 
     276                 :            : static void
     277                 :          6 : build_cfg (tree fndecl)
     278                 :            : {
     279                 :          6 :   function *fun = DECL_STRUCT_FUNCTION (fndecl);
     280                 :          6 :   ASSERT_TRUE (fun != NULL);
     281                 :          6 :   ASSERT_EQ (fndecl, fun->decl);
     282                 :            : 
     283                 :            :   /* We first have to lower control flow; for our trivial test function
     284                 :            :      this gives us:
     285                 :            :          test_fn ()
     286                 :            :          {
     287                 :            :            D.56 = 42;
     288                 :            :            goto <D.57>;
     289                 :            :            <D.57>:
     290                 :            :            return D.56;
     291                 :            :          }
     292                 :            :   */
     293                 :          6 :   gimple_opt_pass *lower_cf_pass = make_pass_lower_cf (g);
     294                 :          6 :   push_cfun (fun);
     295                 :          6 :   lower_cf_pass->execute (fun);
     296                 :          6 :   pop_cfun ();
     297                 :          6 :   delete lower_cf_pass;
     298                 :            : 
     299                 :            :   /* We can now convert to CFG form; for our trivial test function this
     300                 :            :      gives us:
     301                 :            :          test_fn ()
     302                 :            :          {
     303                 :            :            <bb 2>:
     304                 :            :            D.56 = 42;
     305                 :            :            return D.56;
     306                 :            :          }
     307                 :            :   */
     308                 :          6 :   gimple_opt_pass *build_cfg_pass = make_pass_build_cfg (g);
     309                 :          6 :   push_cfun (fun);
     310                 :          6 :   build_cfg_pass->execute (fun);
     311                 :          6 :   pop_cfun ();
     312                 :          6 :   delete build_cfg_pass;
     313                 :          6 : }
     314                 :            : 
     315                 :            : /* Convert a gimple+CFG function to SSA form.  */
     316                 :            : 
     317                 :            : static void
     318                 :          4 : convert_to_ssa (tree fndecl)
     319                 :            : {
     320                 :          4 :   function *fun = DECL_STRUCT_FUNCTION (fndecl);
     321                 :          4 :   ASSERT_TRUE (fun != NULL);
     322                 :          4 :   ASSERT_EQ (fndecl, fun->decl);
     323                 :            : 
     324                 :          4 :   gimple_opt_pass *build_ssa_pass = make_pass_build_ssa (g);
     325                 :          4 :   push_cfun (fun);
     326                 :          4 :   build_ssa_pass->execute (fun);
     327                 :          4 :   pop_cfun ();
     328                 :          4 :   delete build_ssa_pass;
     329                 :          4 : }
     330                 :            : 
     331                 :            : /* Assuming we have a simple 3-block CFG like this:
     332                 :            :      [ENTRY] -> [block2] -> [EXIT]
     333                 :            :    get the "real" basic block (block 2).  */
     334                 :            : 
     335                 :            : static basic_block
     336                 :         26 : get_real_block (function *fun)
     337                 :            : {
     338                 :         26 :   ASSERT_TRUE (fun->cfg != NULL);
     339                 :         26 :   ASSERT_EQ (3, n_basic_blocks_for_fn (fun));
     340                 :         26 :   basic_block bb2 = (*fun->cfg->x_basic_block_info)[2];
     341                 :         26 :   ASSERT_TRUE (bb2 != NULL);
     342                 :         26 :   return bb2;
     343                 :            : }
     344                 :            : 
     345                 :            : /* Verify that we have a simple 3-block CFG: the two "fake" ones, and
     346                 :            :    a "real" one:
     347                 :            :      [ENTRY] -> [block2] -> [EXIT].  */
     348                 :            : 
     349                 :            : static void
     350                 :         10 : verify_three_block_cfg (function *fun)
     351                 :            : {
     352                 :         10 :   ASSERT_TRUE (fun->cfg != NULL);
     353                 :         10 :   ASSERT_EQ (3, n_basic_blocks_for_fn (fun));
     354                 :         10 :   ASSERT_EQ (2, n_edges_for_fn (fun));
     355                 :            : 
     356                 :            :   /* The "fake" basic blocks.  */
     357                 :         10 :   basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
     358                 :         10 :   ASSERT_TRUE (entry != NULL);
     359                 :         10 :   ASSERT_EQ (ENTRY_BLOCK, entry->index);
     360                 :            : 
     361                 :         10 :   basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
     362                 :         10 :   ASSERT_TRUE (exit != NULL);
     363                 :         10 :   ASSERT_EQ (EXIT_BLOCK, exit->index);
     364                 :            : 
     365                 :            :   /* The "real" basic block.  */
     366                 :         10 :   basic_block bb2 = get_real_block (fun);
     367                 :         10 :   ASSERT_TRUE (bb2 != NULL);
     368                 :         10 :   ASSERT_EQ (2, bb2->index);
     369                 :            : 
     370                 :            :   /* Verify connectivity.  */
     371                 :         10 :   ASSERT_EQ (NULL, entry->preds);
     372                 :         10 :   ASSERT_EQ (1, entry->succs->length ());
     373                 :            : 
     374                 :         10 :   edge from_entry_to_bb2 = (*entry->succs)[0];
     375                 :         10 :   ASSERT_EQ (entry, from_entry_to_bb2->src);
     376                 :         10 :   ASSERT_EQ (bb2, from_entry_to_bb2->dest);
     377                 :            : 
     378                 :         10 :   ASSERT_EQ (1, bb2->preds->length ());
     379                 :         10 :   ASSERT_EQ (from_entry_to_bb2, (*bb2->preds)[0]);
     380                 :         10 :   ASSERT_EQ (1, bb2->succs->length ());
     381                 :            : 
     382                 :         10 :   edge from_bb2_to_exit = (*bb2->succs)[0];
     383                 :         10 :   ASSERT_EQ (bb2, from_bb2_to_exit->src);
     384                 :         10 :   ASSERT_EQ (exit, from_bb2_to_exit->dest);
     385                 :            : 
     386                 :         10 :   ASSERT_EQ (1, exit->preds->length ());
     387                 :         10 :   ASSERT_EQ (from_bb2_to_exit, (*exit->preds)[0]);
     388                 :         10 :   ASSERT_EQ (NULL, exit->succs);
     389                 :         10 : }
     390                 :            : 
     391                 :            : /* As above, but additionally verify the gimple statements are sane.  */
     392                 :            : 
     393                 :            : static void
     394                 :          4 : verify_three_block_gimple_cfg (function *fun)
     395                 :            : {
     396                 :          4 :   verify_three_block_cfg (fun);
     397                 :            : 
     398                 :            :   /* The "fake" basic blocks should be flagged as gimple, but with have no
     399                 :            :      statements.  */
     400                 :          4 :   basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
     401                 :          4 :   ASSERT_TRUE (entry != NULL);
     402                 :          4 :   ASSERT_EQ (0, entry->flags & BB_RTL);
     403                 :          4 :   ASSERT_EQ (NULL, bb_seq (entry));
     404                 :            : 
     405                 :          4 :   basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
     406                 :          4 :   ASSERT_TRUE (exit != NULL);
     407                 :          4 :   ASSERT_EQ (0, entry->flags & BB_RTL);
     408                 :          4 :   ASSERT_EQ (NULL, bb_seq (exit));
     409                 :            : 
     410                 :            :   /* The "real" basic block should be flagged as gimple, and have one
     411                 :            :      or more statements.  */
     412                 :          4 :   basic_block bb2 = get_real_block (fun);
     413                 :          4 :   ASSERT_TRUE (bb2 != NULL);
     414                 :          4 :   ASSERT_EQ (0, entry->flags & BB_RTL);
     415                 :          4 :   ASSERT_TRUE (bb_seq (bb2) != NULL);
     416                 :          4 : }
     417                 :            : 
     418                 :            : /* As above, but additionally verify the RTL insns are sane.  */
     419                 :            : 
     420                 :            : void
     421                 :          6 : verify_three_block_rtl_cfg (function *fun)
     422                 :            : {
     423                 :          6 :   verify_three_block_cfg (fun);
     424                 :            : 
     425                 :            :   /* The "fake" basic blocks should be flagged as RTL, but with no
     426                 :            :      insns.  */
     427                 :          6 :   basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (fun);
     428                 :          6 :   ASSERT_TRUE (entry != NULL);
     429                 :          6 :   ASSERT_EQ (BB_RTL, entry->flags & BB_RTL);
     430                 :          6 :   ASSERT_EQ (NULL, BB_HEAD (entry));
     431                 :            : 
     432                 :          6 :   basic_block exit = EXIT_BLOCK_PTR_FOR_FN (fun);
     433                 :          6 :   ASSERT_TRUE (exit != NULL);
     434                 :          6 :   ASSERT_EQ (BB_RTL, exit->flags & BB_RTL);
     435                 :          6 :   ASSERT_EQ (NULL, BB_HEAD (exit));
     436                 :            : 
     437                 :            :   /* The "real" basic block should be flagged as RTL, and have one
     438                 :            :      or more insns.  */
     439                 :          6 :   basic_block bb2 = get_real_block (fun);
     440                 :          6 :   ASSERT_TRUE (bb2 != NULL);
     441                 :          6 :   ASSERT_EQ (BB_RTL, bb2->flags & BB_RTL);
     442                 :          6 :   ASSERT_TRUE (BB_HEAD (bb2) != NULL);
     443                 :          6 : }
     444                 :            : 
     445                 :            : /* Test converting our trivial function:
     446                 :            :      int test_fn (void) { return 42; }
     447                 :            :    to gimple form.  */
     448                 :            : 
     449                 :            : static void
     450                 :          2 : test_gimplification ()
     451                 :            : {
     452                 :          2 :   tree fndecl = build_trivial_generic_function ();
     453                 :            : 
     454                 :            :   /* Convert to gimple: */
     455                 :          2 :   gimplify_function_tree (fndecl);
     456                 :            : 
     457                 :            :   /* Verify that we got gimple out of it.  */
     458                 :            : 
     459                 :            :   /* The function is now in GIMPLE form but the CFG has not been
     460                 :            :      built yet.  */
     461                 :            : 
     462                 :            :   /* We should have a struct function for the decl.  */
     463                 :          2 :   function *fun = DECL_STRUCT_FUNCTION (fndecl);
     464                 :          2 :   ASSERT_TRUE (fun != NULL);
     465                 :          2 :   ASSERT_EQ (fndecl, fun->decl);
     466                 :            : 
     467                 :            :   /* We expect a GIMPLE_BIND, with two gimple statements within it:
     468                 :            :        tmp = 42;
     469                 :            :        return tmp;  */
     470                 :            : 
     471                 :          2 :   gimple_seq seq_fn_body = gimple_body (fndecl);
     472                 :          2 :   ASSERT_TRUE (seq_fn_body != NULL);
     473                 :          2 :   gimple *bind_stmt = gimple_seq_first_stmt (seq_fn_body);
     474                 :          2 :   ASSERT_EQ (GIMPLE_BIND, gimple_code (bind_stmt));
     475                 :          2 :   ASSERT_EQ (NULL, bind_stmt->next);
     476                 :            : 
     477                 :          2 :   gimple_seq seq_bind_body = gimple_bind_body (as_a <gbind *> (bind_stmt));
     478                 :            : 
     479                 :            :   /* Verify that we have the 2 statements we expect.  */
     480                 :          2 :   ASSERT_TRUE (seq_bind_body != NULL);
     481                 :          2 :   gimple *stmt1 = gimple_seq_first_stmt (seq_bind_body);
     482                 :          2 :   ASSERT_TRUE (stmt1 != NULL);
     483                 :          2 :   ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt1));
     484                 :          2 :   gimple *stmt2 = stmt1->next;
     485                 :          2 :   ASSERT_TRUE (stmt2 != NULL);
     486                 :          2 :   ASSERT_EQ (stmt1, stmt2->prev);
     487                 :          2 :   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt2));
     488                 :          2 : }
     489                 :            : 
     490                 :            : /* Test of building a CFG for a function in high gimple form.  */
     491                 :            : 
     492                 :            : static void
     493                 :          2 : test_building_cfg ()
     494                 :            : {
     495                 :            :   /* Construct a trivial function, and gimplify it: */
     496                 :          2 :   tree fndecl = build_trivial_high_gimple_function ();
     497                 :          2 :   function *fun = DECL_STRUCT_FUNCTION (fndecl);
     498                 :          2 :   ASSERT_TRUE (fun != NULL);
     499                 :            : 
     500                 :            :   /* Build a CFG.  */
     501                 :          2 :   build_cfg (fndecl);
     502                 :            : 
     503                 :            :   /* The CFG-building code constructs a 4-block cfg (with
     504                 :            :      ENTRY and EXIT):
     505                 :            :        test_fn ()
     506                 :            :        {
     507                 :            :          <bb 2>:
     508                 :            :          D.65 = 42;
     509                 :            : 
     510                 :            :          <bb 3>:
     511                 :            :          return D.65;
     512                 :            :        }
     513                 :            :      and then ought to merge blocks 2 and 3 in cleanup_tree_cfg.
     514                 :            : 
     515                 :            :      Hence we should end up with a simple 3-block cfg, the two "fake" ones,
     516                 :            :      and a "real" one:
     517                 :            :        [ENTRY] -> [block2] -> [EXIT]
     518                 :            :      with code like this:
     519                 :            :          test_fn ()
     520                 :            :          {
     521                 :            :            <bb 2>:
     522                 :            :            D.56 = 42;
     523                 :            :            return D.56;
     524                 :            :          }
     525                 :            :   */
     526                 :          2 :   verify_three_block_gimple_cfg (fun);
     527                 :            : 
     528                 :            :   /* Verify the statements within the "real" block.  */
     529                 :          2 :   basic_block bb2 = get_real_block (fun);
     530                 :          4 :   gimple *stmt_a = gimple_seq_first_stmt (bb_seq (bb2));
     531                 :          2 :   ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
     532                 :          2 :   gimple *stmt_b = stmt_a->next;
     533                 :          2 :   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
     534                 :          2 :   ASSERT_EQ (NULL, stmt_b->next);
     535                 :          2 : }
     536                 :            : 
     537                 :            : /* Test of conversion of gimple to SSA form.  */
     538                 :            : 
     539                 :            : static void
     540                 :          2 : test_conversion_to_ssa ()
     541                 :            : {
     542                 :            :   /* As above, construct a trivial function, gimplify it, and build a CFG: */
     543                 :          2 :   tree fndecl = build_trivial_high_gimple_function ();
     544                 :          2 :   function *fun = DECL_STRUCT_FUNCTION (fndecl);
     545                 :          2 :   ASSERT_TRUE (fun != NULL);
     546                 :          2 :   build_cfg (fndecl);
     547                 :            : 
     548                 :          2 :   convert_to_ssa (fndecl);
     549                 :            : 
     550                 :          2 :   verify_three_block_gimple_cfg (fun);
     551                 :            : 
     552                 :            :   /* For out trivial test function we should now have something like
     553                 :            :      this:
     554                 :            :        test_fn ()
     555                 :            :        {
     556                 :            :          <bb 2>:
     557                 :            :          _1 = 42;
     558                 :            :          return _1;
     559                 :            :        }
     560                 :            :   */
     561                 :          2 :   basic_block bb2 = get_real_block (fun);
     562                 :          4 :   gimple *stmt_a = gimple_seq_first_stmt (bb_seq (bb2));
     563                 :          2 :   ASSERT_EQ (GIMPLE_ASSIGN, gimple_code (stmt_a));
     564                 :            : 
     565                 :          2 :   gimple *stmt_b = stmt_a->next;
     566                 :          2 :   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt_b));
     567                 :          2 :   ASSERT_EQ (NULL, stmt_b->next);
     568                 :            : 
     569                 :          2 :   greturn *return_stmt = as_a <greturn *> (stmt_b);
     570                 :          2 :   ASSERT_EQ (SSA_NAME, TREE_CODE (gimple_return_retval (return_stmt)));
     571                 :          2 : }
     572                 :            : 
     573                 :            : /* Test range folding.  We must start this here because we need cfun
     574                 :            :    set.  */
     575                 :            : 
     576                 :            : static void
     577                 :          2 : test_ranges ()
     578                 :            : {
     579                 :          2 :   tree fndecl = build_trivial_high_gimple_function ();
     580                 :          2 :   function *fun = DECL_STRUCT_FUNCTION (fndecl);
     581                 :          2 :   push_cfun (fun);
     582                 :          2 :   range_tests ();
     583                 :          2 :   pop_cfun ();
     584                 :          2 : }
     585                 :            : 
     586                 :            : /* Test of expansion from gimple-ssa to RTL.  */
     587                 :            : 
     588                 :            : static void
     589                 :          2 : test_expansion_to_rtl ()
     590                 :            : {
     591                 :            :   /* As above, construct a trivial function, gimplify it, build a CFG,
     592                 :            :      and convert to SSA: */
     593                 :          2 :   tree fndecl = build_trivial_high_gimple_function ();
     594                 :          2 :   function *fun = DECL_STRUCT_FUNCTION (fndecl);
     595                 :          2 :   ASSERT_TRUE (fun != NULL);
     596                 :          2 :   build_cfg (fndecl);
     597                 :          2 :   convert_to_ssa (fndecl);
     598                 :            : 
     599                 :            :   /* We need a cgraph_node for it.  */
     600                 :          2 :   cgraph_node::get_create (fndecl);
     601                 :            :   /* Normally, cgraph_node::expand () would call
     602                 :            :      init_function_start (and a bunch of other stuff),
     603                 :            :      and invoke the expand pass, but it also runs
     604                 :            :      all of the other passes.  So just do the minimum
     605                 :            :      needed to get from gimple-SSA to RTL.  */
     606                 :          2 :   rtl_opt_pass *expand_pass = make_pass_expand (g);
     607                 :          2 :   push_cfun (fun);
     608                 :          2 :   init_function_start (fndecl);
     609                 :          2 :   expand_pass->execute (fun);
     610                 :          2 :   pop_cfun ();
     611                 :          2 :   delete expand_pass;
     612                 :            : 
     613                 :            :   /* On x86_64, I get this:
     614                 :            :        (note 3 1 2 2 [bb 2] NOTE_INSN_BASIC_BLOCK)
     615                 :            :        (note 2 3 5 2 NOTE_INSN_FUNCTION_BEG)
     616                 :            :        (insn 5 2 6 2 (set (reg:SI 87 [ D.59 ])
     617                 :            :                           (const_int 42 [0x2a])) -1 (nil))
     618                 :            :        (insn 6 5 10 2 (set (reg:SI 88 [ <retval> ])
     619                 :            :                            (reg:SI 87 [ D.59 ])) -1 (nil))
     620                 :            :        (insn 10 6 11 2 (set (reg/i:SI 0 ax)
     621                 :            :                             (reg:SI 88 [ <retval> ])) -1 (nil))
     622                 :            :        (insn 11 10 0 2 (use (reg/i:SI 0 ax)) -1 (nil))
     623                 :            : 
     624                 :            :      On cr16-elf I get this:
     625                 :            :        (note 4 1 2 2 [bb 2] NOTE_INSN_BASIC_BLOCK)
     626                 :            :        (insn 2 4 3 2 (set (reg:SI 24)
     627                 :            :             (reg/f:SI 16 virtual-incoming-args)) -1
     628                 :            :           (nil))
     629                 :            :        (note 3 2 6 2 NOTE_INSN_FUNCTION_BEG)
     630                 :            :        (insn 6 3 7 2 (set (reg:HI 22 [ _1 ])
     631                 :            :             (const_int 42 [0x2a])) -1
     632                 :            :          (nil))
     633                 :            :        (insn 7 6 11 2 (set (reg:HI 23 [ <retval> ])
     634                 :            :            (reg:HI 22 [ _1 ])) -1
     635                 :            :          (nil))
     636                 :            :        (insn 11 7 12 2 (set (reg/i:HI 0 r0)
     637                 :            :            (reg:HI 23 [ <retval> ])) -1
     638                 :            :          (nil))
     639                 :            :        (insn 12 11 0 2 (use (reg/i:HI 0 r0)) -1
     640                 :            :          (nil)).  */
     641                 :          2 :   verify_three_block_rtl_cfg (fun);
     642                 :            : 
     643                 :            :   /* Verify as much of the RTL as we can whilst avoiding
     644                 :            :      target-specific behavior.  */
     645                 :          2 :   basic_block bb2 = get_real_block (fun);
     646                 :            : 
     647                 :            :   /* Expect a NOTE_INSN_BASIC_BLOCK... */
     648                 :          2 :   rtx_insn *insn = BB_HEAD (bb2);
     649                 :          2 :   ASSERT_TRUE (insn != NULL);
     650                 :          2 :   ASSERT_EQ (NOTE, insn->code);
     651                 :          2 :   ASSERT_EQ (NOTE_INSN_BASIC_BLOCK, NOTE_KIND (insn));
     652                 :          2 :   ASSERT_EQ (bb2, NOTE_BASIC_BLOCK (insn));
     653                 :            : 
     654                 :            :   /* ...etc; any further checks are likely to over-specify things
     655                 :            :      and run us into target dependencies.  */
     656                 :            : 
     657                 :            :   /* Verify that print_rtl_function is sane.  */
     658                 :          4 :   named_temp_file tmp_out (".rtl");
     659                 :          2 :   FILE *outfile = fopen (tmp_out.get_filename (), "w");
     660                 :          2 :   print_rtx_function (outfile, fun, true);
     661                 :          2 :   fclose (outfile);
     662                 :            : 
     663                 :          2 :   char *dump = read_file (SELFTEST_LOCATION, tmp_out.get_filename ());
     664                 :          2 :   ASSERT_STR_CONTAINS (dump, "(function \"test_fn\"\n");
     665                 :          2 :   ASSERT_STR_CONTAINS (dump, "  (insn-chain\n");
     666                 :          2 :   ASSERT_STR_CONTAINS (dump, "    (block 2\n");
     667                 :          2 :   ASSERT_STR_CONTAINS (dump, "      (edge-from entry (flags \"FALLTHRU\"))\n");
     668                 :          2 :   ASSERT_STR_CONTAINS (dump, "      (cinsn "); /* ...etc.  */
     669                 :          2 :   ASSERT_STR_CONTAINS (dump, "      (edge-to exit (flags \"FALLTHRU\"))\n");
     670                 :          2 :   ASSERT_STR_CONTAINS (dump, "    ) ;; block 2\n");
     671                 :          2 :   ASSERT_STR_CONTAINS (dump, "  ) ;; insn-chain\n");
     672                 :          2 :   ASSERT_STR_CONTAINS (dump, "  (crtl\n");
     673                 :          2 :   ASSERT_STR_CONTAINS (dump, "  ) ;; crtl\n");
     674                 :          2 :   ASSERT_STR_CONTAINS (dump, ") ;; function \"test_fn\"\n");
     675                 :            : 
     676                 :          2 :   free (dump);
     677                 :          2 :   free_after_compilation (fun);
     678                 :          2 : }
     679                 :            : 
     680                 :            : /* Run all of the selftests within this file.  */
     681                 :            : 
     682                 :            : void
     683                 :          2 : function_tests_c_tests ()
     684                 :            : {
     685                 :          2 :   test_fndecl_int_void ();
     686                 :          2 :   test_fndecl_float_intchar ();
     687                 :          2 :   test_gimplification ();
     688                 :          2 :   test_building_cfg ();
     689                 :          2 :   test_conversion_to_ssa ();
     690                 :          2 :   test_ranges ();
     691                 :          2 :   test_expansion_to_rtl ();
     692                 :          2 : }
     693                 :            : 
     694                 :            : } // namespace selftest
     695                 :            : 
     696                 :            : #endif /* #if CHECKING_P */

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.