gcc/sanopt.cc

   1 /* Optimize and expand sanitizer functions.
   2    Copyright (C) 2014-2022 Free Software Foundation, Inc.
   3    Contributed by Marek Polacek <polacek@redhat.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 "tree.h"
  26 #include "gimple.h"
  27 #include "ssa.h"
  28 #include "tree-pass.h"
  29 #include "tree-ssa-operands.h"
  30 #include "gimple-pretty-print.h"
  31 #include "fold-const.h"
  32 #include "gimple-iterator.h"
  33 #include "stringpool.h"
  34 #include "attribs.h"
  35 #include "asan.h"
  36 #include "ubsan.h"
  37 #include "tree-hash-traits.h"
  38 #include "gimple-ssa.h"
  39 #include "tree-phinodes.h"
  40 #include "ssa-iterators.h"
  41 #include "gimplify.h"
  42 #include "gimple-iterator.h"
  43 #include "gimple-walk.h"
  44 #include "cfghooks.h"
  45 #include "tree-dfa.h"
  46 #include "tree-ssa.h"
  47 #include "varasm.h"
  48
  49 /* This is used to carry information about basic blocks.  It is
  50    attached to the AUX field of the standard CFG block.  */
  51
  52 struct sanopt_info
  53 {
  54   /* True if this BB might call (directly or indirectly) free/munmap
  55      or similar operation.  */
  56   bool has_freeing_call_p;
  57
  58   /* True if HAS_FREEING_CALL_P flag has been computed.  */
  59   bool has_freeing_call_computed_p;
  60
  61   /* True if there is a block with HAS_FREEING_CALL_P flag set
  62      on any path between an immediate dominator of BB, denoted
  63      imm(BB), and BB.  */
  64   bool imm_dom_path_with_freeing_call_p;
  65
  66   /* True if IMM_DOM_PATH_WITH_FREEING_CALL_P has been computed.  */
  67   bool imm_dom_path_with_freeing_call_computed_p;
  68
  69   /* Number of possibly freeing calls encountered in this bb
  70      (so far).  */
  71   uint64_t freeing_call_events;
  72
  73   /* True if BB is currently being visited during computation
  74      of IMM_DOM_PATH_WITH_FREEING_CALL_P flag.  */
  75   bool being_visited_p;
  76
  77   /* True if this BB has been visited in the dominator walk.  */
  78   bool visited_p;
  79 };
  80
  81 /* If T has a single definition of form T = T2, return T2.  */
  82
  83 static tree
  84 maybe_get_single_definition (tree t)
  85 {
  86   if (TREE_CODE (t) == SSA_NAME)
  87     {
  88       gimple *g = SSA_NAME_DEF_STMT (t);
  89       if (gimple_assign_single_p (g))
  90         return gimple_assign_rhs1 (g);
  91     }
  92   return NULL_TREE;
  93 }
  94
  95 /* Tree triplet for vptr_check_map.  */
  96 struct sanopt_tree_triplet
  97 {
  98   tree t1, t2, t3;
  99 };
 100
 101 /* Traits class for tree triplet hash maps below.  */
 102
 103 struct sanopt_tree_triplet_hash : typed_noop_remove <sanopt_tree_triplet>
 104 {
 105   typedef sanopt_tree_triplet value_type;
 106   typedef sanopt_tree_triplet compare_type;
 107
 108   static hashval_t
 109   hash (const sanopt_tree_triplet &ref)
 110   {
 111     inchash::hash hstate (0);
 112     inchash::add_expr (ref.t1, hstate);
 113     inchash::add_expr (ref.t2, hstate);
 114     inchash::add_expr (ref.t3, hstate);
 115     return hstate.end ();
 116   }
 117
 118   static bool
 119   equal (const sanopt_tree_triplet &ref1, const sanopt_tree_triplet &ref2)
 120   {
 121     return operand_equal_p (ref1.t1, ref2.t1, 0)
 122            && operand_equal_p (ref1.t2, ref2.t2, 0)
 123            && operand_equal_p (ref1.t3, ref2.t3, 0);
 124   }
 125
 126   static void
 127   mark_deleted (sanopt_tree_triplet &ref)
 128   {
 129     ref.t1 = reinterpret_cast<tree> (1);
 130   }
 131
 132   static const bool empty_zero_p = true;
 133
 134   static void
 135   mark_empty (sanopt_tree_triplet &ref)
 136   {
 137     ref.t1 = NULL;
 138   }
 139
 140   static bool
 141   is_deleted (const sanopt_tree_triplet &ref)
 142   {
 143     return ref.t1 == reinterpret_cast<tree> (1);
 144   }
 145
 146   static bool
 147   is_empty (const sanopt_tree_triplet &ref)
 148   {
 149     return ref.t1 == NULL;
 150   }
 151 };
 152
 153 /* Tree couple for ptr_check_map.  */
 154 struct sanopt_tree_couple
 155 {
 156   tree ptr;
 157   bool pos_p;
 158 };
 159
 160 /* Traits class for tree triplet hash maps below.  */
 161
 162 struct sanopt_tree_couple_hash : typed_noop_remove <sanopt_tree_couple>
 163 {
 164   typedef sanopt_tree_couple value_type;
 165   typedef sanopt_tree_couple compare_type;
 166
 167   static hashval_t
 168   hash (const sanopt_tree_couple &ref)
 169   {
 170     inchash::hash hstate (0);
 171     inchash::add_expr (ref.ptr, hstate);
 172     hstate.add_int (ref.pos_p);
 173     return hstate.end ();
 174   }
 175
 176   static bool
 177   equal (const sanopt_tree_couple &ref1, const sanopt_tree_couple &ref2)
 178   {
 179     return operand_equal_p (ref1.ptr, ref2.ptr, 0)
 180            && ref1.pos_p == ref2.pos_p;
 181   }
 182
 183   static void
 184   mark_deleted (sanopt_tree_couple &ref)
 185   {
 186     ref.ptr = reinterpret_cast<tree> (1);
 187   }
 188
 189   static const bool empty_zero_p = true;
 190
 191   static void
 192   mark_empty (sanopt_tree_couple &ref)
 193   {
 194     ref.ptr = NULL;
 195   }
 196
 197   static bool
 198   is_deleted (const sanopt_tree_couple &ref)
 199   {
 200     return ref.ptr == reinterpret_cast<tree> (1);
 201   }
 202
 203   static bool
 204   is_empty (const sanopt_tree_couple &ref)
 205   {
 206     return ref.ptr == NULL;
 207   }
 208 };
 209
 210 /* This is used to carry various hash maps and variables used
 211    in sanopt_optimize_walker.  */
 212
 213 class sanopt_ctx
 214 {
 215 public:
 216   /* This map maps a pointer (the first argument of UBSAN_NULL) to
 217      a vector of UBSAN_NULL call statements that check this pointer.  */
 218   hash_map<tree, auto_vec<gimple *> > null_check_map;
 219
 220   /* This map maps a pointer (the second argument of ASAN_CHECK) to
 221      a vector of ASAN_CHECK call statements that check the access.  */
 222   hash_map<tree_operand_hash, auto_vec<gimple *> > asan_check_map;
 223
 224   /* This map maps a tree triplet (the first, second and fourth argument
 225      of UBSAN_VPTR) to a vector of UBSAN_VPTR call statements that check
 226      that virtual table pointer.  */
 227   hash_map<sanopt_tree_triplet_hash, auto_vec<gimple *> > vptr_check_map;
 228
 229   /* This map maps a couple (tree and boolean) to a vector of UBSAN_PTR
 230      call statements that check that pointer overflow.  */
 231   hash_map<sanopt_tree_couple_hash, auto_vec<gimple *> > ptr_check_map;
 232
 233   /* Number of IFN_ASAN_CHECK statements.  */
 234   int asan_num_accesses;
 235
 236   /* True when the current functions constains an ASAN_MARK.  */
 237   bool contains_asan_mark;
 238 };
 239
 240 /* Return true if there might be any call to free/munmap operation
 241    on any path in between DOM (which should be imm(BB)) and BB.  */
 242
 243 static bool
 244 imm_dom_path_with_freeing_call (basic_block bb, basic_block dom)
 245 {
 246   sanopt_info *info = (sanopt_info *) bb->aux;
 247   edge e;
 248   edge_iterator ei;
 249
 250   if (info->imm_dom_path_with_freeing_call_computed_p)
 251     return info->imm_dom_path_with_freeing_call_p;
 252
 253   info->being_visited_p = true;
 254
 255   FOR_EACH_EDGE (e, ei, bb->preds)
 256     {
 257       sanopt_info *pred_info = (sanopt_info *) e->src->aux;
 258
 259       if (e->src == dom)
 260         continue;
 261
 262       if ((pred_info->imm_dom_path_with_freeing_call_computed_p
 263           && pred_info->imm_dom_path_with_freeing_call_p)
 264           || (pred_info->has_freeing_call_computed_p
 265               && pred_info->has_freeing_call_p))
 266         {
 267           info->imm_dom_path_with_freeing_call_computed_p = true;
 268           info->imm_dom_path_with_freeing_call_p = true;
 269           info->being_visited_p = false;
 270           return true;
 271         }
 272     }
 273
 274   FOR_EACH_EDGE (e, ei, bb->preds)
 275     {
 276       sanopt_info *pred_info = (sanopt_info *) e->src->aux;
 277
 278       if (e->src == dom)
 279         continue;
 280
 281       if (pred_info->has_freeing_call_computed_p)
 282         continue;
 283
 284       gimple_stmt_iterator gsi;
 285       for (gsi = gsi_start_bb (e->src); !gsi_end_p (gsi); gsi_next (&gsi))
 286         {
 287           gimple *stmt = gsi_stmt (gsi);
 288           gasm *asm_stmt;
 289
 290           if ((is_gimple_call (stmt) && !nonfreeing_call_p (stmt))
 291               || ((asm_stmt = dyn_cast <gasm *> (stmt))
 292                   && (gimple_asm_clobbers_memory_p (asm_stmt)
 293                       || gimple_asm_volatile_p (asm_stmt))))
 294             {
 295               pred_info->has_freeing_call_p = true;
 296               break;
 297             }
 298         }
 299
 300       pred_info->has_freeing_call_computed_p = true;
 301       if (pred_info->has_freeing_call_p)
 302         {
 303           info->imm_dom_path_with_freeing_call_computed_p = true;
 304           info->imm_dom_path_with_freeing_call_p = true;
 305           info->being_visited_p = false;
 306           return true;
 307         }
 308     }
 309
 310   FOR_EACH_EDGE (e, ei, bb->preds)
 311     {
 312       if (e->src == dom)
 313         continue;
 314
 315       basic_block src;
 316       for (src = e->src; src != dom; )
 317         {
 318           sanopt_info *pred_info = (sanopt_info *) src->aux;
 319           if (pred_info->being_visited_p)
 320             break;
 321           basic_block imm = get_immediate_dominator (CDI_DOMINATORS, src);
 322           if (imm_dom_path_with_freeing_call (src, imm))
 323             {
 324               info->imm_dom_path_with_freeing_call_computed_p = true;
 325               info->imm_dom_path_with_freeing_call_p = true;
 326               info->being_visited_p = false;
 327               return true;
 328             }
 329           src = imm;
 330         }
 331     }
 332
 333   info->imm_dom_path_with_freeing_call_computed_p = true;
 334   info->imm_dom_path_with_freeing_call_p = false;
 335   info->being_visited_p = false;
 336   return false;
 337 }
 338
 339 /* Get the first dominating check from the list of stored checks.
 340    Non-dominating checks are silently dropped.  */
 341
 342 static gimple *
 343 maybe_get_dominating_check (auto_vec<gimple *> &v)
 344 {
 345   for (; !v.is_empty (); v.pop ())
 346     {
 347       gimple *g = v.last ();
 348       sanopt_info *si = (sanopt_info *) gimple_bb (g)->aux;
 349       if (!si->visited_p)
 350         /* At this point we shouldn't have any statements
 351            that aren't dominating the current BB.  */
 352         return g;
 353     }
 354   return NULL;
 355 }
 356
 357 /* Optimize away redundant UBSAN_NULL calls.  */
 358
 359 static bool
 360 maybe_optimize_ubsan_null_ifn (class sanopt_ctx *ctx, gimple *stmt)
 361 {
 362   gcc_assert (gimple_call_num_args (stmt) == 3);
 363   tree ptr = gimple_call_arg (stmt, 0);
 364   tree cur_align = gimple_call_arg (stmt, 2);
 365   gcc_assert (TREE_CODE (cur_align) == INTEGER_CST);
 366   bool remove = false;
 367
 368   auto_vec<gimple *> &v = ctx->null_check_map.get_or_insert (ptr);
 369   gimple *g = maybe_get_dominating_check (v);
 370   if (!g)
 371     {
 372       /* For this PTR we don't have any UBSAN_NULL stmts recorded, so there's
 373          nothing to optimize yet.  */
 374       v.safe_push (stmt);
 375       return false;
 376     }
 377
 378   /* We already have recorded a UBSAN_NULL check for this pointer. Perhaps we
 379      can drop this one.  But only if this check doesn't specify stricter
 380      alignment.  */
 381
 382   tree align = gimple_call_arg (g, 2);
 383   int kind = tree_to_shwi (gimple_call_arg (g, 1));
 384   /* If this is a NULL pointer check where we had segv anyway, we can
 385      remove it.  */
 386   if (integer_zerop (align)
 387       && (kind == UBSAN_LOAD_OF
 388           || kind == UBSAN_STORE_OF
 389           || kind == UBSAN_MEMBER_ACCESS))
 390     remove = true;
 391   /* Otherwise remove the check in non-recovering mode, or if the
 392      stmts have same location.  */
 393   else if (integer_zerop (align))
 394     remove = (flag_sanitize_recover & SANITIZE_NULL) == 0
 395               || (flag_sanitize_trap & SANITIZE_NULL) != 0
 396               || gimple_location (g) == gimple_location (stmt);
 397   else if (tree_int_cst_le (cur_align, align))
 398     remove = (flag_sanitize_recover & SANITIZE_ALIGNMENT) == 0
 399               || (flag_sanitize_trap & SANITIZE_ALIGNMENT) != 0
 400               || gimple_location (g) == gimple_location (stmt);
 401
 402   if (!remove && gimple_bb (g) == gimple_bb (stmt)
 403       && tree_int_cst_compare (cur_align, align) == 0)
 404     v.pop ();
 405
 406   if (!remove)
 407     v.safe_push (stmt);
 408   return remove;
 409 }
 410
 411 /* Return true when pointer PTR for a given CUR_OFFSET is already sanitized
 412    in a given sanitization context CTX.  */
 413
 414 static bool
 415 has_dominating_ubsan_ptr_check (sanopt_ctx *ctx, tree ptr,
 416                                 offset_int &cur_offset)
 417 {
 418   bool pos_p = !wi::neg_p (cur_offset);
 419   sanopt_tree_couple couple;
 420   couple.ptr = ptr;
 421   couple.pos_p = pos_p;
 422
 423   auto_vec<gimple *> &v = ctx->ptr_check_map.get_or_insert (couple);
 424   gimple *g = maybe_get_dominating_check (v);
 425   if (!g)
 426     return false;
 427
 428   /* We already have recorded a UBSAN_PTR check for this pointer.  Perhaps we
 429      can drop this one.  But only if this check doesn't specify larger offset.
 430      */
 431   tree offset = gimple_call_arg (g, 1);
 432   gcc_assert (TREE_CODE (offset) == INTEGER_CST);
 433   offset_int ooffset = wi::sext (wi::to_offset (offset), POINTER_SIZE);
 434
 435   if (pos_p)
 436     {
 437       if (wi::les_p (cur_offset, ooffset))
 438         return true;
 439     }
 440   else if (!pos_p && wi::les_p (ooffset, cur_offset))
 441     return true;
 442
 443   return false;
 444 }
 445
 446 /* Record UBSAN_PTR check of given context CTX.  Register pointer PTR on
 447    a given OFFSET that it's handled by GIMPLE STMT.  */
 448
 449 static void
 450 record_ubsan_ptr_check_stmt (sanopt_ctx *ctx, gimple *stmt, tree ptr,
 451                              const offset_int &offset)
 452 {
 453   sanopt_tree_couple couple;
 454   couple.ptr = ptr;
 455   couple.pos_p = !wi::neg_p (offset);
 456
 457   auto_vec<gimple *> &v = ctx->ptr_check_map.get_or_insert (couple);
 458   v.safe_push (stmt);
 459 }
 460
 461 /* Optimize away redundant UBSAN_PTR calls.  */
 462
 463 static bool
 464 maybe_optimize_ubsan_ptr_ifn (sanopt_ctx *ctx, gimple *stmt)
 465 {
 466   poly_int64 bitsize, pbitpos;
 467   machine_mode mode;
 468   int volatilep = 0, reversep, unsignedp = 0;
 469   tree offset;
 470
 471   gcc_assert (gimple_call_num_args (stmt) == 2);
 472   tree ptr = gimple_call_arg (stmt, 0);
 473   tree off = gimple_call_arg (stmt, 1);
 474
 475   if (TREE_CODE (off) != INTEGER_CST)
 476     return false;
 477
 478   if (integer_zerop (off))
 479     return true;
 480
 481   offset_int cur_offset = wi::sext (wi::to_offset (off), POINTER_SIZE);
 482   if (has_dominating_ubsan_ptr_check (ctx, ptr, cur_offset))
 483     return true;
 484
 485   tree base = ptr;
 486   if (TREE_CODE (base) == ADDR_EXPR)
 487     {
 488       base = TREE_OPERAND (base, 0);
 489
 490       HOST_WIDE_INT bitpos;
 491       base = get_inner_reference (base, &bitsize, &pbitpos, &offset, &mode,
 492                                   &unsignedp, &reversep, &volatilep);
 493       if ((offset == NULL_TREE || TREE_CODE (offset) == INTEGER_CST)
 494           && DECL_P (base)
 495           && ((!VAR_P (base)
 496                && TREE_CODE (base) != PARM_DECL
 497                && TREE_CODE (base) != RESULT_DECL)
 498               || !DECL_REGISTER (base))
 499           && pbitpos.is_constant (&bitpos))
 500         {
 501           offset_int expr_offset;
 502           if (offset)
 503             expr_offset = wi::to_offset (offset) + bitpos / BITS_PER_UNIT;
 504           else
 505             expr_offset = bitpos / BITS_PER_UNIT;
 506           expr_offset = wi::sext (expr_offset, POINTER_SIZE);
 507           offset_int total_offset = expr_offset + cur_offset;
 508           if (total_offset != wi::sext (total_offset, POINTER_SIZE))
 509             {
 510               record_ubsan_ptr_check_stmt (ctx, stmt, ptr, cur_offset);
 511               return false;
 512             }
 513
 514           /* If BASE is a fixed size automatic variable or
 515              global variable defined in the current TU, we don't have
 516              to instrument anything if offset is within address
 517              of the variable.  */
 518           if ((VAR_P (base)
 519                || TREE_CODE (base) == PARM_DECL
 520                || TREE_CODE (base) == RESULT_DECL)
 521               && DECL_SIZE_UNIT (base)
 522               && TREE_CODE (DECL_SIZE_UNIT (base)) == INTEGER_CST
 523               && (!is_global_var (base) || decl_binds_to_current_def_p (base)))
 524             {
 525               offset_int base_size = wi::to_offset (DECL_SIZE_UNIT (base));
 526               if (!wi::neg_p (expr_offset)
 527                   && wi::les_p (total_offset, base_size))
 528                 {
 529                   if (!wi::neg_p (total_offset)
 530                       && wi::les_p (total_offset, base_size))
 531                     return true;
 532                 }
 533             }
 534
 535           /* Following expression: UBSAN_PTR (&MEM_REF[ptr + x], y) can be
 536              handled as follows:
 537
 538              1) sign (x) == sign (y), then check for dominating check of (x + y)
 539              2) sign (x) != sign (y), then first check if we have a dominating
 540                 check for ptr + x.  If so, then we have 2 situations:
 541                 a) sign (x) == sign (x + y), here we are done, example:
 542                    UBSAN_PTR (&MEM_REF[ptr + 100], -50)
 543                 b) check for dominating check of ptr + x + y.
 544              */
 545
 546           bool sign_cur_offset = !wi::neg_p (cur_offset);
 547           bool sign_expr_offset = !wi::neg_p (expr_offset);
 548
 549           tree base_addr
 550             = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (base)), base);
 551
 552           bool add = false;
 553           if (sign_cur_offset == sign_expr_offset)
 554             {
 555               if (has_dominating_ubsan_ptr_check (ctx, base_addr, total_offset))
 556                 return true;
 557               else
 558                 add = true;
 559             }
 560           else
 561             {
 562               if (!has_dominating_ubsan_ptr_check (ctx, base_addr, expr_offset))
 563                 ; /* Don't record base_addr + expr_offset, it's not a guarding
 564                      check.  */
 565               else
 566                 {
 567                   bool sign_total_offset = !wi::neg_p (total_offset);
 568                   if (sign_expr_offset == sign_total_offset)
 569                     return true;
 570                   else
 571                     {
 572                       if (has_dominating_ubsan_ptr_check (ctx, base_addr,
 573                                                           total_offset))
 574                         return true;
 575                       else
 576                         add = true;
 577                     }
 578                 }
 579             }
 580
 581           /* Record a new dominating check for base_addr + total_offset.  */
 582           if (add && !operand_equal_p (base, base_addr, 0))
 583             record_ubsan_ptr_check_stmt (ctx, stmt, base_addr,
 584                                          total_offset);
 585         }
 586     }
 587
 588   /* For this PTR we don't have any UBSAN_PTR stmts recorded, so there's
 589      nothing to optimize yet.  */
 590   record_ubsan_ptr_check_stmt (ctx, stmt, ptr, cur_offset);
 591
 592   return false;
 593 }
 594
 595 /* Optimize away redundant UBSAN_VPTR calls.  The second argument
 596    is the value loaded from the virtual table, so rely on FRE to find out
 597    when we can actually optimize.  */
 598
 599 static bool
 600 maybe_optimize_ubsan_vptr_ifn (class sanopt_ctx *ctx, gimple *stmt)
 601 {
 602   gcc_assert (gimple_call_num_args (stmt) == 5);
 603   sanopt_tree_triplet triplet;
 604   triplet.t1 = gimple_call_arg (stmt, 0);
 605   triplet.t2 = gimple_call_arg (stmt, 1);
 606   triplet.t3 = gimple_call_arg (stmt, 3);
 607
 608   auto_vec<gimple *> &v = ctx->vptr_check_map.get_or_insert (triplet);
 609   gimple *g = maybe_get_dominating_check (v);
 610   if (!g)
 611     {
 612       /* For this PTR we don't have any UBSAN_VPTR stmts recorded, so there's
 613          nothing to optimize yet.  */
 614       v.safe_push (stmt);
 615       return false;
 616     }
 617
 618   return true;
 619 }
 620
 621 /* Returns TRUE if ASan check of length LEN in block BB can be removed
 622    if preceded by checks in V.  */
 623
 624 static bool
 625 can_remove_asan_check (auto_vec<gimple *> &v, tree len, basic_block bb)
 626 {
 627   unsigned int i;
 628   gimple *g;
 629   gimple *to_pop = NULL;
 630   bool remove = false;
 631   basic_block last_bb = bb;
 632   bool cleanup = false;
 633
 634   FOR_EACH_VEC_ELT_REVERSE (v, i, g)
 635     {
 636       basic_block gbb = gimple_bb (g);
 637       sanopt_info *si = (sanopt_info *) gbb->aux;
 638       if (gimple_uid (g) < si->freeing_call_events)
 639         {
 640           /* If there is a potentially freeing call after g in gbb, we should
 641              remove it from the vector, can't use in optimization.  */
 642           cleanup = true;
 643           continue;
 644         }
 645
 646       tree glen = gimple_call_arg (g, 2);
 647       gcc_assert (TREE_CODE (glen) == INTEGER_CST);
 648
 649       /* If we've checked only smaller length than we want to check now,
 650          we can't remove the current stmt.  If g is in the same basic block,
 651          we want to remove it though, as the current stmt is better.  */
 652       if (tree_int_cst_lt (glen, len))
 653         {
 654           if (gbb == bb)
 655             {
 656               to_pop = g;
 657               cleanup = true;
 658             }
 659           continue;
 660         }
 661
 662       while (last_bb != gbb)
 663         {
 664           /* Paths from last_bb to bb have been checked before.
 665              gbb is necessarily a dominator of last_bb, but not necessarily
 666              immediate dominator.  */
 667           if (((sanopt_info *) last_bb->aux)->freeing_call_events)
 668             break;
 669
 670           basic_block imm = get_immediate_dominator (CDI_DOMINATORS, last_bb);
 671           gcc_assert (imm);
 672           if (imm_dom_path_with_freeing_call (last_bb, imm))
 673             break;
 674
 675           last_bb = imm;
 676         }
 677       if (last_bb == gbb)
 678         remove = true;
 679       break;
 680     }
 681
 682   if (cleanup)
 683     {
 684       unsigned int j = 0, l = v.length ();
 685       for (i = 0; i < l; i++)
 686         if (v[i] != to_pop
 687             && (gimple_uid (v[i])
 688                 == ((sanopt_info *)
 689                     gimple_bb (v[i])->aux)->freeing_call_events))
 690           {
 691             if (i != j)
 692               v[j] = v[i];
 693             j++;
 694           }
 695       v.truncate (j);
 696     }
 697
 698   return remove;
 699 }
 700
 701 /* Optimize away redundant ASAN_CHECK calls.  */
 702
 703 static bool
 704 maybe_optimize_asan_check_ifn (class sanopt_ctx *ctx, gimple *stmt)
 705 {
 706   gcc_assert (gimple_call_num_args (stmt) == 4);
 707   tree ptr = gimple_call_arg (stmt, 1);
 708   tree len = gimple_call_arg (stmt, 2);
 709   basic_block bb = gimple_bb (stmt);
 710   sanopt_info *info = (sanopt_info *) bb->aux;
 711
 712   if (TREE_CODE (len) != INTEGER_CST)
 713     return false;
 714   if (integer_zerop (len))
 715     return false;
 716
 717   gimple_set_uid (stmt, info->freeing_call_events);
 718
 719   auto_vec<gimple *> *ptr_checks = &ctx->asan_check_map.get_or_insert (ptr);
 720
 721   tree base_addr = maybe_get_single_definition (ptr);
 722   auto_vec<gimple *> *base_checks = NULL;
 723   if (base_addr)
 724     {
 725       base_checks = &ctx->asan_check_map.get_or_insert (base_addr);
 726       /* Original pointer might have been invalidated.  */
 727       ptr_checks = ctx->asan_check_map.get (ptr);
 728     }
 729
 730   gimple *g = maybe_get_dominating_check (*ptr_checks);
 731   gimple *g2 = NULL;
 732
 733   if (base_checks)
 734     /* Try with base address as well.  */
 735     g2 = maybe_get_dominating_check (*base_checks);
 736
 737   if (g == NULL && g2 == NULL)
 738     {
 739       /* For this PTR we don't have any ASAN_CHECK stmts recorded, so there's
 740          nothing to optimize yet.  */
 741       ptr_checks->safe_push (stmt);
 742       if (base_checks)
 743         base_checks->safe_push (stmt);
 744       return false;
 745     }
 746
 747   bool remove = false;
 748
 749   if (ptr_checks)
 750     remove = can_remove_asan_check (*ptr_checks, len, bb);
 751
 752   if (!remove && base_checks)
 753     /* Try with base address as well.  */
 754     remove = can_remove_asan_check (*base_checks, len, bb);
 755
 756   if (!remove)
 757     {
 758       ptr_checks->safe_push (stmt);
 759       if (base_checks)
 760         base_checks->safe_push (stmt);
 761     }
 762
 763   return remove;
 764 }
 765
 766 /* Try to optimize away redundant UBSAN_NULL and ASAN_CHECK calls.
 767
 768    We walk blocks in the CFG via a depth first search of the dominator
 769    tree; we push unique UBSAN_NULL or ASAN_CHECK statements into a vector
 770    in the NULL_CHECK_MAP or ASAN_CHECK_MAP hash maps as we enter the
 771    blocks.  When leaving a block, we mark the block as visited; then
 772    when checking the statements in the vector, we ignore statements that
 773    are coming from already visited blocks, because these cannot dominate
 774    anything anymore.  CTX is a sanopt context.  */
 775
 776 static void
 777 sanopt_optimize_walker (basic_block bb, class sanopt_ctx *ctx)
 778 {
 779   basic_block son;
 780   gimple_stmt_iterator gsi;
 781   sanopt_info *info = (sanopt_info *) bb->aux;
 782   bool asan_check_optimize
 783     = ((flag_sanitize & (SANITIZE_ADDRESS | SANITIZE_HWADDRESS)) != 0);
 784
 785   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
 786     {
 787       gimple *stmt = gsi_stmt (gsi);
 788       bool remove = false;
 789
 790       if (!is_gimple_call (stmt))
 791         {
 792           /* Handle asm volatile or asm with "memory" clobber
 793              the same as potentionally freeing call.  */
 794           gasm *asm_stmt = dyn_cast <gasm *> (stmt);
 795           if (asm_stmt
 796               && asan_check_optimize
 797               && (gimple_asm_clobbers_memory_p (asm_stmt)
 798                   || gimple_asm_volatile_p (asm_stmt)))
 799             info->freeing_call_events++;
 800           gsi_next (&gsi);
 801           continue;
 802         }
 803
 804       if (asan_check_optimize && !nonfreeing_call_p (stmt))
 805         info->freeing_call_events++;
 806
 807       /* If __asan_before_dynamic_init ("module"); is followed by
 808          __asan_after_dynamic_init (); without intervening memory loads/stores,
 809          there is nothing to guard, so optimize both away.  */
 810       if (asan_check_optimize
 811           && gimple_call_builtin_p (stmt, BUILT_IN_ASAN_BEFORE_DYNAMIC_INIT))
 812         {
 813           gcc_assert (!hwasan_sanitize_p ());
 814           use_operand_p use;
 815           gimple *use_stmt;
 816           if (single_imm_use (gimple_vdef (stmt), &use, &use_stmt))
 817             {
 818               if (is_gimple_call (use_stmt)
 819                   && gimple_call_builtin_p (use_stmt,
 820                                             BUILT_IN_ASAN_AFTER_DYNAMIC_INIT))
 821                 {
 822                   unlink_stmt_vdef (use_stmt);
 823                   gimple_stmt_iterator gsi2 = gsi_for_stmt (use_stmt);
 824                   gsi_remove (&gsi2, true);
 825                   remove = true;
 826                 }
 827             }
 828         }
 829
 830       if (gimple_call_internal_p (stmt))
 831         switch (gimple_call_internal_fn (stmt))
 832           {
 833           case IFN_UBSAN_NULL:
 834             remove = maybe_optimize_ubsan_null_ifn (ctx, stmt);
 835             break;
 836           case IFN_UBSAN_VPTR:
 837             remove = maybe_optimize_ubsan_vptr_ifn (ctx, stmt);
 838             break;
 839           case IFN_UBSAN_PTR:
 840             remove = maybe_optimize_ubsan_ptr_ifn (ctx, stmt);
 841             break;
 842           case IFN_HWASAN_CHECK:
 843           case IFN_ASAN_CHECK:
 844             if (asan_check_optimize)
 845               remove = maybe_optimize_asan_check_ifn (ctx, stmt);
 846             if (!remove)
 847               ctx->asan_num_accesses++;
 848             break;
 849           case IFN_ASAN_MARK:
 850             ctx->contains_asan_mark = true;
 851             break;
 852           default:
 853             break;
 854           }
 855
 856       if (remove)
 857         {
 858           /* Drop this check.  */
 859           if (dump_file && (dump_flags & TDF_DETAILS))
 860             {
 861               fprintf (dump_file, "Optimizing out: ");
 862               print_gimple_stmt (dump_file, stmt, 0, dump_flags);
 863             }
 864           unlink_stmt_vdef (stmt);
 865           gsi_remove (&gsi, true);
 866         }
 867       else
 868         {
 869           if (dump_file && (dump_flags & TDF_DETAILS))
 870             {
 871               fprintf (dump_file, "Leaving: ");
 872               print_gimple_stmt (dump_file, stmt, 0, dump_flags);
 873             }
 874
 875           gsi_next (&gsi);
 876         }
 877     }
 878
 879   if (asan_check_optimize)
 880     {
 881       info->has_freeing_call_p = info->freeing_call_events != 0;
 882       info->has_freeing_call_computed_p = true;
 883     }
 884
 885   for (son = first_dom_son (CDI_DOMINATORS, bb);
 886        son;
 887        son = next_dom_son (CDI_DOMINATORS, son))
 888     sanopt_optimize_walker (son, ctx);
 889
 890   /* We're leaving this BB, so mark it to that effect.  */
 891   info->visited_p = true;
 892 }
 893
 894 /* Try to remove redundant sanitizer checks in function FUN.  */
 895
 896 static int
 897 sanopt_optimize (function *fun, bool *contains_asan_mark)
 898 {
 899   class sanopt_ctx ctx;
 900   ctx.asan_num_accesses = 0;
 901   ctx.contains_asan_mark = false;
 902
 903   /* Set up block info for each basic block.  */
 904   alloc_aux_for_blocks (sizeof (sanopt_info));
 905
 906   /* We're going to do a dominator walk, so ensure that we have
 907      dominance information.  */
 908   calculate_dominance_info (CDI_DOMINATORS);
 909
 910   /* Recursively walk the dominator tree optimizing away
 911      redundant checks.  */
 912   sanopt_optimize_walker (ENTRY_BLOCK_PTR_FOR_FN (fun), &ctx);
 913
 914   free_aux_for_blocks ();
 915
 916   *contains_asan_mark = ctx.contains_asan_mark;
 917   return ctx.asan_num_accesses;
 918 }
 919
 920 /* Perform optimization of sanitize functions.  */
 921
 922 namespace {
 923
 924 const pass_data pass_data_sanopt =
 925 {
 926   GIMPLE_PASS, /* type */
 927   "sanopt", /* name */
 928   OPTGROUP_NONE, /* optinfo_flags */
 929   TV_NONE, /* tv_id */
 930   ( PROP_ssa | PROP_cfg | PROP_gimple_leh ), /* properties_required */
 931   0, /* properties_provided */
 932   0, /* properties_destroyed */
 933   0, /* todo_flags_start */
 934   TODO_update_ssa, /* todo_flags_finish */
 935 };
 936
 937 class pass_sanopt : public gimple_opt_pass
 938 {
 939 public:
 940   pass_sanopt (gcc::context *ctxt)
 941     : gimple_opt_pass (pass_data_sanopt, ctxt)
 942   {}
 943
 944   /* opt_pass methods: */
 945   bool gate (function *) final override
 946   {
 947     /* SANITIZE_RETURN is handled in the front-end.  When trapping,
 948        SANITIZE_UNREACHABLE is handled by builtin_decl_unreachable.  */
 949     unsigned int mask = SANITIZE_RETURN;
 950     if (flag_sanitize_trap & SANITIZE_UNREACHABLE)
 951       mask |= SANITIZE_UNREACHABLE;
 952     return flag_sanitize & ~mask;
 953   }
 954   unsigned int execute (function *) final override;
 955
 956 }; // class pass_sanopt
 957
 958 /* Sanitize all ASAN_MARK unpoison calls that are not reachable by a BB
 959    that contains an ASAN_MARK poison.  All these ASAN_MARK unpoison call
 960    can be removed as all variables are unpoisoned in a function prologue.  */
 961
 962 static void
 963 sanitize_asan_mark_unpoison (void)
 964 {
 965   /* 1) Find all BBs that contain an ASAN_MARK poison call.  */
 966   auto_sbitmap with_poison (last_basic_block_for_fn (cfun) + 1);
 967   bitmap_clear (with_poison);
 968   basic_block bb;
 969
 970   FOR_EACH_BB_FN (bb, cfun)
 971     {
 972       if (bitmap_bit_p (with_poison, bb->index))
 973         continue;
 974
 975       gimple_stmt_iterator gsi;
 976       for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
 977         {
 978           gimple *stmt = gsi_stmt (gsi);
 979           if (asan_mark_p (stmt, ASAN_MARK_POISON))
 980             {
 981               bitmap_set_bit (with_poison, bb->index);
 982               break;
 983             }
 984         }
 985     }
 986
 987   auto_sbitmap poisoned (last_basic_block_for_fn (cfun) + 1);
 988   bitmap_clear (poisoned);
 989   auto_sbitmap worklist (last_basic_block_for_fn (cfun) + 1);
 990   bitmap_copy (worklist, with_poison);
 991
 992   /* 2) Propagate the information to all reachable blocks.  */
 993   while (!bitmap_empty_p (worklist))
 994     {
 995       unsigned i = bitmap_first_set_bit (worklist);
 996       bitmap_clear_bit (worklist, i);
 997       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
 998       gcc_assert (bb);
 999
1000       edge e;
1001       edge_iterator ei;
1002       FOR_EACH_EDGE (e, ei, bb->succs)
1003         if (!bitmap_bit_p (poisoned, e->dest->index))
1004           {
1005             bitmap_set_bit (poisoned, e->dest->index);
1006             bitmap_set_bit (worklist, e->dest->index);
1007           }
1008     }
1009
1010   /* 3) Iterate all BBs not included in POISONED BBs and remove unpoison
1011         ASAN_MARK preceding an ASAN_MARK poison (which can still happen).  */
1012   FOR_EACH_BB_FN (bb, cfun)
1013     {
1014       if (bitmap_bit_p (poisoned, bb->index))
1015         continue;
1016
1017       gimple_stmt_iterator gsi;
1018       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
1019         {
1020           gimple *stmt = gsi_stmt (gsi);
1021           if (gimple_call_internal_p (stmt, IFN_ASAN_MARK))
1022             {
1023               if (asan_mark_p (stmt, ASAN_MARK_POISON))
1024                 break;
1025               else
1026                 {
1027                   if (dump_file)
1028                     fprintf (dump_file, "Removing ASAN_MARK unpoison\n");
1029                   unlink_stmt_vdef (stmt);
1030                   release_defs (stmt);
1031                   gsi_remove (&gsi, true);
1032                   continue;
1033                 }
1034             }
1035
1036           gsi_next (&gsi);
1037         }
1038     }
1039 }
1040
1041 /* Return true when STMT is either ASAN_CHECK call or a call of a function
1042    that can contain an ASAN_CHECK.  */
1043
1044 static bool
1045 maybe_contains_asan_check (gimple *stmt)
1046 {
1047   if (is_gimple_call (stmt))
1048     {
1049       if (gimple_call_internal_p (stmt, IFN_ASAN_MARK))
1050         return false;
1051       else
1052         return !(gimple_call_flags (stmt) & ECF_CONST);
1053     }
1054   else if (is_a<gasm *> (stmt))
1055     return true;
1056
1057   return false;
1058 }
1059
1060 /* Sanitize all ASAN_MARK poison calls that are not followed by an ASAN_CHECK
1061    call.  These calls can be removed.  */
1062
1063 static void
1064 sanitize_asan_mark_poison (void)
1065 {
1066   /* 1) Find all BBs that possibly contain an ASAN_CHECK.  */
1067   auto_sbitmap with_check (last_basic_block_for_fn (cfun) + 1);
1068   bitmap_clear (with_check);
1069   basic_block bb;
1070
1071   FOR_EACH_BB_FN (bb, cfun)
1072     {
1073       gimple_stmt_iterator gsi;
1074       for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
1075         {
1076           gimple *stmt = gsi_stmt (gsi);
1077           if (maybe_contains_asan_check (stmt))
1078             {
1079               bitmap_set_bit (with_check, bb->index);
1080               break;
1081             }
1082         }
1083     }
1084
1085   auto_sbitmap can_reach_check (last_basic_block_for_fn (cfun) + 1);
1086   bitmap_clear (can_reach_check);
1087   auto_sbitmap worklist (last_basic_block_for_fn (cfun) + 1);
1088   bitmap_copy (worklist, with_check);
1089
1090   /* 2) Propagate the information to all definitions blocks.  */
1091   while (!bitmap_empty_p (worklist))
1092     {
1093       unsigned i = bitmap_first_set_bit (worklist);
1094       bitmap_clear_bit (worklist, i);
1095       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
1096       gcc_assert (bb);
1097
1098       edge e;
1099       edge_iterator ei;
1100       FOR_EACH_EDGE (e, ei, bb->preds)
1101         if (!bitmap_bit_p (can_reach_check, e->src->index))
1102           {
1103             bitmap_set_bit (can_reach_check, e->src->index);
1104             bitmap_set_bit (worklist, e->src->index);
1105           }
1106     }
1107
1108   /* 3) Iterate all BBs not included in CAN_REACH_CHECK BBs and remove poison
1109         ASAN_MARK not followed by a call to function having an ASAN_CHECK.  */
1110   FOR_EACH_BB_FN (bb, cfun)
1111     {
1112       if (bitmap_bit_p (can_reach_check, bb->index))
1113         continue;
1114
1115       gimple_stmt_iterator gsi;
1116       for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi);)
1117         {
1118           gimple *stmt = gsi_stmt (gsi);
1119           if (maybe_contains_asan_check (stmt))
1120             break;
1121           else if (asan_mark_p (stmt, ASAN_MARK_POISON))
1122             {
1123               if (dump_file)
1124                 fprintf (dump_file, "Removing ASAN_MARK poison\n");
1125               unlink_stmt_vdef (stmt);
1126               release_defs (stmt);
1127               gimple_stmt_iterator gsi2 = gsi;
1128               gsi_prev (&gsi);
1129               gsi_remove (&gsi2, true);
1130               continue;
1131             }
1132
1133           gsi_prev (&gsi);
1134         }
1135     }
1136 }
1137
1138 /* Rewrite all usages of tree OP which is a PARM_DECL with a VAR_DECL
1139    that is it's DECL_VALUE_EXPR.  */
1140
1141 static tree
1142 rewrite_usage_of_param (tree *op, int *walk_subtrees, void *)
1143 {
1144   if (TREE_CODE (*op) == PARM_DECL && DECL_HAS_VALUE_EXPR_P (*op))
1145     {
1146       *op = DECL_VALUE_EXPR (*op);
1147       *walk_subtrees = 0;
1148     }
1149
1150   return NULL;
1151 }
1152
1153 /* For a given function FUN, rewrite all addressable parameters so that
1154    a new automatic variable is introduced.  Right after function entry
1155    a parameter is assigned to the variable.  */
1156
1157 static void
1158 sanitize_rewrite_addressable_params (function *fun)
1159 {
1160   gimple *g;
1161   gimple_seq stmts = NULL;
1162   bool has_any_addressable_param = false;
1163   auto_vec<tree> clear_value_expr_list;
1164
1165   for (tree arg = DECL_ARGUMENTS (current_function_decl);
1166        arg; arg = DECL_CHAIN (arg))
1167     {
1168       tree type = TREE_TYPE (arg);
1169       if (TREE_ADDRESSABLE (arg)
1170           && !TREE_ADDRESSABLE (type)
1171           && !TREE_THIS_VOLATILE (arg)
1172           && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
1173         {
1174           TREE_ADDRESSABLE (arg) = 0;
1175           DECL_NOT_GIMPLE_REG_P (arg) = 0;
1176           /* The parameter is no longer addressable.  */
1177           has_any_addressable_param = true;
1178
1179           /* Create a new automatic variable.  */
1180           tree var = build_decl (DECL_SOURCE_LOCATION (arg),
1181                                  VAR_DECL, DECL_NAME (arg), type);
1182           TREE_ADDRESSABLE (var) = 1;
1183           DECL_IGNORED_P (var) = 1;
1184
1185           gimple_add_tmp_var (var);
1186
1187           /* We skip parameters that have a DECL_VALUE_EXPR.  */
1188           if (DECL_HAS_VALUE_EXPR_P (arg))
1189             continue;
1190
1191           if (dump_file)
1192             {
1193               fprintf (dump_file,
1194                        "Rewriting parameter whose address is taken: ");
1195               print_generic_expr (dump_file, arg, dump_flags);
1196               fputc ('\n', dump_file);
1197             }
1198
1199           SET_DECL_PT_UID (var, DECL_PT_UID (arg));
1200
1201           /* Assign value of parameter to newly created variable.  */
1202           if ((TREE_CODE (type) == COMPLEX_TYPE
1203                || TREE_CODE (type) == VECTOR_TYPE))
1204             {
1205               /* We need to create a SSA name that will be used for the
1206                  assignment.  */
1207               tree tmp = get_or_create_ssa_default_def (cfun, arg);
1208               g = gimple_build_assign (var, tmp);
1209               gimple_set_location (g, DECL_SOURCE_LOCATION (arg));
1210               gimple_seq_add_stmt (&stmts, g);
1211             }
1212           else
1213             {
1214               g = gimple_build_assign (var, arg);
1215               gimple_set_location (g, DECL_SOURCE_LOCATION (arg));
1216               gimple_seq_add_stmt (&stmts, g);
1217             }
1218
1219           if (target_for_debug_bind (arg))
1220             {
1221               g = gimple_build_debug_bind (arg, var, NULL);
1222               gimple_seq_add_stmt (&stmts, g);
1223               clear_value_expr_list.safe_push (arg);
1224             }
1225
1226           DECL_HAS_VALUE_EXPR_P (arg) = 1;
1227           SET_DECL_VALUE_EXPR (arg, var);
1228         }
1229     }
1230
1231   if (!has_any_addressable_param)
1232     return;
1233
1234   /* Replace all usages of PARM_DECLs with the newly
1235      created variable VAR.  */
1236   basic_block bb;
1237   FOR_EACH_BB_FN (bb, fun)
1238     {
1239       gimple_stmt_iterator gsi;
1240       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1241         {
1242           gimple *stmt = gsi_stmt (gsi);
1243           gimple_stmt_iterator it = gsi_for_stmt (stmt);
1244           walk_gimple_stmt (&it, NULL, rewrite_usage_of_param, NULL);
1245         }
1246       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1247         {
1248           gphi *phi = dyn_cast<gphi *> (gsi_stmt (gsi));
1249           for (unsigned i = 0; i < gimple_phi_num_args (phi); ++i)
1250             {
1251               hash_set<tree> visited_nodes;
1252               walk_tree (gimple_phi_arg_def_ptr (phi, i),
1253                          rewrite_usage_of_param, NULL, &visited_nodes);
1254             }
1255         }
1256     }
1257
1258   /* Unset value expr for parameters for which we created debug bind
1259      expressions.  */
1260   for (tree arg : clear_value_expr_list)
1261     {
1262       DECL_HAS_VALUE_EXPR_P (arg) = 0;
1263       SET_DECL_VALUE_EXPR (arg, NULL_TREE);
1264     }
1265
1266   /* Insert default assignments at the beginning of a function.  */
1267   basic_block entry_bb = ENTRY_BLOCK_PTR_FOR_FN (fun);
1268   entry_bb = split_edge (single_succ_edge (entry_bb));
1269
1270   gimple_stmt_iterator gsi = gsi_start_bb (entry_bb);
1271   gsi_insert_seq_before (&gsi, stmts, GSI_NEW_STMT);
1272 }
1273
1274 unsigned int
1275 pass_sanopt::execute (function *fun)
1276 {
1277   /* n.b. ASAN_MARK is used for both HWASAN and ASAN.
1278      asan_num_accesses is hence used to count either HWASAN_CHECK or ASAN_CHECK
1279      stuff.  This is fine because you can only have one of these active at a
1280      time.  */
1281   basic_block bb;
1282   int asan_num_accesses = 0;
1283   bool contains_asan_mark = false;
1284
1285   /* Try to remove redundant checks.  */
1286   if (optimize
1287       && (flag_sanitize
1288           & (SANITIZE_NULL | SANITIZE_ALIGNMENT | SANITIZE_HWADDRESS
1289              | SANITIZE_ADDRESS | SANITIZE_VPTR | SANITIZE_POINTER_OVERFLOW)))
1290     asan_num_accesses = sanopt_optimize (fun, &contains_asan_mark);
1291   else if (flag_sanitize & (SANITIZE_ADDRESS | SANITIZE_HWADDRESS))
1292     {
1293       gimple_stmt_iterator gsi;
1294       FOR_EACH_BB_FN (bb, fun)
1295         for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1296           {
1297             gimple *stmt = gsi_stmt (gsi);
1298             if (gimple_call_internal_p (stmt, IFN_ASAN_CHECK))
1299               ++asan_num_accesses;
1300             else if (gimple_call_internal_p (stmt, IFN_ASAN_MARK))
1301               contains_asan_mark = true;
1302           }
1303     }
1304
1305   if (contains_asan_mark)
1306     {
1307       sanitize_asan_mark_unpoison ();
1308       sanitize_asan_mark_poison ();
1309     }
1310
1311   if (asan_sanitize_stack_p () || hwasan_sanitize_stack_p ())
1312     sanitize_rewrite_addressable_params (fun);
1313
1314   bool use_calls = param_asan_instrumentation_with_call_threshold < INT_MAX
1315     && asan_num_accesses >= param_asan_instrumentation_with_call_threshold;
1316
1317   hash_map<tree, tree> shadow_vars_mapping;
1318   bool need_commit_edge_insert = false;
1319   FOR_EACH_BB_FN (bb, fun)
1320     {
1321       gimple_stmt_iterator gsi;
1322       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); )
1323         {
1324           gimple *stmt = gsi_stmt (gsi);
1325           bool no_next = false;
1326
1327           if (!is_gimple_call (stmt))
1328             {
1329               gsi_next (&gsi);
1330               continue;
1331             }
1332
1333           if (gimple_call_internal_p (stmt))
1334             {
1335               enum internal_fn ifn = gimple_call_internal_fn (stmt);
1336               switch (ifn)
1337                 {
1338                 case IFN_UBSAN_NULL:
1339                   no_next = ubsan_expand_null_ifn (&gsi);
1340                   break;
1341                 case IFN_UBSAN_BOUNDS:
1342                   no_next = ubsan_expand_bounds_ifn (&gsi);
1343                   break;
1344                 case IFN_UBSAN_OBJECT_SIZE:
1345                   no_next = ubsan_expand_objsize_ifn (&gsi);
1346                   break;
1347                 case IFN_UBSAN_PTR:
1348                   no_next = ubsan_expand_ptr_ifn (&gsi);
1349                   break;
1350                 case IFN_UBSAN_VPTR:
1351                   no_next = ubsan_expand_vptr_ifn (&gsi);
1352                   break;
1353                 case IFN_HWASAN_CHECK:
1354                   no_next = hwasan_expand_check_ifn (&gsi, use_calls);
1355                   break;
1356                 case IFN_ASAN_CHECK:
1357                   no_next = asan_expand_check_ifn (&gsi, use_calls);
1358                   break;
1359                 case IFN_ASAN_MARK:
1360                   no_next = asan_expand_mark_ifn (&gsi);
1361                   break;
1362                 case IFN_ASAN_POISON:
1363                   no_next = asan_expand_poison_ifn (&gsi,
1364                                                     &need_commit_edge_insert,
1365                                                     shadow_vars_mapping);
1366                   break;
1367                 case IFN_HWASAN_MARK:
1368                   no_next = hwasan_expand_mark_ifn (&gsi);
1369                   break;
1370                 default:
1371                   break;
1372                 }
1373             }
1374           else if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
1375             {
1376               tree callee = gimple_call_fndecl (stmt);
1377               switch (DECL_FUNCTION_CODE (callee))
1378                 {
1379                 case BUILT_IN_UNREACHABLE:
1380                   if (sanitize_flags_p (SANITIZE_UNREACHABLE))
1381                     no_next = ubsan_instrument_unreachable (&gsi);
1382                   break;
1383                 default:
1384                   break;
1385                 }
1386             }
1387
1388           if (dump_file && (dump_flags & TDF_DETAILS))
1389             {
1390               fprintf (dump_file, "Expanded: ");
1391               print_gimple_stmt (dump_file, stmt, 0, dump_flags);
1392             }
1393
1394           if (!no_next)
1395             gsi_next (&gsi);
1396         }
1397     }
1398
1399   if (need_commit_edge_insert)
1400     gsi_commit_edge_inserts ();
1401
1402   return 0;
1403 }
1404
1405 } // anon namespace
1406
1407 gimple_opt_pass *
1408 make_pass_sanopt (gcc::context *ctxt)
1409 {
1410   return new pass_sanopt (ctxt);
1411 }