gcc/function-instrumentation.c

   1 /* Function Instrumentation.
   2    Copyright (C) 2009 by Cupertino Miranda, Shuangde Huang, Liang Peng
   3    INRIA Futurs, France; ICT, China;
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by the
   9 Free Software Foundation; either version 2, or (at your option) any
  10 later version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT
  13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "rtl.h"
  28 #include "tm_p.h"
  29 #include "hard-reg-set.h"
  30 #include "basic-block.h"
  31 #include "output.h"
  32 #include "diagnostic.h"
  33 #include "tree-flow.h"
  34 #include "tree-dump.h"
  35 #include "tree-pass.h"
  36 #include "timevar.h"
  37 #include "cfgloop.h"
  38 #include "flags.h"
  39 #include "tree-inline.h"
  40 #include "cgraph.h"
  41 #include "ipa-prop.h"
  42 #include "opts.h"
  43 #include "tree-iterator.h"
  44 #include "gimple.h"
  45 #include "toplev.h"
  46 #include "highlev-plugin-internal.h"
  47
  48 /* Info for function instrumentation.  */
  49 instrinfo idi;
  50
  51 static bool
  52 is_it_instrumentable (struct cgraph_node *cg_func)
  53 {
  54   if (cgraph_function_body_availability (cg_func) == AVAIL_NOT_AVAILABLE)
  55     return false;
  56   else
  57     return true;
  58 }
  59
  60 static void
  61 freeinstrinfo (instrinfo idi)
  62 {
  63   /* free instrumentation info.  */
  64   int i;
  65   for(i=0; i<idi.numofinstrfun; i++)
  66     {
  67       free (*(idi.instrument_function_list + i));
  68       free (*(idi.function_filename_list + i));
  69       free (*(idi.timer1 + i));
  70       free (*(idi.timer2 + i));
  71     }
  72   free (idi.instrument_function_list);
  73   free (idi.function_filename_list);
  74   free (idi.timer1);
  75   free (idi.timer2);
  76 }
  77
  78 static bool
  79 is_in_instrument_list (const char *func_name, const char *file_name,
  80                        int *nid)
  81 {
  82   int i = 0;
  83   for(i = 0; i < idi.numofinstrfun; i++)
  84     {
  85       if (strcmp (func_name, *(idi.instrument_function_list + i)) == 0
  86           && strcmp (file_name, *(idi.function_filename_list + i)) == 0)
  87         {
  88           *nid = i;
  89           return true;
  90         }
  91     }
  92   return false;
  93 }
  94
  95 static void
  96 add_timer_begin (struct cgraph_node *cg_func, char *funname, int cloned)
  97 {
  98   gimple_stmt_iterator gsi;
  99   struct function * func = NULL;
 100   gimple_seq gp_seq = NULL;
 101   gimple stmt = NULL;
 102   basic_block bb = NULL;
 103   location_t location;
 104
 105   tree decl = cg_func->decl;
 106   tree ftype = build_function_type (void_type_node, void_list_node);
 107   tree func_decl = build_fn_decl (funname, ftype);
 108   tree call_expr = build_function_call_expr (func_decl, NULL_TREE);
 109   location = DECL_SOURCE_LOCATION(decl);
 110   DECL_SOURCE_LOCATION(func_decl) = location;
 111
 112   /*convert the call_expr (tree) to gimple_seq(gp_seq)*/
 113   gimplify_stmt(&call_expr, &gp_seq);
 114
 115   func = DECL_STRUCT_FUNCTION (decl);
 116   bb = ENTRY_BLOCK_PTR_FOR_FUNCTION (func)->next_bb;
 117   gsi = gsi_start_bb(bb);
 118   if(cloned == 1)
 119     gsi_insert_seq_after (&gsi, gp_seq, GSI_NEW_STMT);
 120   else
 121     gsi_insert_seq_before (&gsi, gp_seq, GSI_NEW_STMT);
 122   stmt = gsi_stmt (gsi);
 123   gimple_set_location (stmt, location);
 124
 125   cgraph_create_edge (cg_func, cgraph_node (func_decl),
 126                       stmt,
 127                       bb->count, CGRAPH_FREQ_MAX, bb->loop_depth);
 128
 129 }
 130
 131 static void
 132 add_timer_end (struct cgraph_node *cg_func, char *funname)
 133 {
 134   edge e;
 135   edge_iterator ei;
 136   gimple_stmt_iterator gsi;
 137   struct function *func = NULL;
 138   gimple stmt = NULL;
 139   gimple_seq gp_seq = NULL;
 140   tree decl, ftype, func_decl, call_expr;
 141   location_t location;
 142
 143   decl = cg_func->decl;
 144   ftype = build_function_type (void_type_node, void_list_node);
 145   func_decl = build_fn_decl (funname, ftype);
 146
 147   func = DECL_STRUCT_FUNCTION (decl);
 148   location = func->function_end_locus;
 149   DECL_SOURCE_LOCATION(func_decl) = location;
 150
 151   FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FUNCTION (func)->preds)
 152     {
 153       gsi = gsi_last_bb (e->src);
 154
 155       call_expr = build_function_call_expr (func_decl, NULL_TREE);
 156       gimplify_stmt(&call_expr, &gp_seq);
 157
 158       if (gimple_code(gsi_stmt (gsi)) == GIMPLE_RETURN)
 159         gsi_insert_seq_before (&gsi, gp_seq, GSI_NEW_STMT);
 160       else
 161         gsi_insert_seq_after (&gsi, gp_seq, GSI_NEW_STMT);
 162
 163       stmt = gsi_stmt (gsi);
 164       gimple_set_location (stmt, location);
 165       gp_seq = NULL;
 166
 167       cgraph_create_edge (cg_func, cgraph_node (func_decl),
 168                           stmt,
 169                           e->src->count, CGRAPH_FREQ_MAX,
 170                           e->src->loop_depth);
 171     }
 172 }
 173
 174 static unsigned int
 175 exec_instrument_functions (void)
 176 {
 177   struct cgraph_node *node;
 178   struct function *saved_cfun, *func;
 179   int nid = -1;
 180   char *beginname = NULL, *endname = NULL;
 181   saved_cfun = cfun;
 182   idi.numofinstrfun = 0;
 183
 184   register_event_parameter("instr_info", &idi, EP_VOID);
 185   call_plugin_event("load_instr_config");
 186   unregister_event_parameter("instr_info");
 187
 188   if (idi.numofinstrfun == 0)
 189     {
 190       fprintf (stderr, "No infomation for instrumentation pass\n");
 191       return 0;
 192     }
 193
 194   /* Perform instrument to functions.  */
 195   for (node = cgraph_nodes; node; node = node->next)
 196     {
 197       const char *node_name = NULL;
 198       const char *file_name = NULL;
 199       func = DECL_STRUCT_FUNCTION (node->decl);
 200       set_cfun (func);
 201       node_name = IDENTIFIER_POINTER (DECL_NAME (node->decl));
 202       file_name = expand_location(DECL_SOURCE_LOCATION (node->decl)).file;
 203
 204       if (is_in_instrument_list (node_name, file_name, &nid)
 205           && is_it_instrumentable(node))
 206         {
 207           int flag_cloned = 0;
 208           if (*(idi.cloned + nid) == '1')
 209             flag_cloned = 1;
 210           if (getenv ("ICI_VERBOSE") != NULL)
 211             printf("Now instrument function: %s \n", node_name);
 212           beginname = (char *) alloca (strlen (node_name) +
 213                                        strlen (*(idi.timer1 + nid)));
 214           if ((*(idi.timer1 + nid))[0] == '_')
 215             sprintf (beginname, "%s%s", node_name, *(idi.timer1 + nid));
 216           else
 217             sprintf (beginname, "%s", *(idi.timer1 + nid));
 218
 219           add_timer_begin (node, beginname, flag_cloned);
 220
 221           endname = (char *) alloca (strlen (node_name) +
 222                                      strlen (*(idi.timer2 + nid)));
 223           if ((*(idi.timer2 + nid))[0] == '_')
 224             sprintf (endname, "%s%s", node_name, *(idi.timer2 + nid));
 225           else
 226             sprintf (endname, "%s", *(idi.timer2 + nid));
 227
 228           add_timer_end (node, endname);
 229         }
 230     }
 231
 232   set_cfun(saved_cfun);
 233   freeinstrinfo (idi);
 234   return 0;
 235 }
 236
 237 static bool
 238 gate_instrument_functions(void)
 239 {
 240   return flag_api_instrument_functions;
 241 }
 242
 243 struct gimple_opt_pass pass_instrument_functions = {
 244  {
 245   SIMPLE_IPA_PASS  ,
 246   "instrumentation",    /* name */
 247   gate_instrument_functions,    /* gate */
 248   exec_instrument_functions,    /* execute */
 249   NULL,                         /* sub */
 250   NULL,                         /* next */
 251   0,                            /* static_pass_number */
 252   0,                            /* tv_id */
 253   0,                            /* properties_required */
 254   0,                            /* properties_provided */
 255   0,                            /* properties_destroyed */
 256   0,                            /* todo_flags_start */
 257   TODO_dump_cgraph | TODO_verify_flow,  /* todo_flags_finish */
 258  }
 259 };