contrib/gcc-8.0/gcc/tree-chkp-opt.c

   1 /* Pointer Bounds Checker optimization pass.
   2    Copyright (C) 2014-2018 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 "backend.h"
  25 #include "target.h"
  26 #include "rtl.h"
  27 #include "tree.h"
  28 #include "gimple.h"
  29 #include "tree-pass.h"
  30 #include "ssa.h"
  31 #include "gimple-pretty-print.h"
  32 #include "diagnostic.h"
  33 #include "fold-const.h"
  34 #include "tree-cfg.h"
  35 #include "tree-ssa-loop-niter.h"
  36 #include "gimple-iterator.h"
  37 #include "tree-chkp.h"
  38 #include "ipa-chkp.h"
  39
  40 enum check_type
  41 {
  42   CHECK_LOWER_BOUND,
  43   CHECK_UPPER_BOUND
  44 };
  45
  46 struct pol_item
  47 {
  48   tree cst;
  49   tree var;
  50 };
  51
  52 struct address_t
  53 {
  54   vec<struct pol_item> pol;
  55 };
  56
  57 /* Structure to hold check informtation.  */
  58 struct check_info
  59 {
  60   /* Type of the check.  */
  61   check_type type;
  62   /* Address used for the check.  */
  63   address_t addr;
  64   /* Bounds used for the check.  */
  65   tree bounds;
  66   /* Check statement.  Can be NULL for removed checks.  */
  67   gimple *stmt;
  68 };
  69
  70 /* Structure to hold checks information for BB.  */
  71 struct bb_checks
  72 {
  73   vec<struct check_info, va_heap, vl_ptr> checks;
  74 };
  75
  76 static void chkp_collect_value (tree ssa_name, address_t &res);
  77
  78 #define chkp_bndmk_fndecl \
  79   (targetm.builtin_chkp_function (BUILT_IN_CHKP_BNDMK))
  80 #define chkp_intersect_fndecl \
  81   (targetm.builtin_chkp_function (BUILT_IN_CHKP_INTERSECT))
  82 #define chkp_checkl_fndecl \
  83   (targetm.builtin_chkp_function (BUILT_IN_CHKP_BNDCL))
  84 #define chkp_checku_fndecl \
  85   (targetm.builtin_chkp_function (BUILT_IN_CHKP_BNDCU))
  86
  87 static vec<struct bb_checks, va_heap, vl_ptr> check_infos;
  88
  89 /* Comparator for pol_item structures I1 and I2 to be used
  90    to find items with equal var.  Also used for polynomial
  91    sorting.  */
  92 static int
  93 chkp_pol_item_compare (const void *i1, const void *i2)
  94 {
  95   const struct pol_item *p1 = (const struct pol_item *)i1;
  96   const struct pol_item *p2 = (const struct pol_item *)i2;
  97
  98   if (p1->var == p2->var)
  99     return 0;
 100   else if (p1->var > p2->var)
 101     return 1;
 102   else
 103     return -1;
 104 }
 105
 106 /* Find polynomial item in ADDR with var equal to VAR
 107    and return its index.  Return -1 if item was not
 108    found.  */
 109 static int
 110 chkp_pol_find (address_t &addr, tree var)
 111 {
 112   int left = 0;
 113   int right = addr.pol.length () - 1;
 114   int n;
 115
 116   while (right >= left)
 117     {
 118       n = (left + right) / 2;
 119
 120       if (addr.pol[n].var == var
 121           || (var && addr.pol[n].var
 122               && TREE_CODE (var) == ADDR_EXPR
 123               && TREE_CODE (addr.pol[n].var) == ADDR_EXPR
 124               && TREE_OPERAND (var, 0) == TREE_OPERAND (addr.pol[n].var, 0)))
 125         return n;
 126       else if (addr.pol[n].var > var)
 127         right = n - 1;
 128       else
 129         left = n + 1;
 130     }
 131
 132   return -1;
 133 }
 134
 135 /* Return constant CST extended to size type.  */
 136 static tree
 137 chkp_extend_const (tree cst)
 138 {
 139   if (TYPE_PRECISION (TREE_TYPE (cst)) < TYPE_PRECISION (size_type_node))
 140     return build_int_cst_type (size_type_node, tree_to_shwi (cst));
 141
 142   return cst;
 143 }
 144
 145 /* Add polynomial item CST * VAR to ADDR.  */
 146 static void
 147 chkp_add_addr_item (address_t &addr, tree cst, tree var)
 148 {
 149   int n = chkp_pol_find (addr, var);
 150
 151   cst = chkp_extend_const (cst);
 152
 153   if (n < 0)
 154     {
 155       struct pol_item item;
 156       item.cst = cst;
 157       item.var = var;
 158
 159       addr.pol.safe_push (item);
 160       addr.pol.qsort (&chkp_pol_item_compare);
 161     }
 162   else
 163     {
 164       addr.pol[n].cst = fold_build2 (PLUS_EXPR, TREE_TYPE (addr.pol[n].cst),
 165                                      addr.pol[n].cst, cst);
 166       if (TREE_CODE (addr.pol[n].cst) == INTEGER_CST
 167           && integer_zerop (addr.pol[n].cst))
 168         addr.pol.ordered_remove (n);
 169     }
 170 }
 171
 172 /* Subtract polynomial item CST * VAR from ADDR.  */
 173 static void
 174 chkp_sub_addr_item (address_t &addr, tree cst, tree var)
 175 {
 176   int n = chkp_pol_find (addr, var);
 177
 178   cst = chkp_extend_const (cst);
 179
 180   if (n < 0)
 181     {
 182       struct pol_item item;
 183       item.cst = fold_build2 (MINUS_EXPR, TREE_TYPE (cst),
 184                               integer_zero_node, cst);
 185       item.var = var;
 186
 187       addr.pol.safe_push (item);
 188       addr.pol.qsort (&chkp_pol_item_compare);
 189     }
 190   else
 191     {
 192       addr.pol[n].cst = fold_build2 (MINUS_EXPR, TREE_TYPE (addr.pol[n].cst),
 193                                      addr.pol[n].cst, cst);
 194       if (TREE_CODE (addr.pol[n].cst) == INTEGER_CST
 195           && integer_zerop (addr.pol[n].cst))
 196         addr.pol.ordered_remove (n);
 197     }
 198 }
 199
 200 /* Add address DELTA to ADDR.  */
 201 static void
 202 chkp_add_addr_addr (address_t &addr, address_t &delta)
 203 {
 204   unsigned int i;
 205   for (i = 0; i < delta.pol.length (); i++)
 206     chkp_add_addr_item (addr, delta.pol[i].cst, delta.pol[i].var);
 207 }
 208
 209 /* Subtract address DELTA from ADDR.  */
 210 static void
 211 chkp_sub_addr_addr (address_t &addr, address_t &delta)
 212 {
 213   unsigned int i;
 214   for (i = 0; i < delta.pol.length (); i++)
 215     chkp_sub_addr_item (addr, delta.pol[i].cst, delta.pol[i].var);
 216 }
 217
 218 /* Mutiply address ADDR by integer constant MULT.  */
 219 static void
 220 chkp_mult_addr (address_t &addr, tree mult)
 221 {
 222   unsigned int i;
 223   for (i = 0; i < addr.pol.length (); i++)
 224     addr.pol[i].cst = fold_build2 (MULT_EXPR, TREE_TYPE (addr.pol[i].cst),
 225                                    addr.pol[i].cst, mult);
 226 }
 227
 228 /* Return 1 if we may prove ADDR has a constant value with
 229    determined sign, which is put into *SIGN.  Otherwise
 230    return 0.  */
 231 static bool
 232 chkp_is_constant_addr (const address_t &addr, int *sign)
 233 {
 234   *sign = 0;
 235
 236   if (addr.pol.length () == 0)
 237     return true;
 238   else if (addr.pol.length () > 1)
 239     return false;
 240   else if (addr.pol[0].var)
 241     return false;
 242   else if (TREE_CODE (addr.pol[0].cst) != INTEGER_CST)
 243     return false;
 244   else if (integer_zerop (addr.pol[0].cst))
 245     *sign = 0;
 246   else if (tree_int_cst_sign_bit (addr.pol[0].cst))
 247     *sign = -1;
 248   else
 249     *sign = 1;
 250
 251   return true;
 252 }
 253
 254 /* Dump ADDR into dump_file.  */
 255 static void
 256 chkp_print_addr (const address_t &addr)
 257 {
 258   unsigned int n = 0;
 259   for (n = 0; n < addr.pol.length (); n++)
 260     {
 261       if (n > 0)
 262         fprintf (dump_file, " + ");
 263
 264       if (addr.pol[n].var == NULL_TREE)
 265         print_generic_expr (dump_file, addr.pol[n].cst);
 266       else
 267         {
 268           if (TREE_CODE (addr.pol[n].cst) != INTEGER_CST
 269               || !integer_onep (addr.pol[n].cst))
 270             {
 271               print_generic_expr (dump_file, addr.pol[n].cst);
 272               fprintf (dump_file, " * ");
 273             }
 274           print_generic_expr (dump_file, addr.pol[n].var);
 275         }
 276     }
 277 }
 278
 279 /* Compute value of PTR and put it into address RES.
 280    PTR has to be ADDR_EXPR.  */
 281 static void
 282 chkp_collect_addr_value (tree ptr, address_t &res)
 283 {
 284   tree obj = TREE_OPERAND (ptr, 0);
 285   address_t addr;
 286
 287   switch (TREE_CODE (obj))
 288     {
 289     case INDIRECT_REF:
 290       chkp_collect_value (TREE_OPERAND (obj, 0), res);
 291       break;
 292
 293     case MEM_REF:
 294       chkp_collect_value (TREE_OPERAND (obj, 0), res);
 295       addr.pol.create (0);
 296       chkp_collect_value (TREE_OPERAND (obj, 1), addr);
 297       chkp_add_addr_addr (res, addr);
 298       addr.pol.release ();
 299       break;
 300
 301     case ARRAY_REF:
 302       chkp_collect_value (build_fold_addr_expr (TREE_OPERAND (obj, 0)), res);
 303       addr.pol.create (0);
 304       chkp_collect_value (TREE_OPERAND (obj, 1), addr);
 305       chkp_mult_addr (addr, array_ref_element_size (obj));
 306       chkp_add_addr_addr (res, addr);
 307       addr.pol.release ();
 308       break;
 309
 310     case COMPONENT_REF:
 311       {
 312         tree str = TREE_OPERAND (obj, 0);
 313         tree field = TREE_OPERAND (obj, 1);
 314         chkp_collect_value (build_fold_addr_expr (str), res);
 315         addr.pol.create (0);
 316         chkp_collect_value (component_ref_field_offset (obj), addr);
 317         chkp_add_addr_addr (res, addr);
 318         addr.pol.release ();
 319         if (DECL_FIELD_BIT_OFFSET (field))
 320           {
 321             addr.pol.create (0);
 322             chkp_collect_value (fold_build2 (TRUNC_DIV_EXPR, size_type_node,
 323                                              DECL_FIELD_BIT_OFFSET (field),
 324                                              size_int (BITS_PER_UNIT)),
 325                            addr);
 326             chkp_add_addr_addr (res, addr);
 327             addr.pol.release ();
 328           }
 329       }
 330       break;
 331
 332     default:
 333       chkp_add_addr_item (res, integer_one_node, ptr);
 334       break;
 335     }
 336 }
 337
 338 /* Compute value of PTR and put it into address RES.  */
 339 static void
 340 chkp_collect_value (tree ptr, address_t &res)
 341 {
 342   gimple *def_stmt;
 343   enum gimple_code code;
 344   enum tree_code rhs_code;
 345   address_t addr;
 346   tree rhs1;
 347
 348   if (TREE_CODE (ptr) == INTEGER_CST)
 349     {
 350       chkp_add_addr_item (res, ptr, NULL);
 351       return;
 352     }
 353   else if (TREE_CODE (ptr) == ADDR_EXPR)
 354     {
 355       chkp_collect_addr_value (ptr, res);
 356       return;
 357     }
 358   else if (TREE_CODE (ptr) != SSA_NAME)
 359     {
 360       chkp_add_addr_item (res, integer_one_node, ptr);
 361       return;
 362     }
 363
 364   /* Now we handle the case when polynomial is computed
 365      for SSA NAME.  */
 366   def_stmt = SSA_NAME_DEF_STMT (ptr);
 367   code = gimple_code (def_stmt);
 368
 369   /* Currently we do not walk through statements other
 370      than assignment.  */
 371   if (code != GIMPLE_ASSIGN)
 372     {
 373       chkp_add_addr_item (res, integer_one_node, ptr);
 374       return;
 375     }
 376
 377   rhs_code = gimple_assign_rhs_code (def_stmt);
 378   rhs1 = gimple_assign_rhs1 (def_stmt);
 379
 380   switch (rhs_code)
 381     {
 382     case SSA_NAME:
 383     case INTEGER_CST:
 384     case ADDR_EXPR:
 385       chkp_collect_value (rhs1, res);
 386       break;
 387
 388     case PLUS_EXPR:
 389     case POINTER_PLUS_EXPR:
 390       chkp_collect_value (rhs1, res);
 391       addr.pol.create (0);
 392       chkp_collect_value (gimple_assign_rhs2 (def_stmt), addr);
 393       chkp_add_addr_addr (res, addr);
 394       addr.pol.release ();
 395       break;
 396
 397     case MINUS_EXPR:
 398       chkp_collect_value (rhs1, res);
 399       addr.pol.create (0);
 400       chkp_collect_value (gimple_assign_rhs2 (def_stmt), addr);
 401       chkp_sub_addr_addr (res, addr);
 402       addr.pol.release ();
 403       break;
 404
 405     case MULT_EXPR:
 406       if (TREE_CODE (rhs1) == SSA_NAME
 407           && TREE_CODE (gimple_assign_rhs2 (def_stmt)) == INTEGER_CST)
 408         {
 409           chkp_collect_value (rhs1, res);
 410           chkp_mult_addr (res, gimple_assign_rhs2 (def_stmt));
 411         }
 412       else if (TREE_CODE (gimple_assign_rhs2 (def_stmt)) == SSA_NAME
 413                && TREE_CODE (rhs1) == INTEGER_CST)
 414         {
 415           chkp_collect_value (gimple_assign_rhs2 (def_stmt), res);
 416           chkp_mult_addr (res, rhs1);
 417         }
 418       else
 419         chkp_add_addr_item (res, integer_one_node, ptr);
 420       break;
 421
 422     default:
 423       chkp_add_addr_item (res, integer_one_node, ptr);
 424       break;
 425     }
 426 }
 427
 428 /* Fill check_info structure *CI with information about
 429    check STMT.  */
 430 static void
 431 chkp_fill_check_info (gimple *stmt, struct check_info *ci)
 432 {
 433   ci->addr.pol.create (0);
 434   ci->bounds = gimple_call_arg (stmt, 1);
 435   chkp_collect_value (gimple_call_arg (stmt, 0), ci->addr);
 436   ci->type = (gimple_call_fndecl (stmt) == chkp_checkl_fndecl
 437              ? CHECK_LOWER_BOUND
 438              : CHECK_UPPER_BOUND);
 439   ci->stmt = stmt;
 440 }
 441
 442 /* Release structures holding check information
 443    for current function.  */
 444 static void
 445 chkp_release_check_info (void)
 446 {
 447   unsigned int n, m;
 448
 449   if (check_infos.exists ())
 450     {
 451       for (n = 0; n < check_infos.length (); n++)
 452         {
 453           for (m = 0; m < check_infos[n].checks.length (); m++)
 454             if (check_infos[n].checks[m].addr.pol.exists ())
 455               check_infos[n].checks[m].addr.pol.release ();
 456           check_infos[n].checks.release ();
 457         }
 458       check_infos.release ();
 459     }
 460 }
 461
 462 /* Create structures to hold check information
 463    for current function.  */
 464 static void
 465 chkp_init_check_info (void)
 466 {
 467   struct bb_checks empty_bbc;
 468   int n;
 469
 470   empty_bbc.checks = vNULL;
 471
 472   chkp_release_check_info ();
 473
 474   check_infos.create (last_basic_block_for_fn (cfun));
 475   for (n = 0; n < last_basic_block_for_fn (cfun); n++)
 476     {
 477       check_infos.safe_push (empty_bbc);
 478       check_infos.last ().checks.create (0);
 479     }
 480 }
 481
 482 /* Find all checks in current function and store info about them
 483    in check_infos.  */
 484 static void
 485 chkp_gather_checks_info (void)
 486 {
 487   basic_block bb;
 488   gimple_stmt_iterator i;
 489
 490   if (dump_file && (dump_flags & TDF_DETAILS))
 491     fprintf (dump_file, "Gathering information about checks...\n");
 492
 493   chkp_init_check_info ();
 494
 495   FOR_EACH_BB_FN (bb, cfun)
 496     {
 497       struct bb_checks *bbc = &check_infos[bb->index];
 498
 499       if (dump_file && (dump_flags & TDF_DETAILS))
 500         fprintf (dump_file, "Searching checks in BB%d...\n", bb->index);
 501
 502       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 503         {
 504           gimple *stmt = gsi_stmt (i);
 505
 506           if (gimple_code (stmt) != GIMPLE_CALL)
 507             continue;
 508
 509           if (gimple_call_fndecl (stmt) == chkp_checkl_fndecl
 510               || gimple_call_fndecl (stmt) == chkp_checku_fndecl)
 511             {
 512               struct check_info ci;
 513
 514               chkp_fill_check_info (stmt, &ci);
 515               bbc->checks.safe_push (ci);
 516
 517               if (dump_file && (dump_flags & TDF_DETAILS))
 518                 {
 519                   fprintf (dump_file, "Adding check information:\n");
 520                   fprintf (dump_file, "  bounds: ");
 521                   print_generic_expr (dump_file, ci.bounds);
 522                   fprintf (dump_file, "\n  address: ");
 523                   chkp_print_addr (ci.addr);
 524                   fprintf (dump_file, "\n  check: ");
 525                   print_gimple_stmt (dump_file, stmt, 0);
 526                 }
 527             }
 528         }
 529     }
 530 }
 531
 532 /* Return 1 if check CI against BOUNDS always pass,
 533    -1 if check CI against BOUNDS always fails and
 534    0 if we cannot compute check result.  */
 535 static int
 536 chkp_get_check_result (struct check_info *ci, tree bounds)
 537 {
 538   gimple *bnd_def;
 539   address_t bound_val;
 540   int sign, res = 0;
 541
 542   if (dump_file && (dump_flags & TDF_DETAILS))
 543     {
 544       fprintf (dump_file, "Trying to compute result of the check\n");
 545       fprintf (dump_file, "  check: ");
 546       print_gimple_stmt (dump_file, ci->stmt, 0);
 547       fprintf (dump_file, "  address: ");
 548       chkp_print_addr (ci->addr);
 549       fprintf (dump_file, "\n  bounds: ");
 550       print_generic_expr (dump_file, bounds);
 551       fprintf (dump_file, "\n");
 552     }
 553
 554   if (TREE_CODE (bounds) != SSA_NAME)
 555     {
 556       if (dump_file && (dump_flags & TDF_DETAILS))
 557         fprintf (dump_file, "  result: bounds tree code is not ssa_name\n");
 558       return 0;
 559     }
 560
 561   bnd_def = SSA_NAME_DEF_STMT (bounds);
 562   /* Currently we handle cases when bounds are result of bndmk
 563      or loaded static bounds var.  */
 564   if (gimple_code (bnd_def) == GIMPLE_CALL
 565       && gimple_call_fndecl (bnd_def) == chkp_bndmk_fndecl)
 566     {
 567       bound_val.pol.create (0);
 568       chkp_collect_value (gimple_call_arg (bnd_def, 0), bound_val);
 569       if (ci->type == CHECK_UPPER_BOUND)
 570         {
 571           address_t size_val;
 572           size_val.pol.create (0);
 573           chkp_collect_value (gimple_call_arg (bnd_def, 1), size_val);
 574           chkp_add_addr_addr (bound_val, size_val);
 575           size_val.pol.release ();
 576           chkp_add_addr_item (bound_val, integer_minus_one_node, NULL);
 577         }
 578     }
 579   else if (gimple_code (bnd_def) == GIMPLE_ASSIGN
 580            && gimple_assign_rhs1 (bnd_def) == chkp_get_zero_bounds_var ())
 581     {
 582       if (dump_file && (dump_flags & TDF_DETAILS))
 583         fprintf (dump_file, "  result: always pass with zero bounds\n");
 584       return 1;
 585     }
 586   else if (gimple_code (bnd_def) == GIMPLE_ASSIGN
 587            && gimple_assign_rhs1 (bnd_def) == chkp_get_none_bounds_var ())
 588     {
 589       if (dump_file && (dump_flags & TDF_DETAILS))
 590         fprintf (dump_file, "  result: always fails with none bounds\n");
 591       return -1;
 592     }
 593   else if (gimple_code (bnd_def) == GIMPLE_ASSIGN
 594            && TREE_CODE (gimple_assign_rhs1 (bnd_def)) == VAR_DECL)
 595     {
 596       tree bnd_var = gimple_assign_rhs1 (bnd_def);
 597       tree var;
 598       tree size;
 599
 600       if (!DECL_INITIAL (bnd_var)
 601           || DECL_INITIAL (bnd_var) == error_mark_node)
 602         {
 603           if (dump_file && (dump_flags & TDF_DETAILS))
 604             fprintf (dump_file, "  result: cannot compute bounds\n");
 605           return 0;
 606         }
 607
 608       gcc_assert (TREE_CODE (DECL_INITIAL (bnd_var)) == ADDR_EXPR);
 609       var = TREE_OPERAND (DECL_INITIAL (bnd_var), 0);
 610
 611       bound_val.pol.create (0);
 612       chkp_collect_value (DECL_INITIAL (bnd_var), bound_val);
 613       if (ci->type == CHECK_UPPER_BOUND)
 614         {
 615           if (VAR_P (var))
 616             {
 617               if (DECL_SIZE (var)
 618                   && !chkp_variable_size_type (TREE_TYPE (var)))
 619                 size = DECL_SIZE_UNIT (var);
 620               else
 621                 {
 622                   if (dump_file && (dump_flags & TDF_DETAILS))
 623                     fprintf (dump_file, "  result: cannot compute bounds\n");
 624                   return 0;
 625                 }
 626             }
 627           else
 628             {
 629               gcc_assert (TREE_CODE (var) == STRING_CST);
 630               size = build_int_cst (size_type_node,
 631                                     TREE_STRING_LENGTH (var));
 632             }
 633
 634           address_t size_val;
 635           size_val.pol.create (0);
 636           chkp_collect_value (size, size_val);
 637           chkp_add_addr_addr (bound_val, size_val);
 638           size_val.pol.release ();
 639           chkp_add_addr_item (bound_val, integer_minus_one_node, NULL);
 640         }
 641     }
 642   else
 643     {
 644       if (dump_file && (dump_flags & TDF_DETAILS))
 645         fprintf (dump_file, "  result: cannot compute bounds\n");
 646       return 0;
 647     }
 648
 649   if (dump_file && (dump_flags & TDF_DETAILS))
 650     {
 651       fprintf (dump_file, "  bound value: ");
 652       chkp_print_addr (bound_val);
 653       fprintf (dump_file, "\n");
 654     }
 655
 656   chkp_sub_addr_addr (bound_val, ci->addr);
 657
 658   if (!chkp_is_constant_addr (bound_val, &sign))
 659     {
 660       if (dump_file && (dump_flags & TDF_DETAILS))
 661         fprintf (dump_file, "  result: cannot compute result\n");
 662
 663       res = 0;
 664     }
 665   else if (sign == 0
 666            || (ci->type == CHECK_UPPER_BOUND && sign > 0)
 667            || (ci->type == CHECK_LOWER_BOUND && sign < 0))
 668     {
 669       if (dump_file && (dump_flags & TDF_DETAILS))
 670         fprintf (dump_file, "  result: always pass\n");
 671
 672       res = 1;
 673     }
 674   else
 675     {
 676       if (dump_file && (dump_flags & TDF_DETAILS))
 677         fprintf (dump_file, "  result: always fail\n");
 678
 679       res = -1;
 680     }
 681
 682   bound_val.pol.release ();
 683
 684   return res;
 685 }
 686
 687 /* Try to compare bounds value and address value
 688    used in the check CI.  If we can prove that check
 689    always pass then remove it.  */
 690 static void
 691 chkp_remove_check_if_pass (struct check_info *ci)
 692 {
 693   int result = 0;
 694
 695   if (dump_file && (dump_flags & TDF_DETAILS))
 696     {
 697       fprintf (dump_file, "Trying to remove check: ");
 698       print_gimple_stmt (dump_file, ci->stmt, 0);
 699     }
 700
 701   result = chkp_get_check_result (ci, ci->bounds);
 702
 703   if (result == 1)
 704     {
 705       gimple_stmt_iterator i = gsi_for_stmt (ci->stmt);
 706
 707       if (dump_file && (dump_flags & TDF_DETAILS))
 708         fprintf (dump_file, "  action: delete check (always pass)\n");
 709
 710       gsi_remove (&i, true);
 711       unlink_stmt_vdef (ci->stmt);
 712       release_defs (ci->stmt);
 713       ci->stmt = NULL;
 714     }
 715   else if (result == -1)
 716     {
 717       if (dump_file && (dump_flags & TDF_DETAILS))
 718         fprintf (dump_file, "  action: keep check (always fail)\n");
 719       warning_at (gimple_location (ci->stmt), OPT_Wchkp,
 720                   "memory access check always fail");
 721     }
 722   else if (result == 0)
 723     {
 724       if (dump_file && (dump_flags & TDF_DETAILS))
 725         fprintf (dump_file, "  action: keep check (cannot compute result)\n");
 726     }
 727 }
 728
 729 /* For bounds used in CI check if bounds are produced by
 730    intersection and we may use outer bounds instead.  If
 731    transformation is possible then fix check statement and
 732    recompute its info.  */
 733 static void
 734 chkp_use_outer_bounds_if_possible (struct check_info *ci)
 735 {
 736   gimple *bnd_def;
 737   tree bnd1, bnd2, bnd_res = NULL;
 738   int check_res1, check_res2;
 739
 740   if (TREE_CODE (ci->bounds) != SSA_NAME)
 741     return;
 742
 743   bnd_def = SSA_NAME_DEF_STMT (ci->bounds);
 744   if (gimple_code (bnd_def) != GIMPLE_CALL
 745       || gimple_call_fndecl (bnd_def) != chkp_intersect_fndecl)
 746     return;
 747
 748   if (dump_file && (dump_flags & TDF_DETAILS))
 749     {
 750       fprintf (dump_file, "Check if bounds intersection is redundant: \n");
 751       fprintf (dump_file, "  check: ");
 752       print_gimple_stmt (dump_file, ci->stmt, 0);
 753       fprintf (dump_file, "  intersection: ");
 754       print_gimple_stmt (dump_file, bnd_def, 0);
 755       fprintf (dump_file, "\n");
 756     }
 757
 758   bnd1 = gimple_call_arg (bnd_def, 0);
 759   bnd2 = gimple_call_arg (bnd_def, 1);
 760
 761   check_res1 = chkp_get_check_result (ci, bnd1);
 762   check_res2 = chkp_get_check_result (ci, bnd2);
 763   if (check_res1 == 1)
 764     bnd_res = bnd2;
 765   else if (check_res1 == -1)
 766     bnd_res = bnd1;
 767   else if (check_res2 == 1)
 768     bnd_res = bnd1;
 769   else if (check_res2 == -1)
 770     bnd_res = bnd2;
 771
 772   if (bnd_res)
 773     {
 774       if (dump_file && (dump_flags & TDF_DETAILS))
 775         {
 776           fprintf (dump_file, "  action: use ");
 777           print_generic_expr (dump_file, bnd2);
 778           fprintf (dump_file, " instead of ");
 779           print_generic_expr (dump_file, ci->bounds);
 780           fprintf (dump_file, "\n");
 781         }
 782
 783       ci->bounds = bnd_res;
 784       gimple_call_set_arg (ci->stmt, 1, bnd_res);
 785       update_stmt (ci->stmt);
 786       chkp_fill_check_info (ci->stmt, ci);
 787     }
 788 }
 789
 790 /*  Try to find checks whose bounds were produced by intersection
 791     which does not affect check result.  In such check outer bounds
 792     are used instead.  It allows to remove excess intersections
 793     and helps to compare checks.  */
 794 static void
 795 chkp_remove_excess_intersections (void)
 796 {
 797   basic_block bb;
 798
 799   if (dump_file && (dump_flags & TDF_DETAILS))
 800     fprintf (dump_file, "Searching for redundant bounds intersections...\n");
 801
 802   FOR_EACH_BB_FN (bb, cfun)
 803     {
 804       struct bb_checks *bbc = &check_infos[bb->index];
 805       unsigned int no;
 806
 807       /* Iterate through all found checks in BB.  */
 808       for (no = 0; no < bbc->checks.length (); no++)
 809         if (bbc->checks[no].stmt)
 810           chkp_use_outer_bounds_if_possible (&bbc->checks[no]);
 811     }
 812 }
 813
 814 /*  Try to remove all checks which are known to alwyas pass.  */
 815 static void
 816 chkp_remove_constant_checks (void)
 817 {
 818   basic_block bb;
 819
 820   if (dump_file && (dump_flags & TDF_DETAILS))
 821     fprintf (dump_file, "Searching for redundant checks...\n");
 822
 823   FOR_EACH_BB_FN (bb, cfun)
 824     {
 825       struct bb_checks *bbc = &check_infos[bb->index];
 826       unsigned int no;
 827
 828       /* Iterate through all found checks in BB.  */
 829       for (no = 0; no < bbc->checks.length (); no++)
 830         if (bbc->checks[no].stmt)
 831           chkp_remove_check_if_pass (&bbc->checks[no]);
 832     }
 833 }
 834
 835 /* Return fast version of string function FNCODE.  */
 836 static tree
 837 chkp_get_nobnd_fndecl (enum built_in_function fncode)
 838 {
 839   /* Check if we are allowed to use fast string functions.  */
 840   if (!flag_chkp_use_fast_string_functions)
 841     return NULL_TREE;
 842
 843   tree fndecl = NULL_TREE;
 844
 845   switch (fncode)
 846     {
 847     case BUILT_IN_MEMCPY_CHKP:
 848       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND);
 849       break;
 850
 851     case BUILT_IN_MEMPCPY_CHKP:
 852       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMPCPY_NOBND);
 853       break;
 854
 855     case BUILT_IN_MEMMOVE_CHKP:
 856       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMMOVE_NOBND);
 857       break;
 858
 859     case BUILT_IN_MEMSET_CHKP:
 860       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMSET_NOBND);
 861       break;
 862
 863     case BUILT_IN_CHKP_MEMCPY_NOCHK_CHKP:
 864       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK);
 865       break;
 866
 867     case BUILT_IN_CHKP_MEMPCPY_NOCHK_CHKP:
 868       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK);
 869       break;
 870
 871     case BUILT_IN_CHKP_MEMMOVE_NOCHK_CHKP:
 872       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMMOVE_NOBND_NOCHK);
 873       break;
 874
 875     case BUILT_IN_CHKP_MEMSET_NOCHK_CHKP:
 876       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMSET_NOBND_NOCHK);
 877       break;
 878
 879     default:
 880       break;
 881     }
 882
 883   if (fndecl)
 884     fndecl = chkp_maybe_clone_builtin_fndecl (fndecl);
 885
 886   return fndecl;
 887 }
 888
 889
 890 /* Return no-check version of string function FNCODE.  */
 891 static tree
 892 chkp_get_nochk_fndecl (enum built_in_function fncode)
 893 {
 894   /* Check if we are allowed to use fast string functions.  */
 895   if (!flag_chkp_use_nochk_string_functions)
 896     return NULL_TREE;
 897
 898   tree fndecl = NULL_TREE;
 899
 900   switch (fncode)
 901     {
 902     case BUILT_IN_MEMCPY_CHKP:
 903       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOCHK);
 904       break;
 905
 906     case BUILT_IN_MEMPCPY_CHKP:
 907       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMPCPY_NOCHK);
 908       break;
 909
 910     case BUILT_IN_MEMMOVE_CHKP:
 911       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMMOVE_NOCHK);
 912       break;
 913
 914     case BUILT_IN_MEMSET_CHKP:
 915       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMSET_NOCHK);
 916       break;
 917
 918     case BUILT_IN_CHKP_MEMCPY_NOBND_CHKP:
 919       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK);
 920       break;
 921
 922     case BUILT_IN_CHKP_MEMPCPY_NOBND_CHKP:
 923       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK);
 924       break;
 925
 926     case BUILT_IN_CHKP_MEMMOVE_NOBND_CHKP:
 927       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMMOVE_NOBND_NOCHK);
 928       break;
 929
 930     case BUILT_IN_CHKP_MEMSET_NOBND_CHKP:
 931       fndecl = builtin_decl_implicit (BUILT_IN_CHKP_MEMSET_NOBND_NOCHK);
 932       break;
 933
 934     default:
 935       break;
 936     }
 937
 938   if (fndecl)
 939     fndecl = chkp_maybe_clone_builtin_fndecl (fndecl);
 940
 941   return fndecl;
 942 }
 943
 944 /* Find memcpy, mempcpy, memmove and memset calls, perform
 945    checks before call and then call no_chk version of
 946    functions.  We do it on O2 to enable inlining of these
 947    functions during expand.
 948
 949    Also try to find memcpy, mempcpy, memmove and memset calls
 950    which are known to not write pointers to memory and use
 951    faster function versions for them.  */
 952 static void
 953 chkp_optimize_string_function_calls (void)
 954 {
 955   basic_block bb;
 956
 957   if (dump_file && (dump_flags & TDF_DETAILS))
 958     fprintf (dump_file, "Searching for replaceable string function calls...\n");
 959
 960   FOR_EACH_BB_FN (bb, cfun)
 961     {
 962       gimple_stmt_iterator i;
 963
 964       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 965         {
 966           gimple *stmt = gsi_stmt (i);
 967           tree fndecl;
 968
 969           if (!is_gimple_call (stmt)
 970               || !gimple_call_with_bounds_p (stmt)
 971               || !gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
 972             continue;
 973
 974           fndecl = gimple_call_fndecl (stmt);
 975           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMCPY_CHKP
 976               || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMPCPY_CHKP
 977               || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMMOVE_CHKP
 978               || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMSET_CHKP)
 979             {
 980               tree dst = gimple_call_arg (stmt, 0);
 981               tree dst_bnd = gimple_call_arg (stmt, 1);
 982               bool is_memset = DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMSET_CHKP;
 983               tree size = gimple_call_arg (stmt, is_memset ? 3 : 4);
 984               tree fndecl_nochk;
 985               gimple_stmt_iterator j;
 986               basic_block check_bb;
 987               address_t size_val;
 988               int sign;
 989               bool known;
 990
 991               /* We may replace call with corresponding __chkp_*_nobnd
 992                  call in case destination pointer base type is not
 993                  void or pointer.  */
 994               if (POINTER_TYPE_P (TREE_TYPE (dst))
 995                   && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (dst)))
 996                   && !chkp_type_has_pointer (TREE_TYPE (TREE_TYPE (dst))))
 997                 {
 998                   tree fndecl_nobnd
 999                     = chkp_get_nobnd_fndecl (DECL_FUNCTION_CODE (fndecl));
1000
1001                   if (fndecl_nobnd)
1002                     fndecl = fndecl_nobnd;
1003                 }
1004
1005               fndecl_nochk = chkp_get_nochk_fndecl (DECL_FUNCTION_CODE (fndecl));
1006
1007               if (fndecl_nochk)
1008                 fndecl = fndecl_nochk;
1009
1010               if (fndecl != gimple_call_fndecl (stmt))
1011                 {
1012                   if (dump_file && (dump_flags & TDF_DETAILS))
1013                     {
1014                       fprintf (dump_file, "Replacing call: ");
1015                       print_gimple_stmt (dump_file, stmt, 0,
1016                                          TDF_VOPS|TDF_MEMSYMS);
1017                     }
1018
1019                   gimple_call_set_fndecl (stmt, fndecl);
1020
1021                   if (dump_file && (dump_flags & TDF_DETAILS))
1022                     {
1023                       fprintf (dump_file, "With a new call: ");
1024                       print_gimple_stmt (dump_file, stmt, 0,
1025                                          TDF_VOPS|TDF_MEMSYMS);
1026                     }
1027                 }
1028
1029               /* If there is no nochk version of function then
1030                  do nothing.  Otherwise insert checks before
1031                  the call.  */
1032               if (!fndecl_nochk)
1033                 continue;
1034
1035               /* If size passed to call is known and > 0
1036                  then we may insert checks unconditionally.  */
1037               size_val.pol.create (0);
1038               chkp_collect_value (size, size_val);
1039               known = chkp_is_constant_addr (size_val, &sign);
1040               size_val.pol.release ();
1041
1042               /* If we are not sure size is not zero then we have
1043                  to perform runtime check for size and perform
1044                  checks only when size is not zero.  */
1045               if (!known)
1046                 {
1047                   gimple *check = gimple_build_cond (NE_EXPR,
1048                                                      size,
1049                                                      size_zero_node,
1050                                                      NULL_TREE,
1051                                                      NULL_TREE);
1052
1053                   /* Split block before string function call.  */
1054                   gsi_prev (&i);
1055                   check_bb = insert_cond_bb (bb, gsi_stmt (i), check,
1056                                              profile_probability::likely ());
1057
1058                   /* Set position for checks.  */
1059                   j = gsi_last_bb (check_bb);
1060
1061                   /* The block was splitted and therefore we
1062                      need to set iterator to its end.  */
1063                   i = gsi_last_bb (bb);
1064                 }
1065               /* If size is known to be zero then no checks
1066                  should be performed.  */
1067               else if (!sign)
1068                 continue;
1069               else
1070                 j = i;
1071
1072               size = size_binop (MINUS_EXPR, size, size_one_node);
1073               if (!is_memset)
1074                 {
1075                   tree src = gimple_call_arg (stmt, 2);
1076                   tree src_bnd = gimple_call_arg (stmt, 3);
1077
1078                   chkp_check_mem_access (src, fold_build_pointer_plus (src, size),
1079                                          src_bnd, j, gimple_location (stmt),
1080                                          integer_zero_node);
1081                 }
1082
1083               chkp_check_mem_access (dst, fold_build_pointer_plus (dst, size),
1084                                      dst_bnd, j, gimple_location (stmt),
1085                                      integer_one_node);
1086
1087             }
1088         }
1089     }
1090 }
1091
1092 /* Intrumentation pass inserts most of bounds creation code
1093    in the header of the function.  We want to move bounds
1094    creation closer to bounds usage to reduce bounds lifetime.
1095    We also try to avoid bounds creation code on paths where
1096    bounds are not used.  */
1097 static void
1098 chkp_reduce_bounds_lifetime (void)
1099 {
1100   basic_block bb = FALLTHRU_EDGE (ENTRY_BLOCK_PTR_FOR_FN (cfun))->dest;
1101   gimple_stmt_iterator i;
1102
1103   for (i = gsi_start_bb (bb); !gsi_end_p (i); )
1104     {
1105       gimple *dom_use, *use_stmt, *stmt = gsi_stmt (i);
1106       basic_block dom_bb;
1107       ssa_op_iter iter;
1108       imm_use_iterator use_iter;
1109       use_operand_p use_p;
1110       tree op;
1111       bool want_move = false;
1112       bool deps = false;
1113
1114       if (gimple_code (stmt) == GIMPLE_CALL
1115           && gimple_call_fndecl (stmt) == chkp_bndmk_fndecl)
1116         want_move = true;
1117
1118       if (gimple_code (stmt) == GIMPLE_ASSIGN
1119           && POINTER_BOUNDS_P (gimple_assign_lhs (stmt))
1120           && gimple_assign_rhs_code (stmt) == VAR_DECL)
1121         want_move = true;
1122
1123       if (!want_move)
1124         {
1125           gsi_next (&i);
1126           continue;
1127         }
1128
1129       /* Check we do not increase other values lifetime.  */
1130       FOR_EACH_PHI_OR_STMT_USE (use_p, stmt, iter, SSA_OP_USE)
1131         {
1132           op = USE_FROM_PTR (use_p);
1133
1134           if (TREE_CODE (op) == SSA_NAME
1135               && gimple_code (SSA_NAME_DEF_STMT (op)) != GIMPLE_NOP)
1136             {
1137               deps = true;
1138               break;
1139             }
1140         }
1141
1142       if (deps)
1143         {
1144           gsi_next (&i);
1145           continue;
1146         }
1147
1148       /* Check all usages of bounds.  */
1149       if (gimple_code (stmt) == GIMPLE_CALL)
1150         op = gimple_call_lhs (stmt);
1151       else
1152         {
1153           gcc_assert (gimple_code (stmt) == GIMPLE_ASSIGN);
1154           op = gimple_assign_lhs (stmt);
1155         }
1156
1157       dom_use = NULL;
1158       dom_bb = NULL;
1159
1160       FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, op)
1161         {
1162           if (is_gimple_debug (use_stmt))
1163             continue;
1164
1165           if (dom_bb &&
1166               dominated_by_p (CDI_DOMINATORS,
1167                               dom_bb, gimple_bb (use_stmt)))
1168             {
1169               dom_use = use_stmt;
1170               dom_bb = NULL;
1171             }
1172           else if (dom_bb)
1173             dom_bb = nearest_common_dominator (CDI_DOMINATORS, dom_bb,
1174                                                gimple_bb (use_stmt));
1175           else if (!dom_use)
1176             dom_use = use_stmt;
1177           else if (stmt_dominates_stmt_p (use_stmt, dom_use))
1178             dom_use = use_stmt;
1179           else if (!stmt_dominates_stmt_p (dom_use, use_stmt)
1180                    /* If dom_use and use_stmt are PHI nodes in one BB
1181                       then it is OK to keep any of them as dom_use.
1182                       stmt_dominates_stmt_p returns 0 for such
1183                       combination, so check it here manually.  */
1184                    && (gimple_code (dom_use) != GIMPLE_PHI
1185                        || gimple_code (use_stmt) != GIMPLE_PHI
1186                        || gimple_bb (use_stmt) != gimple_bb (dom_use))
1187                    )
1188             {
1189               dom_bb = nearest_common_dominator (CDI_DOMINATORS,
1190                                                  gimple_bb (use_stmt),
1191                                                  gimple_bb (dom_use));
1192               dom_use = NULL;
1193             }
1194         }
1195
1196       /* In case there is a single use, just move bounds
1197          creation to the use.  */
1198       if (dom_use || dom_bb)
1199         {
1200           if (dump_file && (dump_flags & TDF_DETAILS))
1201             {
1202               fprintf (dump_file, "Moving creation of ");
1203               print_generic_expr (dump_file, op);
1204               fprintf (dump_file, " down to its use.\n");
1205             }
1206
1207           if (dom_use && gimple_code (dom_use) == GIMPLE_PHI)
1208             {
1209               dom_bb = get_immediate_dominator (CDI_DOMINATORS,
1210                                                 gimple_bb (dom_use));
1211               dom_use = NULL;
1212             }
1213
1214           if (dom_bb == bb
1215               || (dom_use && gimple_bb (dom_use) == bb))
1216             {
1217                   if (dump_file && (dump_flags & TDF_DETAILS))
1218                     fprintf (dump_file, "Cannot move statement bacause there is no "
1219                              "suitable dominator block other than entry block.\n");
1220
1221                   gsi_next (&i);
1222             }
1223           else
1224             {
1225               if (dom_bb)
1226                 {
1227                   gimple_stmt_iterator last = gsi_last_bb (dom_bb);
1228                   if (!gsi_end_p (last) && stmt_ends_bb_p (gsi_stmt (last)))
1229                     gsi_move_before (&i, &last);
1230                   else
1231                     gsi_move_after (&i, &last);
1232                 }
1233               else
1234                 {
1235                   gimple_stmt_iterator gsi = gsi_for_stmt (dom_use);
1236                   gsi_move_before (&i, &gsi);
1237                 }
1238
1239               gimple_set_vdef (stmt, NULL_TREE);
1240               gimple_set_vuse (stmt, NULL_TREE);
1241               update_stmt (stmt);
1242             }
1243         }
1244       else
1245         gsi_next (&i);
1246     }
1247 }
1248
1249 /* Initilize checker optimization pass.  */
1250 static void
1251 chkp_opt_init (void)
1252 {
1253   check_infos.create (0);
1254
1255   calculate_dominance_info (CDI_DOMINATORS);
1256   calculate_dominance_info (CDI_POST_DOMINATORS);
1257
1258   /* With LTO constant bounds vars may be not initialized by now.
1259      Get constant bounds vars to handle their assignments during
1260      optimizations.  */
1261   chkp_get_zero_bounds_var ();
1262   chkp_get_none_bounds_var ();
1263 }
1264
1265 /* Finalise checker optimization  pass.  */
1266 static void
1267 chkp_opt_fini (void)
1268 {
1269   chkp_fix_cfg ();
1270
1271   free_dominance_info (CDI_POST_DOMINATORS);
1272 }
1273
1274 /* Checker optimization pass function.  */
1275 static unsigned int
1276 chkp_opt_execute (void)
1277 {
1278   chkp_opt_init();
1279
1280   /* This optimization may introduce new checks
1281      and thus we put it before checks search.  */
1282   chkp_optimize_string_function_calls ();
1283
1284   chkp_gather_checks_info ();
1285
1286   chkp_remove_excess_intersections ();
1287
1288   chkp_remove_constant_checks ();
1289
1290   chkp_reduce_bounds_lifetime ();
1291
1292   chkp_release_check_info ();
1293
1294   chkp_opt_fini ();
1295
1296   return 0;
1297 }
1298
1299 /* Pass gate.  */
1300 static bool
1301 chkp_opt_gate (void)
1302 {
1303   return chkp_function_instrumented_p (cfun->decl)
1304     && (flag_chkp_optimize > 0
1305         || (flag_chkp_optimize == -1 && optimize > 0));
1306 }
1307
1308 namespace {
1309
1310 const pass_data pass_data_chkp_opt =
1311 {
1312   GIMPLE_PASS, /* type */
1313   "chkpopt", /* name */
1314   OPTGROUP_NONE, /* optinfo_flags */
1315   TV_NONE, /* tv_id */
1316   PROP_ssa | PROP_cfg, /* properties_required */
1317   0, /* properties_provided */
1318   0, /* properties_destroyed */
1319   0, /* todo_flags_start */
1320   TODO_verify_il
1321   | TODO_update_ssa /* todo_flags_finish */
1322 };
1323
1324 class pass_chkp_opt : public gimple_opt_pass
1325 {
1326 public:
1327   pass_chkp_opt (gcc::context *ctxt)
1328     : gimple_opt_pass (pass_data_chkp_opt, ctxt)
1329   {}
1330
1331   /* opt_pass methods: */
1332   virtual opt_pass * clone ()
1333     {
1334       return new pass_chkp_opt (m_ctxt);
1335     }
1336
1337   virtual bool gate (function *)
1338     {
1339       return chkp_opt_gate ();
1340     }
1341
1342   virtual unsigned int execute (function *)
1343     {
1344       return chkp_opt_execute ();
1345     }
1346
1347 }; // class pass_chkp_opt
1348
1349 } // anon namespace
1350
1351 gimple_opt_pass *
1352 make_pass_chkp_opt (gcc::context *ctxt)
1353 {
1354   return new pass_chkp_opt (ctxt);
1355 }