gcc/ipa-chkp.c

   1 /* Pointer Bounds Checker IPA passes.
   2    Copyright (C) 2014-2015 Free Software Foundation, Inc.
   3    Contributed by Ilya Enkovich (ilya.enkovich@intel.com)
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 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 COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "hash-set.h"
  25 #include "machmode.h"
  26 #include "vec.h"
  27 #include "double-int.h"
  28 #include "input.h"
  29 #include "alias.h"
  30 #include "symtab.h"
  31 #include "options.h"
  32 #include "wide-int.h"
  33 #include "inchash.h"
  34 #include "tree.h"
  35 #include "fold-const.h"
  36 #include "stor-layout.h"
  37 #include "tree-pass.h"
  38 #include "stringpool.h"
  39 #include "bitmap.h"
  40 #include "gimple-expr.h"
  41 #include "tm.h"
  42 #include "hard-reg-set.h"
  43 #include "function.h"
  44 #include "is-a.h"
  45 #include "tree-ssa-alias.h"
  46 #include "predict.h"
  47 #include "basic-block.h"
  48 #include "gimple.h"
  49 #include "ipa-ref.h"
  50 #include "lto-streamer.h"
  51 #include "cgraph.h"
  52 #include "tree-chkp.h"
  53 #include "tree-inline.h"
  54 #include "ipa-chkp.h"
  55
  56 /*  Pointer Bounds Checker has two IPA passes to support code instrumentation.
  57
  58     In instrumented code each pointer is provided with bounds.  For input
  59     pointer parameters it means we also have bounds passed.  For calls it
  60     means we have additional bounds arguments for pointer arguments.
  61
  62     To have all IPA optimizations working correctly we have to express
  63     dataflow between passed and received bounds explicitly via additional
  64     entries in function declaration arguments list and in function type.
  65     Since we may have both instrumented and not instrumented code at the
  66     same time, we cannot replace all original functions with their
  67     instrumented variants.  Therefore we create clones (versions) instead.
  68
  69     Instrumentation clones creation is a separate IPA pass which is a part
  70     of early local passes.  Clones are created after SSA is built (because
  71     instrumentation pass works on SSA) and before any transformations
  72     which may change pointer flow and therefore lead to incorrect code
  73     instrumentation (possibly causing false bounds check failures).
  74
  75     Instrumentation clones have pointer bounds arguments added right after
  76     pointer arguments.  Clones have assembler name of the original
  77     function with suffix added.  New assembler name is in transparent
  78     alias chain with the original name.  Thus we expect all calls to the
  79     original and instrumented functions look similar in assembler.
  80
  81     During instrumentation versioning pass we create instrumented versions
  82     of all function with body and also for all their aliases and thunks.
  83     Clones for functions with no body are created on demand (usually
  84     during call instrumentation).
  85
  86     Original and instrumented function nodes are connected with IPA
  87     reference IPA_REF_CHKP.  It is mostly done to have reachability
  88     analysis working correctly.  We may have no references to the
  89     instrumented function in the code but it still should be counted
  90     as reachable if the original function is reachable.
  91
  92     When original function bodies are not needed anymore we release
  93     them and transform functions into a special kind of thunks.  Each
  94     thunk has a call edge to the instrumented version.  These thunks
  95     help to keep externally visible instrumented functions visible
  96     when linker resolution files are used.  Linker has no info about
  97     connection between original and instrumented function and
  98     therefore we may wrongly decide (due to difference in assembler
  99     names) that instrumented function version is local and can be
 100     removed.  */
 101
 102 #define CHKP_BOUNDS_OF_SYMBOL_PREFIX "__chkp_bounds_of_"
 103 #define CHKP_WRAPPER_SYMBOL_PREFIX "__mpx_wrapper_"
 104
 105 /* Return 1 calls to FNDECL should be replaced with
 106    a call to wrapper function.  */
 107 static bool
 108 chkp_wrap_function (tree fndecl)
 109 {
 110   if (!flag_chkp_use_wrappers)
 111     return false;
 112
 113   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
 114     {
 115       switch (DECL_FUNCTION_CODE (fndecl))
 116         {
 117         case BUILT_IN_STRLEN:
 118         case BUILT_IN_STRCPY:
 119         case BUILT_IN_STRNCPY:
 120         case BUILT_IN_STPCPY:
 121         case BUILT_IN_STPNCPY:
 122         case BUILT_IN_STRCAT:
 123         case BUILT_IN_STRNCAT:
 124         case BUILT_IN_MEMCPY:
 125         case BUILT_IN_MEMPCPY:
 126         case BUILT_IN_MEMSET:
 127         case BUILT_IN_MEMMOVE:
 128         case BUILT_IN_BZERO:
 129         case BUILT_IN_MALLOC:
 130         case BUILT_IN_CALLOC:
 131         case BUILT_IN_REALLOC:
 132           return 1;
 133
 134         default:
 135           return 0;
 136         }
 137     }
 138
 139   return false;
 140 }
 141
 142 /* Build a clone of FNDECL with a modified name.  */
 143
 144 static tree
 145 chkp_build_instrumented_fndecl (tree fndecl)
 146 {
 147   tree new_decl = copy_node (fndecl);
 148   tree new_name;
 149   std::string s;
 150
 151   /* called_as_built_in checks DECL_NAME to identify calls to
 152      builtins.  We want instrumented calls to builtins to be
 153      recognized by called_as_built_in.  Therefore use original
 154      DECL_NAME for cloning with no prefixes.  */
 155   s = IDENTIFIER_POINTER (DECL_NAME (fndecl));
 156   s += ".chkp";
 157   DECL_NAME (new_decl) = get_identifier (s.c_str ());
 158
 159   /* References to the original and to the instrumented version
 160      should look the same in the output assembly.  And we cannot
 161      use the same assembler name for the instrumented version
 162      because it conflicts with decl merging algorithms in LTO.
 163      Achieve the result by using transparent alias name for the
 164      instrumented version.  */
 165   if (chkp_wrap_function(fndecl))
 166     {
 167       s = CHKP_WRAPPER_SYMBOL_PREFIX;
 168       s += IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
 169       new_name = get_identifier (s.c_str ());
 170     }
 171   else
 172     {
 173       s = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
 174       s += ".chkp";
 175       new_name = get_identifier (s.c_str ());
 176       IDENTIFIER_TRANSPARENT_ALIAS (new_name) = 1;
 177       TREE_CHAIN (new_name) = DECL_ASSEMBLER_NAME (fndecl);
 178     }
 179   SET_DECL_ASSEMBLER_NAME (new_decl, new_name);
 180
 181   /* For functions with body versioning will make a copy of arguments.
 182      For functions with no body we need to do it here.  */
 183   if (!gimple_has_body_p (fndecl))
 184     DECL_ARGUMENTS (new_decl) = copy_list (DECL_ARGUMENTS (fndecl));
 185
 186   /* We are going to modify attributes list and therefore should
 187      make own copy.  */
 188   DECL_ATTRIBUTES (new_decl) = copy_list (DECL_ATTRIBUTES (fndecl));
 189
 190   /* Change builtin function code.  */
 191   if (DECL_BUILT_IN (new_decl))
 192     {
 193       gcc_assert (DECL_BUILT_IN_CLASS (new_decl) == BUILT_IN_NORMAL);
 194       gcc_assert (DECL_FUNCTION_CODE (new_decl) < BEGIN_CHKP_BUILTINS);
 195       DECL_FUNCTION_CODE (new_decl)
 196         = (enum built_in_function)(DECL_FUNCTION_CODE (new_decl)
 197                                    + BEGIN_CHKP_BUILTINS + 1);
 198     }
 199
 200   return new_decl;
 201 }
 202
 203
 204 /* Fix operands of attribute from ATTRS list named ATTR_NAME.
 205    Integer operands are replaced with values according to
 206    INDEXES map having LEN elements.  For operands out of len
 207    we just add DELTA.  */
 208
 209 static void
 210 chkp_map_attr_arg_indexes (tree attrs, const char *attr_name,
 211                            unsigned *indexes, int len, int delta)
 212 {
 213   tree attr = lookup_attribute (attr_name, attrs);
 214   tree op;
 215
 216   if (!attr)
 217     return;
 218
 219   TREE_VALUE (attr) = copy_list (TREE_VALUE (attr));
 220   for (op = TREE_VALUE (attr); op; op = TREE_CHAIN (op))
 221     {
 222       int idx;
 223
 224       if (TREE_CODE (TREE_VALUE (op)) != INTEGER_CST)
 225         continue;
 226
 227       idx = TREE_INT_CST_LOW (TREE_VALUE (op));
 228
 229       /* If idx exceeds indexes length then we just
 230          keep it at the same distance from the last
 231          known arg.  */
 232       if (idx > len)
 233         idx += delta;
 234       else
 235         idx = indexes[idx - 1] + 1;
 236       TREE_VALUE (op) = build_int_cst (TREE_TYPE (TREE_VALUE (op)), idx);
 237     }
 238 }
 239
 240 /* Make a copy of function type ORIG_TYPE adding pointer
 241    bounds as additional arguments.  */
 242
 243 tree
 244 chkp_copy_function_type_adding_bounds (tree orig_type)
 245 {
 246   tree type;
 247   tree arg_type, attrs, t;
 248   unsigned len = list_length (TYPE_ARG_TYPES (orig_type));
 249   unsigned *indexes = XALLOCAVEC (unsigned, len);
 250   unsigned idx = 0, new_idx = 0;
 251
 252   for (arg_type = TYPE_ARG_TYPES (orig_type);
 253        arg_type;
 254        arg_type = TREE_CHAIN (arg_type))
 255     if (TREE_VALUE (arg_type) == void_type_node)
 256       continue;
 257     else if (BOUNDED_TYPE_P (TREE_VALUE (arg_type))
 258              || pass_by_reference (NULL, TYPE_MODE (TREE_VALUE (arg_type)),
 259                                    TREE_VALUE (arg_type), true)
 260              || chkp_type_has_pointer (TREE_VALUE (arg_type)))
 261       break;
 262
 263   /* We may use original type if there are no bounds passed.  */
 264   if (!arg_type)
 265     return orig_type;
 266
 267   type = copy_node (orig_type);
 268   TYPE_ARG_TYPES (type) = copy_list (TYPE_ARG_TYPES (type));
 269
 270   for (arg_type = TYPE_ARG_TYPES (type);
 271        arg_type;
 272        arg_type = TREE_CHAIN (arg_type))
 273     {
 274       indexes[idx++] = new_idx++;
 275
 276       /* pass_by_reference returns 1 for void type,
 277          so check for it first.  */
 278       if (TREE_VALUE (arg_type) == void_type_node)
 279         continue;
 280       else if (BOUNDED_TYPE_P (TREE_VALUE (arg_type))
 281                || pass_by_reference (NULL, TYPE_MODE (TREE_VALUE (arg_type)),
 282                                      TREE_VALUE (arg_type), true))
 283         {
 284           tree new_type = build_tree_list (NULL_TREE,
 285                                            pointer_bounds_type_node);
 286           TREE_CHAIN (new_type) = TREE_CHAIN (arg_type);
 287           TREE_CHAIN (arg_type) = new_type;
 288
 289           arg_type = TREE_CHAIN (arg_type);
 290           new_idx++;
 291         }
 292       else if (chkp_type_has_pointer (TREE_VALUE (arg_type)))
 293         {
 294           bitmap slots = BITMAP_ALLOC (NULL);
 295           bitmap_iterator bi;
 296           unsigned bnd_no;
 297
 298           chkp_find_bound_slots (TREE_VALUE (arg_type), slots);
 299
 300           EXECUTE_IF_SET_IN_BITMAP (slots, 0, bnd_no, bi)
 301             {
 302               tree new_type = build_tree_list (NULL_TREE,
 303                                                pointer_bounds_type_node);
 304               TREE_CHAIN (new_type) = TREE_CHAIN (arg_type);
 305               TREE_CHAIN (arg_type) = new_type;
 306
 307               arg_type = TREE_CHAIN (arg_type);
 308               new_idx++;
 309             }
 310           BITMAP_FREE (slots);
 311         }
 312     }
 313
 314   /* If function type has attribute with arg indexes then
 315      we have to copy it fixing attribute ops.  Map for
 316      fixing is in indexes array.  */
 317   attrs = TYPE_ATTRIBUTES (type);
 318   if (lookup_attribute ("nonnull", attrs)
 319       || lookup_attribute ("format", attrs)
 320       || lookup_attribute ("format_arg", attrs))
 321     {
 322       int delta = new_idx - len;
 323       attrs = copy_list (TYPE_ATTRIBUTES (type));
 324       chkp_map_attr_arg_indexes (attrs, "nonnull", indexes, len, delta);
 325       chkp_map_attr_arg_indexes (attrs, "format", indexes, len, delta);
 326       chkp_map_attr_arg_indexes (attrs, "format_arg", indexes, len, delta);
 327       TYPE_ATTRIBUTES (type) = attrs;
 328     }
 329
 330   t = TYPE_MAIN_VARIANT (orig_type);
 331   if (orig_type != t)
 332     {
 333       TYPE_MAIN_VARIANT (type) = t;
 334       TYPE_NEXT_VARIANT (type) = TYPE_NEXT_VARIANT (t);
 335       TYPE_NEXT_VARIANT (t) = type;
 336     }
 337   else
 338     {
 339       TYPE_MAIN_VARIANT (type) = type;
 340       TYPE_NEXT_VARIANT (type) = NULL;
 341     }
 342
 343
 344   return type;
 345 }
 346
 347 /* For given function FNDECL add bounds arguments to arguments
 348    list.  */
 349
 350 static void
 351 chkp_add_bounds_params_to_function (tree fndecl)
 352 {
 353   tree arg;
 354
 355   for (arg = DECL_ARGUMENTS (fndecl); arg; arg = DECL_CHAIN (arg))
 356     if (BOUNDED_P (arg))
 357       {
 358         std::string new_name = CHKP_BOUNDS_OF_SYMBOL_PREFIX;
 359         tree new_arg;
 360
 361         if (DECL_NAME (arg))
 362           new_name += IDENTIFIER_POINTER (DECL_NAME (arg));
 363         else
 364           {
 365             char uid[25];
 366             snprintf (uid, 25, "D.%u", DECL_UID (arg));
 367             new_name += uid;
 368           }
 369
 370         new_arg = build_decl (DECL_SOURCE_LOCATION (arg), PARM_DECL,
 371                               get_identifier (new_name.c_str ()),
 372                               pointer_bounds_type_node);
 373         DECL_ARG_TYPE (new_arg) = pointer_bounds_type_node;
 374         DECL_CONTEXT (new_arg) = DECL_CONTEXT (arg);
 375         DECL_ARTIFICIAL (new_arg) = 1;
 376         DECL_CHAIN (new_arg) = DECL_CHAIN (arg);
 377         DECL_CHAIN (arg) = new_arg;
 378
 379         arg = DECL_CHAIN (arg);
 380
 381       }
 382     else if (chkp_type_has_pointer (TREE_TYPE (arg)))
 383       {
 384         tree orig_arg = arg;
 385         bitmap slots = BITMAP_ALLOC (NULL);
 386         bitmap_iterator bi;
 387         unsigned bnd_no;
 388
 389         chkp_find_bound_slots (TREE_TYPE (arg), slots);
 390
 391         EXECUTE_IF_SET_IN_BITMAP (slots, 0, bnd_no, bi)
 392           {
 393             std::string new_name = CHKP_BOUNDS_OF_SYMBOL_PREFIX;
 394             tree new_arg;
 395             char offs[25];
 396
 397             if (DECL_NAME (orig_arg))
 398               new_name += IDENTIFIER_POINTER (DECL_NAME (orig_arg));
 399             else
 400               {
 401                 snprintf (offs, 25, "D.%u", DECL_UID (arg));
 402                 new_name += offs;
 403               }
 404             snprintf (offs, 25, "__%u", bnd_no * POINTER_SIZE / BITS_PER_UNIT);
 405
 406             new_arg = build_decl (DECL_SOURCE_LOCATION (orig_arg),
 407                                   PARM_DECL,
 408                                   get_identifier (new_name.c_str ()),
 409                                   pointer_bounds_type_node);
 410             DECL_ARG_TYPE (new_arg) = pointer_bounds_type_node;
 411             DECL_CONTEXT (new_arg) = DECL_CONTEXT (orig_arg);
 412             DECL_ARTIFICIAL (new_arg) = 1;
 413             DECL_CHAIN (new_arg) = DECL_CHAIN (arg);
 414             DECL_CHAIN (arg) = new_arg;
 415
 416             arg = DECL_CHAIN (arg);
 417           }
 418         BITMAP_FREE (slots);
 419       }
 420
 421   TREE_TYPE (fndecl) =
 422     chkp_copy_function_type_adding_bounds (TREE_TYPE (fndecl));
 423 }
 424
 425 /* Return an instrumentation clone for builtin function
 426    FNDECL.  Create one if needed.  */
 427
 428 tree
 429 chkp_maybe_clone_builtin_fndecl (tree fndecl)
 430 {
 431   tree clone;
 432   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
 433
 434   gcc_assert (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
 435               && fcode < BEGIN_CHKP_BUILTINS);
 436
 437   fcode = (enum built_in_function) (fcode + BEGIN_CHKP_BUILTINS + 1);
 438   clone = builtin_decl_explicit (fcode);
 439   if (clone)
 440     return clone;
 441
 442   clone = chkp_build_instrumented_fndecl (fndecl);
 443   chkp_add_bounds_params_to_function (clone);
 444
 445   gcc_assert (DECL_FUNCTION_CODE (clone) == fcode);
 446
 447   set_builtin_decl (fcode, clone, false);
 448
 449   return clone;
 450 }
 451
 452 /* Return 1 if function FNDECL should be instrumented.  */
 453
 454 bool
 455 chkp_instrumentable_p (tree fndecl)
 456 {
 457   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
 458   return (!lookup_attribute ("bnd_legacy", DECL_ATTRIBUTES (fndecl))
 459           && (!flag_chkp_instrument_marked_only
 460               || lookup_attribute ("bnd_instrument", DECL_ATTRIBUTES (fndecl)))
 461           && (!fn || !copy_forbidden (fn, fndecl)));
 462 }
 463
 464 /* Return clone created for instrumentation of NODE or NULL.  */
 465
 466 cgraph_node *
 467 chkp_maybe_create_clone (tree fndecl)
 468 {
 469   cgraph_node *node = cgraph_node::get_create (fndecl);
 470   cgraph_node *clone = node->instrumented_version;
 471
 472   gcc_assert (!node->instrumentation_clone);
 473
 474   if (DECL_BUILT_IN (fndecl)
 475       && (DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL
 476           || DECL_FUNCTION_CODE (fndecl) >= BEGIN_CHKP_BUILTINS))
 477     return NULL;
 478
 479   clone = node->instrumented_version;
 480
 481   /* Some instrumented builtin function calls may be optimized and
 482      cgraph nodes may be removed as unreachable.  Later optimizations
 483      may generate new calls to removed functions and in this case
 484      we have to recreate cgraph node.  FUNCTION_DECL for instrumented
 485      builtin still exists and should be reused in such case.  */
 486   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
 487       && fndecl == builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl))
 488       && !clone)
 489     {
 490       enum built_in_function fncode = DECL_FUNCTION_CODE (fndecl);
 491       tree new_decl;
 492
 493       fncode = (enum built_in_function) (fncode + BEGIN_CHKP_BUILTINS + 1);
 494       new_decl = builtin_decl_explicit (fncode);
 495
 496       /* We've actually already created an instrumented clone once.
 497          Restore it.  */
 498       if (new_decl)
 499         {
 500           clone = cgraph_node::get (new_decl);
 501
 502           if (!clone)
 503             {
 504               gcc_assert (!gimple_has_body_p (fndecl));
 505               clone = cgraph_node::get_create (new_decl);
 506               clone->externally_visible = node->externally_visible;
 507               clone->local = node->local;
 508               clone->address_taken = node->address_taken;
 509               clone->thunk = node->thunk;
 510               clone->alias = node->alias;
 511               clone->weakref = node->weakref;
 512               clone->cpp_implicit_alias = node->cpp_implicit_alias;
 513               clone->orig_decl = fndecl;
 514               clone->instrumentation_clone = true;
 515             }
 516
 517           clone->instrumented_version = node;
 518           node->instrumented_version = clone;
 519         }
 520     }
 521
 522   if (!clone)
 523     {
 524       tree new_decl = chkp_build_instrumented_fndecl (fndecl);
 525       struct cgraph_edge *e;
 526       struct ipa_ref *ref;
 527       int i;
 528
 529       clone = node->create_version_clone (new_decl, vNULL, NULL);
 530       clone->externally_visible = node->externally_visible;
 531       clone->local = node->local;
 532       clone->address_taken = node->address_taken;
 533       clone->thunk = node->thunk;
 534       clone->alias = node->alias;
 535       clone->weakref = node->weakref;
 536       clone->cpp_implicit_alias = node->cpp_implicit_alias;
 537       clone->instrumented_version = node;
 538       clone->orig_decl = fndecl;
 539       clone->instrumentation_clone = true;
 540       node->instrumented_version = clone;
 541
 542       if (gimple_has_body_p (fndecl))
 543         {
 544           /* If function will not be instrumented, then it's instrumented
 545              version is a thunk for the original.  */
 546           if (!chkp_instrumentable_p (fndecl))
 547             {
 548               clone->remove_callees ();
 549               clone->remove_all_references ();
 550               clone->thunk.thunk_p = true;
 551               clone->thunk.add_pointer_bounds_args = true;
 552               clone->create_edge (node, NULL, 0, CGRAPH_FREQ_BASE);
 553             }
 554           else
 555             {
 556               tree_function_versioning (fndecl, new_decl, NULL, false,
 557                                         NULL, false, NULL, NULL);
 558               clone->lowered = true;
 559             }
 560         }
 561
 562       /* New params are inserted after versioning because it
 563          actually copies args list from the original decl.  */
 564       chkp_add_bounds_params_to_function (new_decl);
 565
 566       /* Remember builtin fndecl.  */
 567       if (DECL_BUILT_IN_CLASS (clone->decl) == BUILT_IN_NORMAL
 568           && fndecl == builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl)))
 569         {
 570           gcc_assert (!builtin_decl_explicit (DECL_FUNCTION_CODE (clone->decl)));
 571           set_builtin_decl (DECL_FUNCTION_CODE (clone->decl),
 572                             clone->decl, false);
 573         }
 574
 575       /* Clones have the same comdat group as originals.  */
 576       if (node->same_comdat_group
 577           || DECL_ONE_ONLY (node->decl))
 578         clone->add_to_same_comdat_group (node);
 579
 580       if (gimple_has_body_p (fndecl))
 581         symtab->call_cgraph_insertion_hooks (clone);
 582
 583       /* Clone all aliases.  */
 584       for (i = 0; node->iterate_direct_aliases (i, ref); i++)
 585         {
 586           struct cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
 587           struct cgraph_node *chkp_alias
 588             = chkp_maybe_create_clone (alias->decl);
 589           chkp_alias->create_reference (clone, IPA_REF_ALIAS, NULL);
 590         }
 591
 592       /* Clone all thunks.  */
 593       for (e = node->callers; e; e = e->next_caller)
 594         if (e->caller->thunk.thunk_p
 595             && !e->caller->thunk.add_pointer_bounds_args
 596             && !e->caller->instrumentation_clone)
 597           {
 598             struct cgraph_node *thunk
 599               = chkp_maybe_create_clone (e->caller->decl);
 600             /* Redirect thunk clone edge to the node clone.  */
 601             thunk->callees->redirect_callee (clone);
 602           }
 603
 604       /* For aliases and thunks we should make sure target is cloned
 605          to have proper references and edges.  */
 606       if (node->thunk.thunk_p)
 607         chkp_maybe_create_clone (node->callees->callee->decl);
 608       else if (node->alias)
 609         {
 610           struct cgraph_node *target;
 611
 612           ref = node->ref_list.first_reference ();
 613           if (ref)
 614             chkp_maybe_create_clone (ref->referred->decl);
 615
 616           if (node->alias_target)
 617             {
 618               if (TREE_CODE (node->alias_target) == FUNCTION_DECL)
 619                 {
 620                   target = chkp_maybe_create_clone (node->alias_target);
 621                   clone->alias_target = target->decl;
 622                 }
 623               else
 624                 clone->alias_target = node->alias_target;
 625             }
 626         }
 627
 628       /* Add IPA reference.  It's main role is to keep instrumented
 629          version reachable while original node is reachable.  */
 630       ref = node->create_reference (clone, IPA_REF_CHKP, NULL);
 631     }
 632
 633   return clone;
 634 }
 635
 636 /* Create clone for all functions to be instrumented.  */
 637
 638 static unsigned int
 639 chkp_versioning (void)
 640 {
 641   struct cgraph_node *node;
 642   const char *reason;
 643
 644   bitmap_obstack_initialize (NULL);
 645
 646   FOR_EACH_DEFINED_FUNCTION (node)
 647     {
 648       if (!node->instrumentation_clone
 649           && !node->instrumented_version
 650           && !node->alias
 651           && !node->thunk.thunk_p
 652           && (!DECL_BUILT_IN (node->decl)
 653               || (DECL_BUILT_IN_CLASS (node->decl) == BUILT_IN_NORMAL
 654                   && DECL_FUNCTION_CODE (node->decl) < BEGIN_CHKP_BUILTINS)))
 655         {
 656           if (chkp_instrumentable_p (node->decl))
 657             chkp_maybe_create_clone (node->decl);
 658           else if ((reason = copy_forbidden (DECL_STRUCT_FUNCTION (node->decl),
 659                                              node->decl)))
 660             {
 661               if (warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wchkp,
 662                               "function cannot be instrumented"))
 663                 inform (DECL_SOURCE_LOCATION (node->decl), reason, node->decl);
 664             }
 665         }
 666     }
 667
 668   /* Mark all aliases and thunks of functions with no instrumented
 669      version as legacy function.  */
 670   FOR_EACH_DEFINED_FUNCTION (node)
 671     {
 672       if (!node->instrumentation_clone
 673           && !node->instrumented_version
 674           && (node->alias || node->thunk.thunk_p)
 675           && !lookup_attribute ("bnd_legacy", DECL_ATTRIBUTES (node->decl)))
 676         DECL_ATTRIBUTES (node->decl)
 677           = tree_cons (get_identifier ("bnd_legacy"), NULL,
 678                        DECL_ATTRIBUTES (node->decl));
 679     }
 680
 681   bitmap_obstack_release (NULL);
 682
 683   return 0;
 684 }
 685
 686 /* In this pass we remove bodies of functions having
 687    instrumented version.  Functions with removed bodies
 688    become a special kind of thunks to provide a connection
 689    between calls to the original version and instrumented
 690    function.  */
 691
 692 static unsigned int
 693 chkp_produce_thunks (bool early)
 694 {
 695   struct cgraph_node *node;
 696
 697   FOR_EACH_DEFINED_FUNCTION (node)
 698     {
 699       if (!node->instrumentation_clone
 700           && node->instrumented_version
 701           && gimple_has_body_p (node->decl)
 702           && gimple_has_body_p (node->instrumented_version->decl)
 703           && (!lookup_attribute ("always_inline", DECL_ATTRIBUTES (node->decl))
 704               || !early))
 705         {
 706           node->release_body ();
 707           node->remove_callees ();
 708           node->remove_all_references ();
 709
 710           node->thunk.thunk_p = true;
 711           node->thunk.add_pointer_bounds_args = true;
 712           node->create_edge (node->instrumented_version, NULL,
 713                              0, CGRAPH_FREQ_BASE);
 714           node->create_reference (node->instrumented_version,
 715                                IPA_REF_CHKP, NULL);
 716         }
 717     }
 718
 719   /* Mark instrumentation clones created for aliases and thunks
 720      as insttrumented so they could be removed as unreachable
 721      now.  */
 722   if (!early)
 723     {
 724       FOR_EACH_DEFINED_FUNCTION (node)
 725       {
 726         if (node->instrumentation_clone
 727             && (node->alias || node->thunk.thunk_p)
 728             && !chkp_function_instrumented_p (node->decl))
 729           chkp_function_mark_instrumented (node->decl);
 730       }
 731     }
 732
 733   return TODO_remove_functions;
 734 }
 735
 736 const pass_data pass_data_ipa_chkp_versioning =
 737 {
 738   SIMPLE_IPA_PASS, /* type */
 739   "chkp_versioning", /* name */
 740   OPTGROUP_NONE, /* optinfo_flags */
 741   TV_NONE, /* tv_id */
 742   0, /* properties_required */
 743   0, /* properties_provided */
 744   0, /* properties_destroyed */
 745   0, /* todo_flags_start */
 746   0 /* todo_flags_finish */
 747 };
 748
 749 const pass_data pass_data_ipa_chkp_early_produce_thunks =
 750 {
 751   SIMPLE_IPA_PASS, /* type */
 752   "chkp_ecleanup", /* name */
 753   OPTGROUP_NONE, /* optinfo_flags */
 754   TV_NONE, /* tv_id */
 755   0, /* properties_required */
 756   0, /* properties_provided */
 757   0, /* properties_destroyed */
 758   0, /* todo_flags_start */
 759   0 /* todo_flags_finish */
 760 };
 761
 762 const pass_data pass_data_ipa_chkp_produce_thunks =
 763 {
 764   SIMPLE_IPA_PASS, /* type */
 765   "chkp_cleanup", /* name */
 766   OPTGROUP_NONE, /* optinfo_flags */
 767   TV_NONE, /* tv_id */
 768   0, /* properties_required */
 769   0, /* properties_provided */
 770   0, /* properties_destroyed */
 771   0, /* todo_flags_start */
 772   0 /* todo_flags_finish */
 773 };
 774
 775 class pass_ipa_chkp_versioning : public simple_ipa_opt_pass
 776 {
 777 public:
 778   pass_ipa_chkp_versioning (gcc::context *ctxt)
 779     : simple_ipa_opt_pass (pass_data_ipa_chkp_versioning, ctxt)
 780   {}
 781
 782   /* opt_pass methods: */
 783   virtual opt_pass * clone ()
 784     {
 785       return new pass_ipa_chkp_versioning (m_ctxt);
 786     }
 787
 788   virtual bool gate (function *)
 789     {
 790       return flag_check_pointer_bounds;
 791     }
 792
 793   virtual unsigned int execute (function *)
 794     {
 795       return chkp_versioning ();
 796     }
 797
 798 }; // class pass_ipa_chkp_versioning
 799
 800 class pass_ipa_chkp_early_produce_thunks : public simple_ipa_opt_pass
 801 {
 802 public:
 803   pass_ipa_chkp_early_produce_thunks (gcc::context *ctxt)
 804     : simple_ipa_opt_pass (pass_data_ipa_chkp_early_produce_thunks, ctxt)
 805   {}
 806
 807   /* opt_pass methods: */
 808   virtual opt_pass * clone ()
 809     {
 810       return new pass_ipa_chkp_early_produce_thunks (m_ctxt);
 811     }
 812
 813   virtual bool gate (function *)
 814     {
 815       return flag_check_pointer_bounds;
 816     }
 817
 818   virtual unsigned int execute (function *)
 819     {
 820       return chkp_produce_thunks (true);
 821     }
 822
 823 }; // class pass_chkp_produce_thunks
 824
 825 class pass_ipa_chkp_produce_thunks : public simple_ipa_opt_pass
 826 {
 827 public:
 828   pass_ipa_chkp_produce_thunks (gcc::context *ctxt)
 829     : simple_ipa_opt_pass (pass_data_ipa_chkp_produce_thunks, ctxt)
 830   {}
 831
 832   /* opt_pass methods: */
 833   virtual opt_pass * clone ()
 834     {
 835       return new pass_ipa_chkp_produce_thunks (m_ctxt);
 836     }
 837
 838   virtual bool gate (function *)
 839     {
 840       return flag_check_pointer_bounds;
 841     }
 842
 843   virtual unsigned int execute (function *)
 844     {
 845       return chkp_produce_thunks (false);
 846     }
 847
 848 }; // class pass_chkp_produce_thunks
 849
 850 simple_ipa_opt_pass *
 851 make_pass_ipa_chkp_versioning (gcc::context *ctxt)
 852 {
 853   return new pass_ipa_chkp_versioning (ctxt);
 854 }
 855
 856 simple_ipa_opt_pass *
 857 make_pass_ipa_chkp_early_produce_thunks (gcc::context *ctxt)
 858 {
 859   return new pass_ipa_chkp_early_produce_thunks (ctxt);
 860 }
 861
 862 simple_ipa_opt_pass *
 863 make_pass_ipa_chkp_produce_thunks (gcc::context *ctxt)
 864 {
 865   return new pass_ipa_chkp_produce_thunks (ctxt);
 866 }