contrib/gcc-8.0/gcc/tree-object-size.c

   1 /* __builtin_object_size (ptr, object_size_type) computation
   2    Copyright (C) 2004-2018 Free Software Foundation, Inc.
   3    Contributed by Jakub Jelinek <jakub@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License 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 "tree-pass.h"
  28 #include "ssa.h"
  29 #include "gimple-pretty-print.h"
  30 #include "fold-const.h"
  31 #include "tree-object-size.h"
  32 #include "gimple-fold.h"
  33 #include "gimple-iterator.h"
  34 #include "tree-cfg.h"
  35 #include "stringpool.h"
  36 #include "attribs.h"
  37
  38 struct object_size_info
  39 {
  40   int object_size_type;
  41   unsigned char pass;
  42   bool changed;
  43   bitmap visited, reexamine;
  44   unsigned int *depths;
  45   unsigned int *stack, *tos;
  46 };
  47
  48 static const unsigned HOST_WIDE_INT unknown[4] = {
  49   HOST_WIDE_INT_M1U,
  50   HOST_WIDE_INT_M1U,
  51   0,
  52   0
  53 };
  54
  55 static tree compute_object_offset (const_tree, const_tree);
  56 static bool addr_object_size (struct object_size_info *,
  57                               const_tree, int, unsigned HOST_WIDE_INT *);
  58 static unsigned HOST_WIDE_INT alloc_object_size (const gcall *, int);
  59 static tree pass_through_call (const gcall *);
  60 static void collect_object_sizes_for (struct object_size_info *, tree);
  61 static void expr_object_size (struct object_size_info *, tree, tree);
  62 static bool merge_object_sizes (struct object_size_info *, tree, tree,
  63                                 unsigned HOST_WIDE_INT);
  64 static bool plus_stmt_object_size (struct object_size_info *, tree, gimple *);
  65 static bool cond_expr_object_size (struct object_size_info *, tree, gimple *);
  66 static void init_offset_limit (void);
  67 static void check_for_plus_in_loops (struct object_size_info *, tree);
  68 static void check_for_plus_in_loops_1 (struct object_size_info *, tree,
  69                                        unsigned int);
  70
  71 /* object_sizes[0] is upper bound for number of bytes till the end of
  72    the object.
  73    object_sizes[1] is upper bound for number of bytes till the end of
  74    the subobject (innermost array or field with address taken).
  75    object_sizes[2] is lower bound for number of bytes till the end of
  76    the object and object_sizes[3] lower bound for subobject.  */
  77 static vec<unsigned HOST_WIDE_INT> object_sizes[4];
  78
  79 /* Bitmaps what object sizes have been computed already.  */
  80 static bitmap computed[4];
  81
  82 /* Maximum value of offset we consider to be addition.  */
  83 static unsigned HOST_WIDE_INT offset_limit;
  84
  85
  86 /* Initialize OFFSET_LIMIT variable.  */
  87 static void
  88 init_offset_limit (void)
  89 {
  90   if (tree_fits_uhwi_p (TYPE_MAX_VALUE (sizetype)))
  91     offset_limit = tree_to_uhwi (TYPE_MAX_VALUE (sizetype));
  92   else
  93     offset_limit = -1;
  94   offset_limit /= 2;
  95 }
  96
  97
  98 /* Compute offset of EXPR within VAR.  Return error_mark_node
  99    if unknown.  */
 100
 101 static tree
 102 compute_object_offset (const_tree expr, const_tree var)
 103 {
 104   enum tree_code code = PLUS_EXPR;
 105   tree base, off, t;
 106
 107   if (expr == var)
 108     return size_zero_node;
 109
 110   switch (TREE_CODE (expr))
 111     {
 112     case COMPONENT_REF:
 113       base = compute_object_offset (TREE_OPERAND (expr, 0), var);
 114       if (base == error_mark_node)
 115         return base;
 116
 117       t = TREE_OPERAND (expr, 1);
 118       off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
 119                         size_int (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (t))
 120                                   / BITS_PER_UNIT));
 121       break;
 122
 123     case REALPART_EXPR:
 124     CASE_CONVERT:
 125     case VIEW_CONVERT_EXPR:
 126     case NON_LVALUE_EXPR:
 127       return compute_object_offset (TREE_OPERAND (expr, 0), var);
 128
 129     case IMAGPART_EXPR:
 130       base = compute_object_offset (TREE_OPERAND (expr, 0), var);
 131       if (base == error_mark_node)
 132         return base;
 133
 134       off = TYPE_SIZE_UNIT (TREE_TYPE (expr));
 135       break;
 136
 137     case ARRAY_REF:
 138       base = compute_object_offset (TREE_OPERAND (expr, 0), var);
 139       if (base == error_mark_node)
 140         return base;
 141
 142       t = TREE_OPERAND (expr, 1);
 143       tree low_bound, unit_size;
 144       low_bound = array_ref_low_bound (CONST_CAST_TREE (expr));
 145       unit_size = array_ref_element_size (CONST_CAST_TREE (expr));
 146       if (! integer_zerop (low_bound))
 147         t = fold_build2 (MINUS_EXPR, TREE_TYPE (t), t, low_bound);
 148       if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
 149         {
 150           code = MINUS_EXPR;
 151           t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
 152         }
 153       t = fold_convert (sizetype, t);
 154       off = size_binop (MULT_EXPR, unit_size, t);
 155       break;
 156
 157     case MEM_REF:
 158       gcc_assert (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR);
 159       return wide_int_to_tree (sizetype, mem_ref_offset (expr));
 160
 161     default:
 162       return error_mark_node;
 163     }
 164
 165   return size_binop (code, base, off);
 166 }
 167
 168
 169 /* Compute __builtin_object_size for PTR, which is a ADDR_EXPR.
 170    OBJECT_SIZE_TYPE is the second argument from __builtin_object_size.
 171    If unknown, return unknown[object_size_type].  */
 172
 173 static bool
 174 addr_object_size (struct object_size_info *osi, const_tree ptr,
 175                   int object_size_type, unsigned HOST_WIDE_INT *psize)
 176 {
 177   tree pt_var, pt_var_size = NULL_TREE, var_size, bytes;
 178
 179   gcc_assert (TREE_CODE (ptr) == ADDR_EXPR);
 180
 181   /* Set to unknown and overwrite just before returning if the size
 182      could be determined.  */
 183   *psize = unknown[object_size_type];
 184
 185   pt_var = TREE_OPERAND (ptr, 0);
 186   while (handled_component_p (pt_var))
 187     pt_var = TREE_OPERAND (pt_var, 0);
 188
 189   if (pt_var
 190       && TREE_CODE (pt_var) == MEM_REF)
 191     {
 192       unsigned HOST_WIDE_INT sz;
 193
 194       if (!osi || (object_size_type & 1) != 0
 195           || TREE_CODE (TREE_OPERAND (pt_var, 0)) != SSA_NAME)
 196         {
 197           compute_builtin_object_size (TREE_OPERAND (pt_var, 0),
 198                                        object_size_type & ~1, &sz);
 199         }
 200       else
 201         {
 202           tree var = TREE_OPERAND (pt_var, 0);
 203           if (osi->pass == 0)
 204             collect_object_sizes_for (osi, var);
 205           if (bitmap_bit_p (computed[object_size_type],
 206                             SSA_NAME_VERSION (var)))
 207             sz = object_sizes[object_size_type][SSA_NAME_VERSION (var)];
 208           else
 209             sz = unknown[object_size_type];
 210         }
 211       if (sz != unknown[object_size_type])
 212         {
 213           offset_int mem_offset;
 214           if (mem_ref_offset (pt_var).is_constant (&mem_offset))
 215             {
 216               offset_int dsz = wi::sub (sz, mem_offset);
 217               if (wi::neg_p (dsz))
 218                 sz = 0;
 219               else if (wi::fits_uhwi_p (dsz))
 220                 sz = dsz.to_uhwi ();
 221               else
 222                 sz = unknown[object_size_type];
 223             }
 224           else
 225             sz = unknown[object_size_type];
 226         }
 227
 228       if (sz != unknown[object_size_type] && sz < offset_limit)
 229         pt_var_size = size_int (sz);
 230     }
 231   else if (pt_var
 232            && DECL_P (pt_var)
 233            && tree_fits_uhwi_p (DECL_SIZE_UNIT (pt_var))
 234            && tree_to_uhwi (DECL_SIZE_UNIT (pt_var)) < offset_limit)
 235     pt_var_size = DECL_SIZE_UNIT (pt_var);
 236   else if (pt_var
 237            && TREE_CODE (pt_var) == STRING_CST
 238            && TYPE_SIZE_UNIT (TREE_TYPE (pt_var))
 239            && tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)))
 240            && tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (pt_var)))
 241               < offset_limit)
 242     pt_var_size = TYPE_SIZE_UNIT (TREE_TYPE (pt_var));
 243   else
 244     return false;
 245
 246   if (pt_var != TREE_OPERAND (ptr, 0))
 247     {
 248       tree var;
 249
 250       if (object_size_type & 1)
 251         {
 252           var = TREE_OPERAND (ptr, 0);
 253
 254           while (var != pt_var
 255                  && TREE_CODE (var) != BIT_FIELD_REF
 256                  && TREE_CODE (var) != COMPONENT_REF
 257                  && TREE_CODE (var) != ARRAY_REF
 258                  && TREE_CODE (var) != ARRAY_RANGE_REF
 259                  && TREE_CODE (var) != REALPART_EXPR
 260                  && TREE_CODE (var) != IMAGPART_EXPR)
 261             var = TREE_OPERAND (var, 0);
 262           if (var != pt_var && TREE_CODE (var) == ARRAY_REF)
 263             var = TREE_OPERAND (var, 0);
 264           if (! TYPE_SIZE_UNIT (TREE_TYPE (var))
 265               || ! tree_fits_uhwi_p (TYPE_SIZE_UNIT (TREE_TYPE (var)))
 266               || (pt_var_size
 267                   && tree_int_cst_lt (pt_var_size,
 268                                       TYPE_SIZE_UNIT (TREE_TYPE (var)))))
 269             var = pt_var;
 270           else if (var != pt_var && TREE_CODE (pt_var) == MEM_REF)
 271             {
 272               tree v = var;
 273               /* For &X->fld, compute object size only if fld isn't the last
 274                  field, as struct { int i; char c[1]; } is often used instead
 275                  of flexible array member.  */
 276               while (v && v != pt_var)
 277                 switch (TREE_CODE (v))
 278                   {
 279                   case ARRAY_REF:
 280                     if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_OPERAND (v, 0)))
 281                         && TREE_CODE (TREE_OPERAND (v, 1)) == INTEGER_CST)
 282                       {
 283                         tree domain
 284                           = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (v, 0)));
 285                         if (domain
 286                             && TYPE_MAX_VALUE (domain)
 287                             && TREE_CODE (TYPE_MAX_VALUE (domain))
 288                                == INTEGER_CST
 289                             && tree_int_cst_lt (TREE_OPERAND (v, 1),
 290                                                 TYPE_MAX_VALUE (domain)))
 291                           {
 292                             v = NULL_TREE;
 293                             break;
 294                           }
 295                       }
 296                     v = TREE_OPERAND (v, 0);
 297                     break;
 298                   case REALPART_EXPR:
 299                   case IMAGPART_EXPR:
 300                     v = NULL_TREE;
 301                     break;
 302                   case COMPONENT_REF:
 303                     if (TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE)
 304                       {
 305                         v = NULL_TREE;
 306                         break;
 307                       }
 308                     while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
 309                       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
 310                           != UNION_TYPE
 311                           && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
 312                           != QUAL_UNION_TYPE)
 313                         break;
 314                       else
 315                         v = TREE_OPERAND (v, 0);
 316                     if (TREE_CODE (v) == COMPONENT_REF
 317                         && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
 318                            == RECORD_TYPE)
 319                       {
 320                         tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
 321                         for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
 322                           if (TREE_CODE (fld_chain) == FIELD_DECL)
 323                             break;
 324
 325                         if (fld_chain)
 326                           {
 327                             v = NULL_TREE;
 328                             break;
 329                           }
 330                         v = TREE_OPERAND (v, 0);
 331                       }
 332                     while (v != pt_var && TREE_CODE (v) == COMPONENT_REF)
 333                       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
 334                           != UNION_TYPE
 335                           && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
 336                           != QUAL_UNION_TYPE)
 337                         break;
 338                       else
 339                         v = TREE_OPERAND (v, 0);
 340                     if (v != pt_var)
 341                       v = NULL_TREE;
 342                     else
 343                       v = pt_var;
 344                     break;
 345                   default:
 346                     v = pt_var;
 347                     break;
 348                   }
 349               if (v == pt_var)
 350                 var = pt_var;
 351             }
 352         }
 353       else
 354         var = pt_var;
 355
 356       if (var != pt_var)
 357         var_size = TYPE_SIZE_UNIT (TREE_TYPE (var));
 358       else if (!pt_var_size)
 359         return false;
 360       else
 361         var_size = pt_var_size;
 362       bytes = compute_object_offset (TREE_OPERAND (ptr, 0), var);
 363       if (bytes != error_mark_node)
 364         {
 365           if (TREE_CODE (bytes) == INTEGER_CST
 366               && tree_int_cst_lt (var_size, bytes))
 367             bytes = size_zero_node;
 368           else
 369             bytes = size_binop (MINUS_EXPR, var_size, bytes);
 370         }
 371       if (var != pt_var
 372           && pt_var_size
 373           && TREE_CODE (pt_var) == MEM_REF
 374           && bytes != error_mark_node)
 375         {
 376           tree bytes2 = compute_object_offset (TREE_OPERAND (ptr, 0), pt_var);
 377           if (bytes2 != error_mark_node)
 378             {
 379               if (TREE_CODE (bytes2) == INTEGER_CST
 380                   && tree_int_cst_lt (pt_var_size, bytes2))
 381                 bytes2 = size_zero_node;
 382               else
 383                 bytes2 = size_binop (MINUS_EXPR, pt_var_size, bytes2);
 384               bytes = size_binop (MIN_EXPR, bytes, bytes2);
 385             }
 386         }
 387     }
 388   else if (!pt_var_size)
 389     return false;
 390   else
 391     bytes = pt_var_size;
 392
 393   if (tree_fits_uhwi_p (bytes))
 394     {
 395       *psize = tree_to_uhwi (bytes);
 396       return true;
 397     }
 398
 399   return false;
 400 }
 401
 402
 403 /* Compute __builtin_object_size for CALL, which is a GIMPLE_CALL.
 404    Handles various allocation calls.  OBJECT_SIZE_TYPE is the second
 405    argument from __builtin_object_size.  If unknown, return
 406    unknown[object_size_type].  */
 407
 408 static unsigned HOST_WIDE_INT
 409 alloc_object_size (const gcall *call, int object_size_type)
 410 {
 411   tree callee, bytes = NULL_TREE;
 412   tree alloc_size;
 413   int arg1 = -1, arg2 = -1;
 414
 415   gcc_assert (is_gimple_call (call));
 416
 417   callee = gimple_call_fndecl (call);
 418   if (!callee)
 419     return unknown[object_size_type];
 420
 421   alloc_size = lookup_attribute ("alloc_size",
 422                                  TYPE_ATTRIBUTES (TREE_TYPE (callee)));
 423   if (alloc_size && TREE_VALUE (alloc_size))
 424     {
 425       tree p = TREE_VALUE (alloc_size);
 426
 427       arg1 = TREE_INT_CST_LOW (TREE_VALUE (p))-1;
 428       if (TREE_CHAIN (p))
 429         arg2 = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (p)))-1;
 430     }
 431
 432   if (DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL)
 433     switch (DECL_FUNCTION_CODE (callee))
 434       {
 435       case BUILT_IN_CALLOC:
 436         arg2 = 1;
 437         /* fall through */
 438       case BUILT_IN_MALLOC:
 439       CASE_BUILT_IN_ALLOCA:
 440         arg1 = 0;
 441       default:
 442         break;
 443       }
 444
 445   if (arg1 < 0 || arg1 >= (int)gimple_call_num_args (call)
 446       || TREE_CODE (gimple_call_arg (call, arg1)) != INTEGER_CST
 447       || (arg2 >= 0
 448           && (arg2 >= (int)gimple_call_num_args (call)
 449               || TREE_CODE (gimple_call_arg (call, arg2)) != INTEGER_CST)))
 450     return unknown[object_size_type];
 451
 452   if (arg2 >= 0)
 453     bytes = size_binop (MULT_EXPR,
 454         fold_convert (sizetype, gimple_call_arg (call, arg1)),
 455         fold_convert (sizetype, gimple_call_arg (call, arg2)));
 456   else if (arg1 >= 0)
 457     bytes = fold_convert (sizetype, gimple_call_arg (call, arg1));
 458
 459   if (bytes && tree_fits_uhwi_p (bytes))
 460     return tree_to_uhwi (bytes);
 461
 462   return unknown[object_size_type];
 463 }
 464
 465
 466 /* If object size is propagated from one of function's arguments directly
 467    to its return value, return that argument for GIMPLE_CALL statement CALL.
 468    Otherwise return NULL.  */
 469
 470 static tree
 471 pass_through_call (const gcall *call)
 472 {
 473   unsigned rf = gimple_call_return_flags (call);
 474   if (rf & ERF_RETURNS_ARG)
 475     {
 476       unsigned argnum = rf & ERF_RETURN_ARG_MASK;
 477       if (argnum < gimple_call_num_args (call))
 478         return gimple_call_arg (call, argnum);
 479     }
 480
 481   /* __builtin_assume_aligned is intentionally not marked RET1.  */
 482   if (gimple_call_builtin_p (call, BUILT_IN_ASSUME_ALIGNED))
 483     return gimple_call_arg (call, 0);
 484
 485   return NULL_TREE;
 486 }
 487
 488
 489 /* Compute __builtin_object_size value for PTR and set *PSIZE to
 490    the resulting value.  OBJECT_SIZE_TYPE is the second argument
 491    to __builtin_object_size.  Return true on success and false
 492    when the object size could not be determined.  */
 493
 494 bool
 495 compute_builtin_object_size (tree ptr, int object_size_type,
 496                              unsigned HOST_WIDE_INT *psize)
 497 {
 498   gcc_assert (object_size_type >= 0 && object_size_type <= 3);
 499
 500   /* Set to unknown and overwrite just before returning if the size
 501      could be determined.  */
 502   *psize = unknown[object_size_type];
 503
 504   if (! offset_limit)
 505     init_offset_limit ();
 506
 507   if (TREE_CODE (ptr) == ADDR_EXPR)
 508     return addr_object_size (NULL, ptr, object_size_type, psize);
 509
 510   if (TREE_CODE (ptr) != SSA_NAME
 511       || !POINTER_TYPE_P (TREE_TYPE (ptr)))
 512       return false;
 513
 514   if (computed[object_size_type] == NULL)
 515     {
 516       if (optimize || object_size_type & 1)
 517         return false;
 518
 519       /* When not optimizing, rather than failing, make a small effort
 520          to determine the object size without the full benefit of
 521          the (costly) computation below.  */
 522       gimple *def = SSA_NAME_DEF_STMT (ptr);
 523       if (gimple_code (def) == GIMPLE_ASSIGN)
 524         {
 525           tree_code code = gimple_assign_rhs_code (def);
 526           if (code == POINTER_PLUS_EXPR)
 527             {
 528               tree offset = gimple_assign_rhs2 (def);
 529               ptr = gimple_assign_rhs1 (def);
 530
 531               if (tree_fits_shwi_p (offset)
 532                   && compute_builtin_object_size (ptr, object_size_type, psize))
 533                 {
 534                   /* Return zero when the offset is out of bounds.  */
 535                   unsigned HOST_WIDE_INT off = tree_to_shwi (offset);
 536                   *psize = off < *psize ? *psize - off : 0;
 537                   return true;
 538                 }
 539             }
 540         }
 541       return false;
 542     }
 543
 544   if (!bitmap_bit_p (computed[object_size_type], SSA_NAME_VERSION (ptr)))
 545     {
 546       struct object_size_info osi;
 547       bitmap_iterator bi;
 548       unsigned int i;
 549
 550       if (num_ssa_names > object_sizes[object_size_type].length ())
 551         object_sizes[object_size_type].safe_grow (num_ssa_names);
 552       if (dump_file)
 553         {
 554           fprintf (dump_file, "Computing %s %sobject size for ",
 555                    (object_size_type & 2) ? "minimum" : "maximum",
 556                    (object_size_type & 1) ? "sub" : "");
 557           print_generic_expr (dump_file, ptr, dump_flags);
 558           fprintf (dump_file, ":\n");
 559         }
 560
 561       osi.visited = BITMAP_ALLOC (NULL);
 562       osi.reexamine = BITMAP_ALLOC (NULL);
 563       osi.object_size_type = object_size_type;
 564       osi.depths = NULL;
 565       osi.stack = NULL;
 566       osi.tos = NULL;
 567
 568       /* First pass: walk UD chains, compute object sizes that
 569          can be computed.  osi.reexamine bitmap at the end will
 570          contain what variables were found in dependency cycles
 571          and therefore need to be reexamined.  */
 572       osi.pass = 0;
 573       osi.changed = false;
 574       collect_object_sizes_for (&osi, ptr);
 575
 576       /* Second pass: keep recomputing object sizes of variables
 577          that need reexamination, until no object sizes are
 578          increased or all object sizes are computed.  */
 579       if (! bitmap_empty_p (osi.reexamine))
 580         {
 581           bitmap reexamine = BITMAP_ALLOC (NULL);
 582
 583           /* If looking for minimum instead of maximum object size,
 584              detect cases where a pointer is increased in a loop.
 585              Although even without this detection pass 2 would eventually
 586              terminate, it could take a long time.  If a pointer is
 587              increasing this way, we need to assume 0 object size.
 588              E.g. p = &buf[0]; while (cond) p = p + 4;  */
 589           if (object_size_type & 2)
 590             {
 591               osi.depths = XCNEWVEC (unsigned int, num_ssa_names);
 592               osi.stack = XNEWVEC (unsigned int, num_ssa_names);
 593               osi.tos = osi.stack;
 594               osi.pass = 1;
 595               /* collect_object_sizes_for is changing
 596                  osi.reexamine bitmap, so iterate over a copy.  */
 597               bitmap_copy (reexamine, osi.reexamine);
 598               EXECUTE_IF_SET_IN_BITMAP (reexamine, 0, i, bi)
 599                 if (bitmap_bit_p (osi.reexamine, i))
 600                   check_for_plus_in_loops (&osi, ssa_name (i));
 601
 602               free (osi.depths);
 603               osi.depths = NULL;
 604               free (osi.stack);
 605               osi.stack = NULL;
 606               osi.tos = NULL;
 607             }
 608
 609           do
 610             {
 611               osi.pass = 2;
 612               osi.changed = false;
 613               /* collect_object_sizes_for is changing
 614                  osi.reexamine bitmap, so iterate over a copy.  */
 615               bitmap_copy (reexamine, osi.reexamine);
 616               EXECUTE_IF_SET_IN_BITMAP (reexamine, 0, i, bi)
 617                 if (bitmap_bit_p (osi.reexamine, i))
 618                   {
 619                     collect_object_sizes_for (&osi, ssa_name (i));
 620                     if (dump_file && (dump_flags & TDF_DETAILS))
 621                       {
 622                         fprintf (dump_file, "Reexamining ");
 623                         print_generic_expr (dump_file, ssa_name (i),
 624                                             dump_flags);
 625                         fprintf (dump_file, "\n");
 626                       }
 627                   }
 628             }
 629           while (osi.changed);
 630
 631           BITMAP_FREE (reexamine);
 632         }
 633       EXECUTE_IF_SET_IN_BITMAP (osi.reexamine, 0, i, bi)
 634         bitmap_set_bit (computed[object_size_type], i);
 635
 636       /* Debugging dumps.  */
 637       if (dump_file)
 638         {
 639           EXECUTE_IF_SET_IN_BITMAP (osi.visited, 0, i, bi)
 640             if (object_sizes[object_size_type][i]
 641                 != unknown[object_size_type])
 642               {
 643                 print_generic_expr (dump_file, ssa_name (i),
 644                                     dump_flags);
 645                 fprintf (dump_file,
 646                          ": %s %sobject size "
 647                          HOST_WIDE_INT_PRINT_UNSIGNED "\n",
 648                          (object_size_type & 2) ? "minimum" : "maximum",
 649                          (object_size_type & 1) ? "sub" : "",
 650                          object_sizes[object_size_type][i]);
 651               }
 652         }
 653
 654       BITMAP_FREE (osi.reexamine);
 655       BITMAP_FREE (osi.visited);
 656     }
 657
 658   *psize = object_sizes[object_size_type][SSA_NAME_VERSION (ptr)];
 659   return *psize != unknown[object_size_type];
 660 }
 661
 662 /* Compute object_sizes for PTR, defined to VALUE, which is not an SSA_NAME.  */
 663
 664 static void
 665 expr_object_size (struct object_size_info *osi, tree ptr, tree value)
 666 {
 667   int object_size_type = osi->object_size_type;
 668   unsigned int varno = SSA_NAME_VERSION (ptr);
 669   unsigned HOST_WIDE_INT bytes;
 670
 671   gcc_assert (object_sizes[object_size_type][varno]
 672               != unknown[object_size_type]);
 673   gcc_assert (osi->pass == 0);
 674
 675   if (TREE_CODE (value) == WITH_SIZE_EXPR)
 676     value = TREE_OPERAND (value, 0);
 677
 678   /* Pointer variables should have been handled by merge_object_sizes.  */
 679   gcc_assert (TREE_CODE (value) != SSA_NAME
 680               || !POINTER_TYPE_P (TREE_TYPE (value)));
 681
 682   if (TREE_CODE (value) == ADDR_EXPR)
 683     addr_object_size (osi, value, object_size_type, &bytes);
 684   else
 685     bytes = unknown[object_size_type];
 686
 687   if ((object_size_type & 2) == 0)
 688     {
 689       if (object_sizes[object_size_type][varno] < bytes)
 690         object_sizes[object_size_type][varno] = bytes;
 691     }
 692   else
 693     {
 694       if (object_sizes[object_size_type][varno] > bytes)
 695         object_sizes[object_size_type][varno] = bytes;
 696     }
 697 }
 698
 699
 700 /* Compute object_sizes for PTR, defined to the result of a call.  */
 701
 702 static void
 703 call_object_size (struct object_size_info *osi, tree ptr, gcall *call)
 704 {
 705   int object_size_type = osi->object_size_type;
 706   unsigned int varno = SSA_NAME_VERSION (ptr);
 707   unsigned HOST_WIDE_INT bytes;
 708
 709   gcc_assert (is_gimple_call (call));
 710
 711   gcc_assert (object_sizes[object_size_type][varno]
 712               != unknown[object_size_type]);
 713   gcc_assert (osi->pass == 0);
 714
 715   bytes = alloc_object_size (call, object_size_type);
 716
 717   if ((object_size_type & 2) == 0)
 718     {
 719       if (object_sizes[object_size_type][varno] < bytes)
 720         object_sizes[object_size_type][varno] = bytes;
 721     }
 722   else
 723     {
 724       if (object_sizes[object_size_type][varno] > bytes)
 725         object_sizes[object_size_type][varno] = bytes;
 726     }
 727 }
 728
 729
 730 /* Compute object_sizes for PTR, defined to an unknown value.  */
 731
 732 static void
 733 unknown_object_size (struct object_size_info *osi, tree ptr)
 734 {
 735   int object_size_type = osi->object_size_type;
 736   unsigned int varno = SSA_NAME_VERSION (ptr);
 737   unsigned HOST_WIDE_INT bytes;
 738
 739   gcc_assert (object_sizes[object_size_type][varno]
 740               != unknown[object_size_type]);
 741   gcc_assert (osi->pass == 0);
 742
 743   bytes = unknown[object_size_type];
 744
 745   if ((object_size_type & 2) == 0)
 746     {
 747       if (object_sizes[object_size_type][varno] < bytes)
 748         object_sizes[object_size_type][varno] = bytes;
 749     }
 750   else
 751     {
 752       if (object_sizes[object_size_type][varno] > bytes)
 753         object_sizes[object_size_type][varno] = bytes;
 754     }
 755 }
 756
 757
 758 /* Merge object sizes of ORIG + OFFSET into DEST.  Return true if
 759    the object size might need reexamination later.  */
 760
 761 static bool
 762 merge_object_sizes (struct object_size_info *osi, tree dest, tree orig,
 763                     unsigned HOST_WIDE_INT offset)
 764 {
 765   int object_size_type = osi->object_size_type;
 766   unsigned int varno = SSA_NAME_VERSION (dest);
 767   unsigned HOST_WIDE_INT orig_bytes;
 768
 769   if (object_sizes[object_size_type][varno] == unknown[object_size_type])
 770     return false;
 771   if (offset >= offset_limit)
 772     {
 773       object_sizes[object_size_type][varno] = unknown[object_size_type];
 774       return false;
 775     }
 776
 777   if (osi->pass == 0)
 778     collect_object_sizes_for (osi, orig);
 779
 780   orig_bytes = object_sizes[object_size_type][SSA_NAME_VERSION (orig)];
 781   if (orig_bytes != unknown[object_size_type])
 782     orig_bytes = (offset > orig_bytes)
 783                  ? HOST_WIDE_INT_0U : orig_bytes - offset;
 784
 785   if ((object_size_type & 2) == 0)
 786     {
 787       if (object_sizes[object_size_type][varno] < orig_bytes)
 788         {
 789           object_sizes[object_size_type][varno] = orig_bytes;
 790           osi->changed = true;
 791         }
 792     }
 793   else
 794     {
 795       if (object_sizes[object_size_type][varno] > orig_bytes)
 796         {
 797           object_sizes[object_size_type][varno] = orig_bytes;
 798           osi->changed = true;
 799         }
 800     }
 801   return bitmap_bit_p (osi->reexamine, SSA_NAME_VERSION (orig));
 802 }
 803
 804
 805 /* Compute object_sizes for VAR, defined to the result of an assignment
 806    with operator POINTER_PLUS_EXPR.  Return true if the object size might
 807    need reexamination  later.  */
 808
 809 static bool
 810 plus_stmt_object_size (struct object_size_info *osi, tree var, gimple *stmt)
 811 {
 812   int object_size_type = osi->object_size_type;
 813   unsigned int varno = SSA_NAME_VERSION (var);
 814   unsigned HOST_WIDE_INT bytes;
 815   tree op0, op1;
 816
 817   if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
 818     {
 819       op0 = gimple_assign_rhs1 (stmt);
 820       op1 = gimple_assign_rhs2 (stmt);
 821     }
 822   else if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
 823     {
 824       tree rhs = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
 825       gcc_assert (TREE_CODE (rhs) == MEM_REF);
 826       op0 = TREE_OPERAND (rhs, 0);
 827       op1 = TREE_OPERAND (rhs, 1);
 828     }
 829   else
 830     gcc_unreachable ();
 831
 832   if (object_sizes[object_size_type][varno] == unknown[object_size_type])
 833     return false;
 834
 835   /* Handle PTR + OFFSET here.  */
 836   if (TREE_CODE (op1) == INTEGER_CST
 837       && (TREE_CODE (op0) == SSA_NAME
 838           || TREE_CODE (op0) == ADDR_EXPR))
 839     {
 840       if (! tree_fits_uhwi_p (op1))
 841         bytes = unknown[object_size_type];
 842       else if (TREE_CODE (op0) == SSA_NAME)
 843         return merge_object_sizes (osi, var, op0, tree_to_uhwi (op1));
 844       else
 845         {
 846           unsigned HOST_WIDE_INT off = tree_to_uhwi (op1);
 847
 848           /* op0 will be ADDR_EXPR here.  */
 849           addr_object_size (osi, op0, object_size_type, &bytes);
 850           if (bytes == unknown[object_size_type])
 851             ;
 852           else if (off > offset_limit)
 853             bytes = unknown[object_size_type];
 854           else if (off > bytes)
 855             bytes = 0;
 856           else
 857             bytes -= off;
 858         }
 859     }
 860   else
 861     bytes = unknown[object_size_type];
 862
 863   if ((object_size_type & 2) == 0)
 864     {
 865       if (object_sizes[object_size_type][varno] < bytes)
 866         object_sizes[object_size_type][varno] = bytes;
 867     }
 868   else
 869     {
 870       if (object_sizes[object_size_type][varno] > bytes)
 871         object_sizes[object_size_type][varno] = bytes;
 872     }
 873   return false;
 874 }
 875
 876
 877 /* Compute object_sizes for VAR, defined at STMT, which is
 878    a COND_EXPR.  Return true if the object size might need reexamination
 879    later.  */
 880
 881 static bool
 882 cond_expr_object_size (struct object_size_info *osi, tree var, gimple *stmt)
 883 {
 884   tree then_, else_;
 885   int object_size_type = osi->object_size_type;
 886   unsigned int varno = SSA_NAME_VERSION (var);
 887   bool reexamine = false;
 888
 889   gcc_assert (gimple_assign_rhs_code (stmt) == COND_EXPR);
 890
 891   if (object_sizes[object_size_type][varno] == unknown[object_size_type])
 892     return false;
 893
 894   then_ = gimple_assign_rhs2 (stmt);
 895   else_ = gimple_assign_rhs3 (stmt);
 896
 897   if (TREE_CODE (then_) == SSA_NAME)
 898     reexamine |= merge_object_sizes (osi, var, then_, 0);
 899   else
 900     expr_object_size (osi, var, then_);
 901
 902   if (TREE_CODE (else_) == SSA_NAME)
 903     reexamine |= merge_object_sizes (osi, var, else_, 0);
 904   else
 905     expr_object_size (osi, var, else_);
 906
 907   return reexamine;
 908 }
 909
 910 /* Compute object sizes for VAR.
 911    For ADDR_EXPR an object size is the number of remaining bytes
 912    to the end of the object (where what is considered an object depends on
 913    OSI->object_size_type).
 914    For allocation GIMPLE_CALL like malloc or calloc object size is the size
 915    of the allocation.
 916    For POINTER_PLUS_EXPR where second operand is a constant integer,
 917    object size is object size of the first operand minus the constant.
 918    If the constant is bigger than the number of remaining bytes until the
 919    end of the object, object size is 0, but if it is instead a pointer
 920    subtraction, object size is unknown[object_size_type].
 921    To differentiate addition from subtraction, ADDR_EXPR returns
 922    unknown[object_size_type] for all objects bigger than half of the address
 923    space, and constants less than half of the address space are considered
 924    addition, while bigger constants subtraction.
 925    For a memcpy like GIMPLE_CALL that always returns one of its arguments, the
 926    object size is object size of that argument.
 927    Otherwise, object size is the maximum of object sizes of variables
 928    that it might be set to.  */
 929
 930 static void
 931 collect_object_sizes_for (struct object_size_info *osi, tree var)
 932 {
 933   int object_size_type = osi->object_size_type;
 934   unsigned int varno = SSA_NAME_VERSION (var);
 935   gimple *stmt;
 936   bool reexamine;
 937
 938   if (bitmap_bit_p (computed[object_size_type], varno))
 939     return;
 940
 941   if (osi->pass == 0)
 942     {
 943       if (bitmap_set_bit (osi->visited, varno))
 944         {
 945           object_sizes[object_size_type][varno]
 946             = (object_size_type & 2) ? -1 : 0;
 947         }
 948       else
 949         {
 950           /* Found a dependency loop.  Mark the variable for later
 951              re-examination.  */
 952           bitmap_set_bit (osi->reexamine, varno);
 953           if (dump_file && (dump_flags & TDF_DETAILS))
 954             {
 955               fprintf (dump_file, "Found a dependency loop at ");
 956               print_generic_expr (dump_file, var, dump_flags);
 957               fprintf (dump_file, "\n");
 958             }
 959           return;
 960         }
 961     }
 962
 963   if (dump_file && (dump_flags & TDF_DETAILS))
 964     {
 965       fprintf (dump_file, "Visiting use-def links for ");
 966       print_generic_expr (dump_file, var, dump_flags);
 967       fprintf (dump_file, "\n");
 968     }
 969
 970   stmt = SSA_NAME_DEF_STMT (var);
 971   reexamine = false;
 972
 973   switch (gimple_code (stmt))
 974     {
 975     case GIMPLE_ASSIGN:
 976       {
 977         tree rhs = gimple_assign_rhs1 (stmt);
 978         if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
 979             || (gimple_assign_rhs_code (stmt) == ADDR_EXPR
 980                 && TREE_CODE (TREE_OPERAND (rhs, 0)) == MEM_REF))
 981           reexamine = plus_stmt_object_size (osi, var, stmt);
 982         else if (gimple_assign_rhs_code (stmt) == COND_EXPR)
 983           reexamine = cond_expr_object_size (osi, var, stmt);
 984         else if (gimple_assign_single_p (stmt)
 985                  || gimple_assign_unary_nop_p (stmt))
 986           {
 987             if (TREE_CODE (rhs) == SSA_NAME
 988                 && POINTER_TYPE_P (TREE_TYPE (rhs)))
 989               reexamine = merge_object_sizes (osi, var, rhs, 0);
 990             else
 991               expr_object_size (osi, var, rhs);
 992           }
 993         else
 994           unknown_object_size (osi, var);
 995         break;
 996       }
 997
 998     case GIMPLE_CALL:
 999       {
1000         gcall *call_stmt = as_a <gcall *> (stmt);
1001         tree arg = pass_through_call (call_stmt);
1002         if (arg)
1003           {
1004             if (TREE_CODE (arg) == SSA_NAME
1005                 && POINTER_TYPE_P (TREE_TYPE (arg)))
1006               reexamine = merge_object_sizes (osi, var, arg, 0);
1007             else
1008               expr_object_size (osi, var, arg);
1009           }
1010         else
1011           call_object_size (osi, var, call_stmt);
1012         break;
1013       }
1014
1015     case GIMPLE_ASM:
1016       /* Pointers defined by __asm__ statements can point anywhere.  */
1017       object_sizes[object_size_type][varno] = unknown[object_size_type];
1018       break;
1019
1020     case GIMPLE_NOP:
1021       if (SSA_NAME_VAR (var)
1022           && TREE_CODE (SSA_NAME_VAR (var)) == PARM_DECL)
1023         expr_object_size (osi, var, SSA_NAME_VAR (var));
1024       else
1025         /* Uninitialized SSA names point nowhere.  */
1026         object_sizes[object_size_type][varno] = unknown[object_size_type];
1027       break;
1028
1029     case GIMPLE_PHI:
1030       {
1031         unsigned i;
1032
1033         for (i = 0; i < gimple_phi_num_args (stmt); i++)
1034           {
1035             tree rhs = gimple_phi_arg (stmt, i)->def;
1036
1037             if (object_sizes[object_size_type][varno]
1038                 == unknown[object_size_type])
1039               break;
1040
1041             if (TREE_CODE (rhs) == SSA_NAME)
1042               reexamine |= merge_object_sizes (osi, var, rhs, 0);
1043             else if (osi->pass == 0)
1044               expr_object_size (osi, var, rhs);
1045           }
1046         break;
1047       }
1048
1049     default:
1050       gcc_unreachable ();
1051     }
1052
1053   if (! reexamine
1054       || object_sizes[object_size_type][varno] == unknown[object_size_type])
1055     {
1056       bitmap_set_bit (computed[object_size_type], varno);
1057       bitmap_clear_bit (osi->reexamine, varno);
1058     }
1059   else
1060     {
1061       bitmap_set_bit (osi->reexamine, varno);
1062       if (dump_file && (dump_flags & TDF_DETAILS))
1063         {
1064           fprintf (dump_file, "Need to reexamine ");
1065           print_generic_expr (dump_file, var, dump_flags);
1066           fprintf (dump_file, "\n");
1067         }
1068     }
1069 }
1070
1071
1072 /* Helper function for check_for_plus_in_loops.  Called recursively
1073    to detect loops.  */
1074
1075 static void
1076 check_for_plus_in_loops_1 (struct object_size_info *osi, tree var,
1077                            unsigned int depth)
1078 {
1079   gimple *stmt = SSA_NAME_DEF_STMT (var);
1080   unsigned int varno = SSA_NAME_VERSION (var);
1081
1082   if (osi->depths[varno])
1083     {
1084       if (osi->depths[varno] != depth)
1085         {
1086           unsigned int *sp;
1087
1088           /* Found a loop involving pointer addition.  */
1089           for (sp = osi->tos; sp > osi->stack; )
1090             {
1091               --sp;
1092               bitmap_clear_bit (osi->reexamine, *sp);
1093               bitmap_set_bit (computed[osi->object_size_type], *sp);
1094               object_sizes[osi->object_size_type][*sp] = 0;
1095               if (*sp == varno)
1096                 break;
1097             }
1098         }
1099       return;
1100     }
1101   else if (! bitmap_bit_p (osi->reexamine, varno))
1102     return;
1103
1104   osi->depths[varno] = depth;
1105   *osi->tos++ = varno;
1106
1107   switch (gimple_code (stmt))
1108     {
1109
1110     case GIMPLE_ASSIGN:
1111       {
1112         if ((gimple_assign_single_p (stmt)
1113              || gimple_assign_unary_nop_p (stmt))
1114             && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
1115           {
1116             tree rhs = gimple_assign_rhs1 (stmt);
1117
1118             check_for_plus_in_loops_1 (osi, rhs, depth);
1119           }
1120         else if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
1121           {
1122             tree basevar = gimple_assign_rhs1 (stmt);
1123             tree cst = gimple_assign_rhs2 (stmt);
1124
1125             gcc_assert (TREE_CODE (cst) == INTEGER_CST);
1126
1127             check_for_plus_in_loops_1 (osi, basevar,
1128                                        depth + !integer_zerop (cst));
1129           }
1130         else
1131           gcc_unreachable ();
1132         break;
1133       }
1134
1135     case GIMPLE_CALL:
1136       {
1137         gcall *call_stmt = as_a <gcall *> (stmt);
1138         tree arg = pass_through_call (call_stmt);
1139         if (arg)
1140           {
1141             if (TREE_CODE (arg) == SSA_NAME)
1142               check_for_plus_in_loops_1 (osi, arg, depth);
1143             else
1144               gcc_unreachable ();
1145           }
1146         break;
1147       }
1148
1149     case GIMPLE_PHI:
1150       {
1151         unsigned i;
1152
1153         for (i = 0; i < gimple_phi_num_args (stmt); i++)
1154           {
1155             tree rhs = gimple_phi_arg (stmt, i)->def;
1156
1157             if (TREE_CODE (rhs) == SSA_NAME)
1158               check_for_plus_in_loops_1 (osi, rhs, depth);
1159           }
1160         break;
1161       }
1162
1163     default:
1164       gcc_unreachable ();
1165     }
1166
1167   osi->depths[varno] = 0;
1168   osi->tos--;
1169 }
1170
1171
1172 /* Check if some pointer we are computing object size of is being increased
1173    within a loop.  If yes, assume all the SSA variables participating in
1174    that loop have minimum object sizes 0.  */
1175
1176 static void
1177 check_for_plus_in_loops (struct object_size_info *osi, tree var)
1178 {
1179   gimple *stmt = SSA_NAME_DEF_STMT (var);
1180
1181   /* NOTE: In the pre-tuples code, we handled a CALL_EXPR here,
1182      and looked for a POINTER_PLUS_EXPR in the pass-through
1183      argument, if any.  In GIMPLE, however, such an expression
1184      is not a valid call operand.  */
1185
1186   if (is_gimple_assign (stmt)
1187       && gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR)
1188     {
1189       tree basevar = gimple_assign_rhs1 (stmt);
1190       tree cst = gimple_assign_rhs2 (stmt);
1191
1192       gcc_assert (TREE_CODE (cst) == INTEGER_CST);
1193
1194       if (integer_zerop (cst))
1195         return;
1196
1197       osi->depths[SSA_NAME_VERSION (basevar)] = 1;
1198       *osi->tos++ = SSA_NAME_VERSION (basevar);
1199       check_for_plus_in_loops_1 (osi, var, 2);
1200       osi->depths[SSA_NAME_VERSION (basevar)] = 0;
1201       osi->tos--;
1202     }
1203 }
1204
1205
1206 /* Initialize data structures for the object size computation.  */
1207
1208 void
1209 init_object_sizes (void)
1210 {
1211   int object_size_type;
1212
1213   if (computed[0])
1214     return;
1215
1216   for (object_size_type = 0; object_size_type <= 3; object_size_type++)
1217     {
1218       object_sizes[object_size_type].safe_grow (num_ssa_names);
1219       computed[object_size_type] = BITMAP_ALLOC (NULL);
1220     }
1221
1222   init_offset_limit ();
1223 }
1224
1225
1226 /* Destroy data structures after the object size computation.  */
1227
1228 void
1229 fini_object_sizes (void)
1230 {
1231   int object_size_type;
1232
1233   for (object_size_type = 0; object_size_type <= 3; object_size_type++)
1234     {
1235       object_sizes[object_size_type].release ();
1236       BITMAP_FREE (computed[object_size_type]);
1237     }
1238 }
1239
1240
1241 /* Simple pass to optimize all __builtin_object_size () builtins.  */
1242
1243 namespace {
1244
1245 const pass_data pass_data_object_sizes =
1246 {
1247   GIMPLE_PASS, /* type */
1248   "objsz", /* name */
1249   OPTGROUP_NONE, /* optinfo_flags */
1250   TV_NONE, /* tv_id */
1251   ( PROP_cfg | PROP_ssa ), /* properties_required */
1252   0, /* properties_provided */
1253   0, /* properties_destroyed */
1254   0, /* todo_flags_start */
1255   0, /* todo_flags_finish */
1256 };
1257
1258 class pass_object_sizes : public gimple_opt_pass
1259 {
1260 public:
1261   pass_object_sizes (gcc::context *ctxt)
1262     : gimple_opt_pass (pass_data_object_sizes, ctxt), insert_min_max_p (false)
1263   {}
1264
1265   /* opt_pass methods: */
1266   opt_pass * clone () { return new pass_object_sizes (m_ctxt); }
1267   void set_pass_param (unsigned int n, bool param)
1268     {
1269       gcc_assert (n == 0);
1270       insert_min_max_p = param;
1271     }
1272   virtual unsigned int execute (function *);
1273
1274  private:
1275   /* Determines whether the pass instance creates MIN/MAX_EXPRs.  */
1276   bool insert_min_max_p;
1277 }; // class pass_object_sizes
1278
1279 /* Dummy valueize function.  */
1280
1281 static tree
1282 do_valueize (tree t)
1283 {
1284   return t;
1285 }
1286
1287 unsigned int
1288 pass_object_sizes::execute (function *fun)
1289 {
1290   basic_block bb;
1291   FOR_EACH_BB_FN (bb, fun)
1292     {
1293       gimple_stmt_iterator i;
1294       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
1295         {
1296           tree result;
1297           gimple *call = gsi_stmt (i);
1298           if (!gimple_call_builtin_p (call, BUILT_IN_OBJECT_SIZE))
1299             continue;
1300
1301           init_object_sizes ();
1302
1303           /* If insert_min_max_p, only attempt to fold
1304              __builtin_object_size (x, 1) and __builtin_object_size (x, 3),
1305              and rather than folding the builtin to the constant if any,
1306              create a MIN_EXPR or MAX_EXPR of the __builtin_object_size
1307              call result and the computed constant.  */
1308           if (insert_min_max_p)
1309             {
1310               tree ost = gimple_call_arg (call, 1);
1311               if (tree_fits_uhwi_p (ost))
1312                 {
1313                   unsigned HOST_WIDE_INT object_size_type = tree_to_uhwi (ost);
1314                   tree ptr = gimple_call_arg (call, 0);
1315                   tree lhs = gimple_call_lhs (call);
1316                   if ((object_size_type == 1 || object_size_type == 3)
1317                       && (TREE_CODE (ptr) == ADDR_EXPR
1318                           || TREE_CODE (ptr) == SSA_NAME)
1319                       && lhs)
1320                     {
1321                       tree type = TREE_TYPE (lhs);
1322                       unsigned HOST_WIDE_INT bytes;
1323                       if (compute_builtin_object_size (ptr, object_size_type,
1324                                                        &bytes)
1325                           && wi::fits_to_tree_p (bytes, type))
1326                         {
1327                           tree tem = make_ssa_name (type);
1328                           gimple_call_set_lhs (call, tem);
1329                           enum tree_code code
1330                             = object_size_type == 1 ? MIN_EXPR : MAX_EXPR;
1331                           tree cst = build_int_cstu (type, bytes);
1332                           gimple *g
1333                             = gimple_build_assign (lhs, code, tem, cst);
1334                           gsi_insert_after (&i, g, GSI_NEW_STMT);
1335                           update_stmt (call);
1336                         }
1337                     }
1338                 }
1339               continue;
1340             }
1341
1342           tree lhs = gimple_call_lhs (call);
1343           if (!lhs)
1344             continue;
1345
1346           result = gimple_fold_stmt_to_constant (call, do_valueize);
1347           if (!result)
1348             {
1349               tree ost = gimple_call_arg (call, 1);
1350
1351               if (tree_fits_uhwi_p (ost))
1352                 {
1353                   unsigned HOST_WIDE_INT object_size_type = tree_to_uhwi (ost);
1354
1355                   if (object_size_type < 2)
1356                     result = fold_convert (size_type_node,
1357                                            integer_minus_one_node);
1358                   else if (object_size_type < 4)
1359                     result = build_zero_cst (size_type_node);
1360                 }
1361
1362               if (!result)
1363                 continue;
1364             }
1365
1366           gcc_assert (TREE_CODE (result) == INTEGER_CST);
1367
1368           if (dump_file && (dump_flags & TDF_DETAILS))
1369             {
1370               fprintf (dump_file, "Simplified\n  ");
1371               print_gimple_stmt (dump_file, call, 0, dump_flags);
1372               fprintf (dump_file, " to ");
1373               print_generic_expr (dump_file, result);
1374               fprintf (dump_file, "\n");
1375             }
1376
1377           /* Propagate into all uses and fold those stmts.  */
1378           replace_uses_by (lhs, result);
1379         }
1380     }
1381
1382   fini_object_sizes ();
1383   return 0;
1384 }
1385
1386 } // anon namespace
1387
1388 gimple_opt_pass *
1389 make_pass_object_sizes (gcc::context *ctxt)
1390 {
1391   return new pass_object_sizes (ctxt);
1392 }