gcc/asan.c

   1 /* AddressSanitizer, a fast memory error detector.
   2    Copyright (C) 2012-2013 Free Software Foundation, Inc.
   3    Contributed by Kostya Serebryany <kcc@google.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
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "gimple.h"
  26 #include "tree-iterator.h"
  27 #include "tree-ssa.h"
  28 #include "tree-pass.h"
  29 #include "asan.h"
  30 #include "gimple-pretty-print.h"
  31 #include "target.h"
  32 #include "expr.h"
  33 #include "optabs.h"
  34 #include "output.h"
  35 #include "tm_p.h"
  36 #include "langhooks.h"
  37 #include "hash-table.h"
  38 #include "alloc-pool.h"
  39 #include "cfgloop.h"
  40 #include "gimple-builder.h"
  41
  42 /* AddressSanitizer finds out-of-bounds and use-after-free bugs
  43    with <2x slowdown on average.
  44
  45    The tool consists of two parts:
  46    instrumentation module (this file) and a run-time library.
  47    The instrumentation module adds a run-time check before every memory insn.
  48      For a 8- or 16- byte load accessing address X:
  49        ShadowAddr = (X >> 3) + Offset
  50        ShadowValue = *(char*)ShadowAddr;  // *(short*) for 16-byte access.
  51        if (ShadowValue)
  52          __asan_report_load8(X);
  53      For a load of N bytes (N=1, 2 or 4) from address X:
  54        ShadowAddr = (X >> 3) + Offset
  55        ShadowValue = *(char*)ShadowAddr;
  56        if (ShadowValue)
  57          if ((X & 7) + N - 1 > ShadowValue)
  58            __asan_report_loadN(X);
  59    Stores are instrumented similarly, but using __asan_report_storeN functions.
  60    A call too __asan_init() is inserted to the list of module CTORs.
  61
  62    The run-time library redefines malloc (so that redzone are inserted around
  63    the allocated memory) and free (so that reuse of free-ed memory is delayed),
  64    provides __asan_report* and __asan_init functions.
  65
  66    Read more:
  67    http://code.google.com/p/address-sanitizer/wiki/AddressSanitizerAlgorithm
  68
  69    The current implementation supports detection of out-of-bounds and
  70    use-after-free in the heap, on the stack and for global variables.
  71
  72    [Protection of stack variables]
  73
  74    To understand how detection of out-of-bounds and use-after-free works
  75    for stack variables, lets look at this example on x86_64 where the
  76    stack grows downward:
  77
  78      int
  79      foo ()
  80      {
  81        char a[23] = {0};
  82        int b[2] = {0};
  83
  84        a[5] = 1;
  85        b[1] = 2;
  86
  87        return a[5] + b[1];
  88      }
  89
  90    For this function, the stack protected by asan will be organized as
  91    follows, from the top of the stack to the bottom:
  92
  93    Slot 1/ [red zone of 32 bytes called 'RIGHT RedZone']
  94
  95    Slot 2/ [8 bytes of red zone, that adds up to the space of 'a' to make
  96            the next slot be 32 bytes aligned; this one is called Partial
  97            Redzone; this 32 bytes alignment is an asan constraint]
  98
  99    Slot 3/ [24 bytes for variable 'a']
 100
 101    Slot 4/ [red zone of 32 bytes called 'Middle RedZone']
 102
 103    Slot 5/ [24 bytes of Partial Red Zone (similar to slot 2]
 104
 105    Slot 6/ [8 bytes for variable 'b']
 106
 107    Slot 7/ [32 bytes of Red Zone at the bottom of the stack, called
 108             'LEFT RedZone']
 109
 110    The 32 bytes of LEFT red zone at the bottom of the stack can be
 111    decomposed as such:
 112
 113      1/ The first 8 bytes contain a magical asan number that is always
 114      0x41B58AB3.
 115
 116      2/ The following 8 bytes contains a pointer to a string (to be
 117      parsed at runtime by the runtime asan library), which format is
 118      the following:
 119
 120       "<function-name> <space> <num-of-variables-on-the-stack>
 121       (<32-bytes-aligned-offset-in-bytes-of-variable> <space>
 122       <length-of-var-in-bytes> ){n} "
 123
 124         where '(...){n}' means the content inside the parenthesis occurs 'n'
 125         times, with 'n' being the number of variables on the stack.
 126
 127       3/ The following 16 bytes of the red zone have no particular
 128       format.
 129
 130    The shadow memory for that stack layout is going to look like this:
 131
 132      - content of shadow memory 8 bytes for slot 7: 0xF1F1F1F1.
 133        The F1 byte pattern is a magic number called
 134        ASAN_STACK_MAGIC_LEFT and is a way for the runtime to know that
 135        the memory for that shadow byte is part of a the LEFT red zone
 136        intended to seat at the bottom of the variables on the stack.
 137
 138      - content of shadow memory 8 bytes for slots 6 and 5:
 139        0xF4F4F400.  The F4 byte pattern is a magic number
 140        called ASAN_STACK_MAGIC_PARTIAL.  It flags the fact that the
 141        memory region for this shadow byte is a PARTIAL red zone
 142        intended to pad a variable A, so that the slot following
 143        {A,padding} is 32 bytes aligned.
 144
 145        Note that the fact that the least significant byte of this
 146        shadow memory content is 00 means that 8 bytes of its
 147        corresponding memory (which corresponds to the memory of
 148        variable 'b') is addressable.
 149
 150      - content of shadow memory 8 bytes for slot 4: 0xF2F2F2F2.
 151        The F2 byte pattern is a magic number called
 152        ASAN_STACK_MAGIC_MIDDLE.  It flags the fact that the memory
 153        region for this shadow byte is a MIDDLE red zone intended to
 154        seat between two 32 aligned slots of {variable,padding}.
 155
 156      - content of shadow memory 8 bytes for slot 3 and 2:
 157        0xF4000000.  This represents is the concatenation of
 158        variable 'a' and the partial red zone following it, like what we
 159        had for variable 'b'.  The least significant 3 bytes being 00
 160        means that the 3 bytes of variable 'a' are addressable.
 161
 162      - content of shadow memory 8 bytes for slot 1: 0xF3F3F3F3.
 163        The F3 byte pattern is a magic number called
 164        ASAN_STACK_MAGIC_RIGHT.  It flags the fact that the memory
 165        region for this shadow byte is a RIGHT red zone intended to seat
 166        at the top of the variables of the stack.
 167
 168    Note that the real variable layout is done in expand_used_vars in
 169    cfgexpand.c.  As far as Address Sanitizer is concerned, it lays out
 170    stack variables as well as the different red zones, emits some
 171    prologue code to populate the shadow memory as to poison (mark as
 172    non-accessible) the regions of the red zones and mark the regions of
 173    stack variables as accessible, and emit some epilogue code to
 174    un-poison (mark as accessible) the regions of red zones right before
 175    the function exits.
 176
 177    [Protection of global variables]
 178
 179    The basic idea is to insert a red zone between two global variables
 180    and install a constructor function that calls the asan runtime to do
 181    the populating of the relevant shadow memory regions at load time.
 182
 183    So the global variables are laid out as to insert a red zone between
 184    them. The size of the red zones is so that each variable starts on a
 185    32 bytes boundary.
 186
 187    Then a constructor function is installed so that, for each global
 188    variable, it calls the runtime asan library function
 189    __asan_register_globals_with an instance of this type:
 190
 191      struct __asan_global
 192      {
 193        // Address of the beginning of the global variable.
 194        const void *__beg;
 195
 196        // Initial size of the global variable.
 197        uptr __size;
 198
 199        // Size of the global variable + size of the red zone.  This
 200        //   size is 32 bytes aligned.
 201        uptr __size_with_redzone;
 202
 203        // Name of the global variable.
 204        const void *__name;
 205
 206        // This is always set to NULL for now.
 207        uptr __has_dynamic_init;
 208      }
 209
 210    A destructor function that calls the runtime asan library function
 211    _asan_unregister_globals is also installed.  */
 212
 213 alias_set_type asan_shadow_set = -1;
 214
 215 /* Pointer types to 1 resp. 2 byte integers in shadow memory.  A separate
 216    alias set is used for all shadow memory accesses.  */
 217 static GTY(()) tree shadow_ptr_types[2];
 218
 219 /* Hashtable support for memory references used by gimple
 220    statements.  */
 221
 222 /* This type represents a reference to a memory region.  */
 223 struct asan_mem_ref
 224 {
 225   /* The expression of the beginning of the memory region.  */
 226   tree start;
 227
 228   /* The size of the access (can be 1, 2, 4, 8, 16 for now).  */
 229   char access_size;
 230 };
 231
 232 static alloc_pool asan_mem_ref_alloc_pool;
 233
 234 /* This creates the alloc pool used to store the instances of
 235    asan_mem_ref that are stored in the hash table asan_mem_ref_ht.  */
 236
 237 static alloc_pool
 238 asan_mem_ref_get_alloc_pool ()
 239 {
 240   if (asan_mem_ref_alloc_pool == NULL)
 241     asan_mem_ref_alloc_pool = create_alloc_pool ("asan_mem_ref",
 242                                                  sizeof (asan_mem_ref),
 243                                                  10);
 244   return asan_mem_ref_alloc_pool;
 245
 246 }
 247
 248 /* Initializes an instance of asan_mem_ref.  */
 249
 250 static void
 251 asan_mem_ref_init (asan_mem_ref *ref, tree start, char access_size)
 252 {
 253   ref->start = start;
 254   ref->access_size = access_size;
 255 }
 256
 257 /* Allocates memory for an instance of asan_mem_ref into the memory
 258    pool returned by asan_mem_ref_get_alloc_pool and initialize it.
 259    START is the address of (or the expression pointing to) the
 260    beginning of memory reference.  ACCESS_SIZE is the size of the
 261    access to the referenced memory.  */
 262
 263 static asan_mem_ref*
 264 asan_mem_ref_new (tree start, char access_size)
 265 {
 266   asan_mem_ref *ref =
 267     (asan_mem_ref *) pool_alloc (asan_mem_ref_get_alloc_pool ());
 268
 269   asan_mem_ref_init (ref, start, access_size);
 270   return ref;
 271 }
 272
 273 /* This builds and returns a pointer to the end of the memory region
 274    that starts at START and of length LEN.  */
 275
 276 tree
 277 asan_mem_ref_get_end (tree start, tree len)
 278 {
 279   if (len == NULL_TREE || integer_zerop (len))
 280     return start;
 281
 282   return fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (start), start, len);
 283 }
 284
 285 /*  Return a tree expression that represents the end of the referenced
 286     memory region.  Beware that this function can actually build a new
 287     tree expression.  */
 288
 289 tree
 290 asan_mem_ref_get_end (const asan_mem_ref *ref, tree len)
 291 {
 292   return asan_mem_ref_get_end (ref->start, len);
 293 }
 294
 295 struct asan_mem_ref_hasher
 296   : typed_noop_remove <asan_mem_ref>
 297 {
 298   typedef asan_mem_ref value_type;
 299   typedef asan_mem_ref compare_type;
 300
 301   static inline hashval_t hash (const value_type *);
 302   static inline bool equal (const value_type *, const compare_type *);
 303 };
 304
 305 /* Hash a memory reference.  */
 306
 307 inline hashval_t
 308 asan_mem_ref_hasher::hash (const asan_mem_ref *mem_ref)
 309 {
 310   hashval_t h = iterative_hash_expr (mem_ref->start, 0);
 311   h = iterative_hash_hashval_t (h, mem_ref->access_size);
 312   return h;
 313 }
 314
 315 /* Compare two memory references.  We accept the length of either
 316    memory references to be NULL_TREE.  */
 317
 318 inline bool
 319 asan_mem_ref_hasher::equal (const asan_mem_ref *m1,
 320                             const asan_mem_ref *m2)
 321 {
 322   return (m1->access_size == m2->access_size
 323           && operand_equal_p (m1->start, m2->start, 0));
 324 }
 325
 326 static hash_table <asan_mem_ref_hasher> asan_mem_ref_ht;
 327
 328 /* Returns a reference to the hash table containing memory references.
 329    This function ensures that the hash table is created.  Note that
 330    this hash table is updated by the function
 331    update_mem_ref_hash_table.  */
 332
 333 static hash_table <asan_mem_ref_hasher> &
 334 get_mem_ref_hash_table ()
 335 {
 336   if (!asan_mem_ref_ht.is_created ())
 337     asan_mem_ref_ht.create (10);
 338
 339   return asan_mem_ref_ht;
 340 }
 341
 342 /* Clear all entries from the memory references hash table.  */
 343
 344 static void
 345 empty_mem_ref_hash_table ()
 346 {
 347   if (asan_mem_ref_ht.is_created ())
 348     asan_mem_ref_ht.empty ();
 349 }
 350
 351 /* Free the memory references hash table.  */
 352
 353 static void
 354 free_mem_ref_resources ()
 355 {
 356   if (asan_mem_ref_ht.is_created ())
 357     asan_mem_ref_ht.dispose ();
 358
 359   if (asan_mem_ref_alloc_pool)
 360     {
 361       free_alloc_pool (asan_mem_ref_alloc_pool);
 362       asan_mem_ref_alloc_pool = NULL;
 363     }
 364 }
 365
 366 /* Return true iff the memory reference REF has been instrumented.  */
 367
 368 static bool
 369 has_mem_ref_been_instrumented (tree ref, char access_size)
 370 {
 371   asan_mem_ref r;
 372   asan_mem_ref_init (&r, ref, access_size);
 373
 374   return (get_mem_ref_hash_table ().find (&r) != NULL);
 375 }
 376
 377 /* Return true iff the memory reference REF has been instrumented.  */
 378
 379 static bool
 380 has_mem_ref_been_instrumented (const asan_mem_ref *ref)
 381 {
 382   return has_mem_ref_been_instrumented (ref->start, ref->access_size);
 383 }
 384
 385 /* Return true iff access to memory region starting at REF and of
 386    length LEN has been instrumented.  */
 387
 388 static bool
 389 has_mem_ref_been_instrumented (const asan_mem_ref *ref, tree len)
 390 {
 391   /* First let's see if the address of the beginning of REF has been
 392      instrumented.  */
 393   if (!has_mem_ref_been_instrumented (ref))
 394     return false;
 395
 396   if (len != 0)
 397     {
 398       /* Let's see if the end of the region has been instrumented.  */
 399       if (!has_mem_ref_been_instrumented (asan_mem_ref_get_end (ref, len),
 400                                           ref->access_size))
 401         return false;
 402     }
 403   return true;
 404 }
 405
 406 /* Set REF to the memory reference present in a gimple assignment
 407    ASSIGNMENT.  Return true upon successful completion, false
 408    otherwise.  */
 409
 410 static bool
 411 get_mem_ref_of_assignment (const gimple assignment,
 412                            asan_mem_ref *ref,
 413                            bool *ref_is_store)
 414 {
 415   gcc_assert (gimple_assign_single_p (assignment));
 416
 417   if (gimple_store_p (assignment)
 418       && !gimple_clobber_p (assignment))
 419     {
 420       ref->start = gimple_assign_lhs (assignment);
 421       *ref_is_store = true;
 422     }
 423   else if (gimple_assign_load_p (assignment))
 424     {
 425       ref->start = gimple_assign_rhs1 (assignment);
 426       *ref_is_store = false;
 427     }
 428   else
 429     return false;
 430
 431   ref->access_size = int_size_in_bytes (TREE_TYPE (ref->start));
 432   return true;
 433 }
 434
 435 /* Return the memory references contained in a gimple statement
 436    representing a builtin call that has to do with memory access.  */
 437
 438 static bool
 439 get_mem_refs_of_builtin_call (const gimple call,
 440                               asan_mem_ref *src0,
 441                               tree *src0_len,
 442                               bool *src0_is_store,
 443                               asan_mem_ref *src1,
 444                               tree *src1_len,
 445                               bool *src1_is_store,
 446                               asan_mem_ref *dst,
 447                               tree *dst_len,
 448                               bool *dst_is_store,
 449                               bool *dest_is_deref)
 450 {
 451   gcc_checking_assert (gimple_call_builtin_p (call, BUILT_IN_NORMAL));
 452
 453   tree callee = gimple_call_fndecl (call);
 454   tree source0 = NULL_TREE, source1 = NULL_TREE,
 455     dest = NULL_TREE, len = NULL_TREE;
 456   bool is_store = true, got_reference_p = false;
 457   char access_size = 1;
 458
 459   switch (DECL_FUNCTION_CODE (callee))
 460     {
 461       /* (s, s, n) style memops.  */
 462     case BUILT_IN_BCMP:
 463     case BUILT_IN_MEMCMP:
 464       source0 = gimple_call_arg (call, 0);
 465       source1 = gimple_call_arg (call, 1);
 466       len = gimple_call_arg (call, 2);
 467       break;
 468
 469       /* (src, dest, n) style memops.  */
 470     case BUILT_IN_BCOPY:
 471       source0 = gimple_call_arg (call, 0);
 472       dest = gimple_call_arg (call, 1);
 473       len = gimple_call_arg (call, 2);
 474       break;
 475
 476       /* (dest, src, n) style memops.  */
 477     case BUILT_IN_MEMCPY:
 478     case BUILT_IN_MEMCPY_CHK:
 479     case BUILT_IN_MEMMOVE:
 480     case BUILT_IN_MEMMOVE_CHK:
 481     case BUILT_IN_MEMPCPY:
 482     case BUILT_IN_MEMPCPY_CHK:
 483       dest = gimple_call_arg (call, 0);
 484       source0 = gimple_call_arg (call, 1);
 485       len = gimple_call_arg (call, 2);
 486       break;
 487
 488       /* (dest, n) style memops.  */
 489     case BUILT_IN_BZERO:
 490       dest = gimple_call_arg (call, 0);
 491       len = gimple_call_arg (call, 1);
 492       break;
 493
 494       /* (dest, x, n) style memops*/
 495     case BUILT_IN_MEMSET:
 496     case BUILT_IN_MEMSET_CHK:
 497       dest = gimple_call_arg (call, 0);
 498       len = gimple_call_arg (call, 2);
 499       break;
 500
 501     case BUILT_IN_STRLEN:
 502       source0 = gimple_call_arg (call, 0);
 503       len = gimple_call_lhs (call);
 504       break ;
 505
 506     /* And now the __atomic* and __sync builtins.
 507        These are handled differently from the classical memory memory
 508        access builtins above.  */
 509
 510     case BUILT_IN_ATOMIC_LOAD_1:
 511     case BUILT_IN_ATOMIC_LOAD_2:
 512     case BUILT_IN_ATOMIC_LOAD_4:
 513     case BUILT_IN_ATOMIC_LOAD_8:
 514     case BUILT_IN_ATOMIC_LOAD_16:
 515       is_store = false;
 516       /* fall through.  */
 517
 518     case BUILT_IN_SYNC_FETCH_AND_ADD_1:
 519     case BUILT_IN_SYNC_FETCH_AND_ADD_2:
 520     case BUILT_IN_SYNC_FETCH_AND_ADD_4:
 521     case BUILT_IN_SYNC_FETCH_AND_ADD_8:
 522     case BUILT_IN_SYNC_FETCH_AND_ADD_16:
 523
 524     case BUILT_IN_SYNC_FETCH_AND_SUB_1:
 525     case BUILT_IN_SYNC_FETCH_AND_SUB_2:
 526     case BUILT_IN_SYNC_FETCH_AND_SUB_4:
 527     case BUILT_IN_SYNC_FETCH_AND_SUB_8:
 528     case BUILT_IN_SYNC_FETCH_AND_SUB_16:
 529
 530     case BUILT_IN_SYNC_FETCH_AND_OR_1:
 531     case BUILT_IN_SYNC_FETCH_AND_OR_2:
 532     case BUILT_IN_SYNC_FETCH_AND_OR_4:
 533     case BUILT_IN_SYNC_FETCH_AND_OR_8:
 534     case BUILT_IN_SYNC_FETCH_AND_OR_16:
 535
 536     case BUILT_IN_SYNC_FETCH_AND_AND_1:
 537     case BUILT_IN_SYNC_FETCH_AND_AND_2:
 538     case BUILT_IN_SYNC_FETCH_AND_AND_4:
 539     case BUILT_IN_SYNC_FETCH_AND_AND_8:
 540     case BUILT_IN_SYNC_FETCH_AND_AND_16:
 541
 542     case BUILT_IN_SYNC_FETCH_AND_XOR_1:
 543     case BUILT_IN_SYNC_FETCH_AND_XOR_2:
 544     case BUILT_IN_SYNC_FETCH_AND_XOR_4:
 545     case BUILT_IN_SYNC_FETCH_AND_XOR_8:
 546     case BUILT_IN_SYNC_FETCH_AND_XOR_16:
 547
 548     case BUILT_IN_SYNC_FETCH_AND_NAND_1:
 549     case BUILT_IN_SYNC_FETCH_AND_NAND_2:
 550     case BUILT_IN_SYNC_FETCH_AND_NAND_4:
 551     case BUILT_IN_SYNC_FETCH_AND_NAND_8:
 552
 553     case BUILT_IN_SYNC_ADD_AND_FETCH_1:
 554     case BUILT_IN_SYNC_ADD_AND_FETCH_2:
 555     case BUILT_IN_SYNC_ADD_AND_FETCH_4:
 556     case BUILT_IN_SYNC_ADD_AND_FETCH_8:
 557     case BUILT_IN_SYNC_ADD_AND_FETCH_16:
 558
 559     case BUILT_IN_SYNC_SUB_AND_FETCH_1:
 560     case BUILT_IN_SYNC_SUB_AND_FETCH_2:
 561     case BUILT_IN_SYNC_SUB_AND_FETCH_4:
 562     case BUILT_IN_SYNC_SUB_AND_FETCH_8:
 563     case BUILT_IN_SYNC_SUB_AND_FETCH_16:
 564
 565     case BUILT_IN_SYNC_OR_AND_FETCH_1:
 566     case BUILT_IN_SYNC_OR_AND_FETCH_2:
 567     case BUILT_IN_SYNC_OR_AND_FETCH_4:
 568     case BUILT_IN_SYNC_OR_AND_FETCH_8:
 569     case BUILT_IN_SYNC_OR_AND_FETCH_16:
 570
 571     case BUILT_IN_SYNC_AND_AND_FETCH_1:
 572     case BUILT_IN_SYNC_AND_AND_FETCH_2:
 573     case BUILT_IN_SYNC_AND_AND_FETCH_4:
 574     case BUILT_IN_SYNC_AND_AND_FETCH_8:
 575     case BUILT_IN_SYNC_AND_AND_FETCH_16:
 576
 577     case BUILT_IN_SYNC_XOR_AND_FETCH_1:
 578     case BUILT_IN_SYNC_XOR_AND_FETCH_2:
 579     case BUILT_IN_SYNC_XOR_AND_FETCH_4:
 580     case BUILT_IN_SYNC_XOR_AND_FETCH_8:
 581     case BUILT_IN_SYNC_XOR_AND_FETCH_16:
 582
 583     case BUILT_IN_SYNC_NAND_AND_FETCH_1:
 584     case BUILT_IN_SYNC_NAND_AND_FETCH_2:
 585     case BUILT_IN_SYNC_NAND_AND_FETCH_4:
 586     case BUILT_IN_SYNC_NAND_AND_FETCH_8:
 587
 588     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1:
 589     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2:
 590     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4:
 591     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8:
 592     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16:
 593
 594     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1:
 595     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2:
 596     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4:
 597     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8:
 598     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16:
 599
 600     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1:
 601     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2:
 602     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4:
 603     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8:
 604     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16:
 605
 606     case BUILT_IN_SYNC_LOCK_RELEASE_1:
 607     case BUILT_IN_SYNC_LOCK_RELEASE_2:
 608     case BUILT_IN_SYNC_LOCK_RELEASE_4:
 609     case BUILT_IN_SYNC_LOCK_RELEASE_8:
 610     case BUILT_IN_SYNC_LOCK_RELEASE_16:
 611
 612     case BUILT_IN_ATOMIC_EXCHANGE_1:
 613     case BUILT_IN_ATOMIC_EXCHANGE_2:
 614     case BUILT_IN_ATOMIC_EXCHANGE_4:
 615     case BUILT_IN_ATOMIC_EXCHANGE_8:
 616     case BUILT_IN_ATOMIC_EXCHANGE_16:
 617
 618     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1:
 619     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2:
 620     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4:
 621     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8:
 622     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
 623
 624     case BUILT_IN_ATOMIC_STORE_1:
 625     case BUILT_IN_ATOMIC_STORE_2:
 626     case BUILT_IN_ATOMIC_STORE_4:
 627     case BUILT_IN_ATOMIC_STORE_8:
 628     case BUILT_IN_ATOMIC_STORE_16:
 629
 630     case BUILT_IN_ATOMIC_ADD_FETCH_1:
 631     case BUILT_IN_ATOMIC_ADD_FETCH_2:
 632     case BUILT_IN_ATOMIC_ADD_FETCH_4:
 633     case BUILT_IN_ATOMIC_ADD_FETCH_8:
 634     case BUILT_IN_ATOMIC_ADD_FETCH_16:
 635
 636     case BUILT_IN_ATOMIC_SUB_FETCH_1:
 637     case BUILT_IN_ATOMIC_SUB_FETCH_2:
 638     case BUILT_IN_ATOMIC_SUB_FETCH_4:
 639     case BUILT_IN_ATOMIC_SUB_FETCH_8:
 640     case BUILT_IN_ATOMIC_SUB_FETCH_16:
 641
 642     case BUILT_IN_ATOMIC_AND_FETCH_1:
 643     case BUILT_IN_ATOMIC_AND_FETCH_2:
 644     case BUILT_IN_ATOMIC_AND_FETCH_4:
 645     case BUILT_IN_ATOMIC_AND_FETCH_8:
 646     case BUILT_IN_ATOMIC_AND_FETCH_16:
 647
 648     case BUILT_IN_ATOMIC_NAND_FETCH_1:
 649     case BUILT_IN_ATOMIC_NAND_FETCH_2:
 650     case BUILT_IN_ATOMIC_NAND_FETCH_4:
 651     case BUILT_IN_ATOMIC_NAND_FETCH_8:
 652     case BUILT_IN_ATOMIC_NAND_FETCH_16:
 653
 654     case BUILT_IN_ATOMIC_XOR_FETCH_1:
 655     case BUILT_IN_ATOMIC_XOR_FETCH_2:
 656     case BUILT_IN_ATOMIC_XOR_FETCH_4:
 657     case BUILT_IN_ATOMIC_XOR_FETCH_8:
 658     case BUILT_IN_ATOMIC_XOR_FETCH_16:
 659
 660     case BUILT_IN_ATOMIC_OR_FETCH_1:
 661     case BUILT_IN_ATOMIC_OR_FETCH_2:
 662     case BUILT_IN_ATOMIC_OR_FETCH_4:
 663     case BUILT_IN_ATOMIC_OR_FETCH_8:
 664     case BUILT_IN_ATOMIC_OR_FETCH_16:
 665
 666     case BUILT_IN_ATOMIC_FETCH_ADD_1:
 667     case BUILT_IN_ATOMIC_FETCH_ADD_2:
 668     case BUILT_IN_ATOMIC_FETCH_ADD_4:
 669     case BUILT_IN_ATOMIC_FETCH_ADD_8:
 670     case BUILT_IN_ATOMIC_FETCH_ADD_16:
 671
 672     case BUILT_IN_ATOMIC_FETCH_SUB_1:
 673     case BUILT_IN_ATOMIC_FETCH_SUB_2:
 674     case BUILT_IN_ATOMIC_FETCH_SUB_4:
 675     case BUILT_IN_ATOMIC_FETCH_SUB_8:
 676     case BUILT_IN_ATOMIC_FETCH_SUB_16:
 677
 678     case BUILT_IN_ATOMIC_FETCH_AND_1:
 679     case BUILT_IN_ATOMIC_FETCH_AND_2:
 680     case BUILT_IN_ATOMIC_FETCH_AND_4:
 681     case BUILT_IN_ATOMIC_FETCH_AND_8:
 682     case BUILT_IN_ATOMIC_FETCH_AND_16:
 683
 684     case BUILT_IN_ATOMIC_FETCH_NAND_1:
 685     case BUILT_IN_ATOMIC_FETCH_NAND_2:
 686     case BUILT_IN_ATOMIC_FETCH_NAND_4:
 687     case BUILT_IN_ATOMIC_FETCH_NAND_8:
 688     case BUILT_IN_ATOMIC_FETCH_NAND_16:
 689
 690     case BUILT_IN_ATOMIC_FETCH_XOR_1:
 691     case BUILT_IN_ATOMIC_FETCH_XOR_2:
 692     case BUILT_IN_ATOMIC_FETCH_XOR_4:
 693     case BUILT_IN_ATOMIC_FETCH_XOR_8:
 694     case BUILT_IN_ATOMIC_FETCH_XOR_16:
 695
 696     case BUILT_IN_ATOMIC_FETCH_OR_1:
 697     case BUILT_IN_ATOMIC_FETCH_OR_2:
 698     case BUILT_IN_ATOMIC_FETCH_OR_4:
 699     case BUILT_IN_ATOMIC_FETCH_OR_8:
 700     case BUILT_IN_ATOMIC_FETCH_OR_16:
 701       {
 702         dest = gimple_call_arg (call, 0);
 703         /* DEST represents the address of a memory location.
 704            instrument_derefs wants the memory location, so lets
 705            dereference the address DEST before handing it to
 706            instrument_derefs.  */
 707         if (TREE_CODE (dest) == ADDR_EXPR)
 708           dest = TREE_OPERAND (dest, 0);
 709         else if (TREE_CODE (dest) == SSA_NAME)
 710           dest = build2 (MEM_REF, TREE_TYPE (TREE_TYPE (dest)),
 711                          dest, build_int_cst (TREE_TYPE (dest), 0));
 712         else
 713           gcc_unreachable ();
 714
 715         access_size = int_size_in_bytes (TREE_TYPE (dest));
 716       }
 717
 718     default:
 719       /* The other builtins memory access are not instrumented in this
 720          function because they either don't have any length parameter,
 721          or their length parameter is just a limit.  */
 722       break;
 723     }
 724
 725   if (len != NULL_TREE)
 726     {
 727       if (source0 != NULL_TREE)
 728         {
 729           src0->start = source0;
 730           src0->access_size = access_size;
 731           *src0_len = len;
 732           *src0_is_store = false;
 733         }
 734
 735       if (source1 != NULL_TREE)
 736         {
 737           src1->start = source1;
 738           src1->access_size = access_size;
 739           *src1_len = len;
 740           *src1_is_store = false;
 741         }
 742
 743       if (dest != NULL_TREE)
 744         {
 745           dst->start = dest;
 746           dst->access_size = access_size;
 747           *dst_len = len;
 748           *dst_is_store = true;
 749         }
 750
 751       got_reference_p = true;
 752     }
 753   else if (dest)
 754     {
 755       dst->start = dest;
 756       dst->access_size = access_size;
 757       *dst_len = NULL_TREE;
 758       *dst_is_store = is_store;
 759       *dest_is_deref = true;
 760       got_reference_p = true;
 761     }
 762
 763   return got_reference_p;
 764 }
 765
 766 /* Return true iff a given gimple statement has been instrumented.
 767    Note that the statement is "defined" by the memory references it
 768    contains.  */
 769
 770 static bool
 771 has_stmt_been_instrumented_p (gimple stmt)
 772 {
 773   if (gimple_assign_single_p (stmt))
 774     {
 775       bool r_is_store;
 776       asan_mem_ref r;
 777       asan_mem_ref_init (&r, NULL, 1);
 778
 779       if (get_mem_ref_of_assignment (stmt, &r, &r_is_store))
 780         return has_mem_ref_been_instrumented (&r);
 781     }
 782   else if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
 783     {
 784       asan_mem_ref src0, src1, dest;
 785       asan_mem_ref_init (&src0, NULL, 1);
 786       asan_mem_ref_init (&src1, NULL, 1);
 787       asan_mem_ref_init (&dest, NULL, 1);
 788
 789       tree src0_len = NULL_TREE, src1_len = NULL_TREE, dest_len = NULL_TREE;
 790       bool src0_is_store = false, src1_is_store = false,
 791         dest_is_store = false, dest_is_deref = false;
 792       if (get_mem_refs_of_builtin_call (stmt,
 793                                         &src0, &src0_len, &src0_is_store,
 794                                         &src1, &src1_len, &src1_is_store,
 795                                         &dest, &dest_len, &dest_is_store,
 796                                         &dest_is_deref))
 797         {
 798           if (src0.start != NULL_TREE
 799               && !has_mem_ref_been_instrumented (&src0, src0_len))
 800             return false;
 801
 802           if (src1.start != NULL_TREE
 803               && !has_mem_ref_been_instrumented (&src1, src1_len))
 804             return false;
 805
 806           if (dest.start != NULL_TREE
 807               && !has_mem_ref_been_instrumented (&dest, dest_len))
 808             return false;
 809
 810           return true;
 811         }
 812     }
 813   return false;
 814 }
 815
 816 /*  Insert a memory reference into the hash table.  */
 817
 818 static void
 819 update_mem_ref_hash_table (tree ref, char access_size)
 820 {
 821   hash_table <asan_mem_ref_hasher> ht = get_mem_ref_hash_table ();
 822
 823   asan_mem_ref r;
 824   asan_mem_ref_init (&r, ref, access_size);
 825
 826   asan_mem_ref **slot = ht.find_slot (&r, INSERT);
 827   if (*slot == NULL)
 828     *slot = asan_mem_ref_new (ref, access_size);
 829 }
 830
 831 /* Initialize shadow_ptr_types array.  */
 832
 833 static void
 834 asan_init_shadow_ptr_types (void)
 835 {
 836   asan_shadow_set = new_alias_set ();
 837   shadow_ptr_types[0] = build_distinct_type_copy (signed_char_type_node);
 838   TYPE_ALIAS_SET (shadow_ptr_types[0]) = asan_shadow_set;
 839   shadow_ptr_types[0] = build_pointer_type (shadow_ptr_types[0]);
 840   shadow_ptr_types[1] = build_distinct_type_copy (short_integer_type_node);
 841   TYPE_ALIAS_SET (shadow_ptr_types[1]) = asan_shadow_set;
 842   shadow_ptr_types[1] = build_pointer_type (shadow_ptr_types[1]);
 843   initialize_sanitizer_builtins ();
 844 }
 845
 846 /* Create ADDR_EXPR of STRING_CST with the PP pretty printer text.  */
 847
 848 static tree
 849 asan_pp_string (pretty_printer *pp)
 850 {
 851   const char *buf = pp_formatted_text (pp);
 852   size_t len = strlen (buf);
 853   tree ret = build_string (len + 1, buf);
 854   TREE_TYPE (ret)
 855     = build_array_type (TREE_TYPE (shadow_ptr_types[0]),
 856                         build_index_type (size_int (len)));
 857   TREE_READONLY (ret) = 1;
 858   TREE_STATIC (ret) = 1;
 859   return build1 (ADDR_EXPR, shadow_ptr_types[0], ret);
 860 }
 861
 862 /* Return a CONST_INT representing 4 subsequent shadow memory bytes.  */
 863
 864 static rtx
 865 asan_shadow_cst (unsigned char shadow_bytes[4])
 866 {
 867   int i;
 868   unsigned HOST_WIDE_INT val = 0;
 869   gcc_assert (WORDS_BIG_ENDIAN == BYTES_BIG_ENDIAN);
 870   for (i = 0; i < 4; i++)
 871     val |= (unsigned HOST_WIDE_INT) shadow_bytes[BYTES_BIG_ENDIAN ? 3 - i : i]
 872            << (BITS_PER_UNIT * i);
 873   return gen_int_mode (val, SImode);
 874 }
 875
 876 /* Clear shadow memory at SHADOW_MEM, LEN bytes.  Can't call a library call here
 877    though.  */
 878
 879 static void
 880 asan_clear_shadow (rtx shadow_mem, HOST_WIDE_INT len)
 881 {
 882   rtx insn, insns, top_label, end, addr, tmp, jump;
 883
 884   start_sequence ();
 885   clear_storage (shadow_mem, GEN_INT (len), BLOCK_OP_NORMAL);
 886   insns = get_insns ();
 887   end_sequence ();
 888   for (insn = insns; insn; insn = NEXT_INSN (insn))
 889     if (CALL_P (insn))
 890       break;
 891   if (insn == NULL_RTX)
 892     {
 893       emit_insn (insns);
 894       return;
 895     }
 896
 897   gcc_assert ((len & 3) == 0);
 898   top_label = gen_label_rtx ();
 899   addr = force_reg (Pmode, XEXP (shadow_mem, 0));
 900   shadow_mem = adjust_automodify_address (shadow_mem, SImode, addr, 0);
 901   end = force_reg (Pmode, plus_constant (Pmode, addr, len));
 902   emit_label (top_label);
 903
 904   emit_move_insn (shadow_mem, const0_rtx);
 905   tmp = expand_simple_binop (Pmode, PLUS, addr, gen_int_mode (4, Pmode), addr,
 906                              true, OPTAB_LIB_WIDEN);
 907   if (tmp != addr)
 908     emit_move_insn (addr, tmp);
 909   emit_cmp_and_jump_insns (addr, end, LT, NULL_RTX, Pmode, true, top_label);
 910   jump = get_last_insn ();
 911   gcc_assert (JUMP_P (jump));
 912   add_int_reg_note (jump, REG_BR_PROB, REG_BR_PROB_BASE * 80 / 100);
 913 }
 914
 915 /* Insert code to protect stack vars.  The prologue sequence should be emitted
 916    directly, epilogue sequence returned.  BASE is the register holding the
 917    stack base, against which OFFSETS array offsets are relative to, OFFSETS
 918    array contains pairs of offsets in reverse order, always the end offset
 919    of some gap that needs protection followed by starting offset,
 920    and DECLS is an array of representative decls for each var partition.
 921    LENGTH is the length of the OFFSETS array, DECLS array is LENGTH / 2 - 1
 922    elements long (OFFSETS include gap before the first variable as well
 923    as gaps after each stack variable).  */
 924
 925 rtx
 926 asan_emit_stack_protection (rtx base, HOST_WIDE_INT *offsets, tree *decls,
 927                             int length)
 928 {
 929   rtx shadow_base, shadow_mem, ret, mem;
 930   unsigned char shadow_bytes[4];
 931   HOST_WIDE_INT base_offset = offsets[length - 1], offset, prev_offset;
 932   HOST_WIDE_INT last_offset, last_size;
 933   int l;
 934   unsigned char cur_shadow_byte = ASAN_STACK_MAGIC_LEFT;
 935   tree str_cst;
 936
 937   if (shadow_ptr_types[0] == NULL_TREE)
 938     asan_init_shadow_ptr_types ();
 939
 940   /* First of all, prepare the description string.  */
 941   pretty_printer asan_pp;
 942
 943   if (DECL_NAME (current_function_decl))
 944     pp_tree_identifier (&asan_pp, DECL_NAME (current_function_decl));
 945   else
 946     pp_string (&asan_pp, "<unknown>");
 947   pp_space (&asan_pp);
 948   pp_decimal_int (&asan_pp, length / 2 - 1);
 949   pp_space (&asan_pp);
 950   for (l = length - 2; l; l -= 2)
 951     {
 952       tree decl = decls[l / 2 - 1];
 953       pp_wide_integer (&asan_pp, offsets[l] - base_offset);
 954       pp_space (&asan_pp);
 955       pp_wide_integer (&asan_pp, offsets[l - 1] - offsets[l]);
 956       pp_space (&asan_pp);
 957       if (DECL_P (decl) && DECL_NAME (decl))
 958         {
 959           pp_decimal_int (&asan_pp, IDENTIFIER_LENGTH (DECL_NAME (decl)));
 960           pp_space (&asan_pp);
 961           pp_tree_identifier (&asan_pp, DECL_NAME (decl));
 962         }
 963       else
 964         pp_string (&asan_pp, "9 <unknown>");
 965       pp_space (&asan_pp);
 966     }
 967   str_cst = asan_pp_string (&asan_pp);
 968
 969   /* Emit the prologue sequence.  */
 970   base = expand_binop (Pmode, add_optab, base,
 971                        gen_int_mode (base_offset, Pmode),
 972                        NULL_RTX, 1, OPTAB_DIRECT);
 973   mem = gen_rtx_MEM (ptr_mode, base);
 974   emit_move_insn (mem, gen_int_mode (ASAN_STACK_FRAME_MAGIC, ptr_mode));
 975   mem = adjust_address (mem, VOIDmode, GET_MODE_SIZE (ptr_mode));
 976   emit_move_insn (mem, expand_normal (str_cst));
 977   shadow_base = expand_binop (Pmode, lshr_optab, base,
 978                               GEN_INT (ASAN_SHADOW_SHIFT),
 979                               NULL_RTX, 1, OPTAB_DIRECT);
 980   shadow_base = expand_binop (Pmode, add_optab, shadow_base,
 981                               gen_int_mode (targetm.asan_shadow_offset (),
 982                                             Pmode),
 983                               NULL_RTX, 1, OPTAB_DIRECT);
 984   gcc_assert (asan_shadow_set != -1
 985               && (ASAN_RED_ZONE_SIZE >> ASAN_SHADOW_SHIFT) == 4);
 986   shadow_mem = gen_rtx_MEM (SImode, shadow_base);
 987   set_mem_alias_set (shadow_mem, asan_shadow_set);
 988   prev_offset = base_offset;
 989   for (l = length; l; l -= 2)
 990     {
 991       if (l == 2)
 992         cur_shadow_byte = ASAN_STACK_MAGIC_RIGHT;
 993       offset = offsets[l - 1];
 994       if ((offset - base_offset) & (ASAN_RED_ZONE_SIZE - 1))
 995         {
 996           int i;
 997           HOST_WIDE_INT aoff
 998             = base_offset + ((offset - base_offset)
 999                              & ~(ASAN_RED_ZONE_SIZE - HOST_WIDE_INT_1));
1000           shadow_mem = adjust_address (shadow_mem, VOIDmode,
1001                                        (aoff - prev_offset)
1002                                        >> ASAN_SHADOW_SHIFT);
1003           prev_offset = aoff;
1004           for (i = 0; i < 4; i++, aoff += (1 << ASAN_SHADOW_SHIFT))
1005             if (aoff < offset)
1006               {
1007                 if (aoff < offset - (1 << ASAN_SHADOW_SHIFT) + 1)
1008                   shadow_bytes[i] = 0;
1009                 else
1010                   shadow_bytes[i] = offset - aoff;
1011               }
1012             else
1013               shadow_bytes[i] = ASAN_STACK_MAGIC_PARTIAL;
1014           emit_move_insn (shadow_mem, asan_shadow_cst (shadow_bytes));
1015           offset = aoff;
1016         }
1017       while (offset <= offsets[l - 2] - ASAN_RED_ZONE_SIZE)
1018         {
1019           shadow_mem = adjust_address (shadow_mem, VOIDmode,
1020                                        (offset - prev_offset)
1021                                        >> ASAN_SHADOW_SHIFT);
1022           prev_offset = offset;
1023           memset (shadow_bytes, cur_shadow_byte, 4);
1024           emit_move_insn (shadow_mem, asan_shadow_cst (shadow_bytes));
1025           offset += ASAN_RED_ZONE_SIZE;
1026         }
1027       cur_shadow_byte = ASAN_STACK_MAGIC_MIDDLE;
1028     }
1029   do_pending_stack_adjust ();
1030
1031   /* Construct epilogue sequence.  */
1032   start_sequence ();
1033
1034   shadow_mem = gen_rtx_MEM (BLKmode, shadow_base);
1035   set_mem_alias_set (shadow_mem, asan_shadow_set);
1036   prev_offset = base_offset;
1037   last_offset = base_offset;
1038   last_size = 0;
1039   for (l = length; l; l -= 2)
1040     {
1041       offset = base_offset + ((offsets[l - 1] - base_offset)
1042                              & ~(ASAN_RED_ZONE_SIZE - HOST_WIDE_INT_1));
1043       if (last_offset + last_size != offset)
1044         {
1045           shadow_mem = adjust_address (shadow_mem, VOIDmode,
1046                                        (last_offset - prev_offset)
1047                                        >> ASAN_SHADOW_SHIFT);
1048           prev_offset = last_offset;
1049           asan_clear_shadow (shadow_mem, last_size >> ASAN_SHADOW_SHIFT);
1050           last_offset = offset;
1051           last_size = 0;
1052         }
1053       last_size += base_offset + ((offsets[l - 2] - base_offset)
1054                                   & ~(ASAN_RED_ZONE_SIZE - HOST_WIDE_INT_1))
1055                    - offset;
1056     }
1057   if (last_size)
1058     {
1059       shadow_mem = adjust_address (shadow_mem, VOIDmode,
1060                                    (last_offset - prev_offset)
1061                                    >> ASAN_SHADOW_SHIFT);
1062       asan_clear_shadow (shadow_mem, last_size >> ASAN_SHADOW_SHIFT);
1063     }
1064
1065   do_pending_stack_adjust ();
1066
1067   ret = get_insns ();
1068   end_sequence ();
1069   return ret;
1070 }
1071
1072 /* Return true if DECL, a global var, might be overridden and needs
1073    therefore a local alias.  */
1074
1075 static bool
1076 asan_needs_local_alias (tree decl)
1077 {
1078   return DECL_WEAK (decl) || !targetm.binds_local_p (decl);
1079 }
1080
1081 /* Return true if DECL is a VAR_DECL that should be protected
1082    by Address Sanitizer, by appending a red zone with protected
1083    shadow memory after it and aligning it to at least
1084    ASAN_RED_ZONE_SIZE bytes.  */
1085
1086 bool
1087 asan_protect_global (tree decl)
1088 {
1089   rtx rtl, symbol;
1090
1091   if (TREE_CODE (decl) == STRING_CST)
1092     {
1093       /* Instrument all STRING_CSTs except those created
1094          by asan_pp_string here.  */
1095       if (shadow_ptr_types[0] != NULL_TREE
1096           && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
1097           && TREE_TYPE (TREE_TYPE (decl)) == TREE_TYPE (shadow_ptr_types[0]))
1098         return false;
1099       return true;
1100     }
1101   if (TREE_CODE (decl) != VAR_DECL
1102       /* TLS vars aren't statically protectable.  */
1103       || DECL_THREAD_LOCAL_P (decl)
1104       /* Externs will be protected elsewhere.  */
1105       || DECL_EXTERNAL (decl)
1106       || !DECL_RTL_SET_P (decl)
1107       /* Comdat vars pose an ABI problem, we can't know if
1108          the var that is selected by the linker will have
1109          padding or not.  */
1110       || DECL_ONE_ONLY (decl)
1111       /* Similarly for common vars.  People can use -fno-common.  */
1112       || (DECL_COMMON (decl) && TREE_PUBLIC (decl))
1113       /* Don't protect if using user section, often vars placed
1114          into user section from multiple TUs are then assumed
1115          to be an array of such vars, putting padding in there
1116          breaks this assumption.  */
1117       || (DECL_SECTION_NAME (decl) != NULL_TREE
1118           && !DECL_HAS_IMPLICIT_SECTION_NAME_P (decl))
1119       || DECL_SIZE (decl) == 0
1120       || ASAN_RED_ZONE_SIZE * BITS_PER_UNIT > MAX_OFILE_ALIGNMENT
1121       || !valid_constant_size_p (DECL_SIZE_UNIT (decl))
1122       || DECL_ALIGN_UNIT (decl) > 2 * ASAN_RED_ZONE_SIZE)
1123     return false;
1124
1125   rtl = DECL_RTL (decl);
1126   if (!MEM_P (rtl) || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF)
1127     return false;
1128   symbol = XEXP (rtl, 0);
1129
1130   if (CONSTANT_POOL_ADDRESS_P (symbol)
1131       || TREE_CONSTANT_POOL_ADDRESS_P (symbol))
1132     return false;
1133
1134   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
1135     return false;
1136
1137 #ifndef ASM_OUTPUT_DEF
1138   if (asan_needs_local_alias (decl))
1139     return false;
1140 #endif
1141
1142   return true;
1143 }
1144
1145 /* Construct a function tree for __asan_report_{load,store}{1,2,4,8,16}.
1146    IS_STORE is either 1 (for a store) or 0 (for a load).
1147    SIZE_IN_BYTES is one of 1, 2, 4, 8, 16.  */
1148
1149 static tree
1150 report_error_func (bool is_store, int size_in_bytes)
1151 {
1152   static enum built_in_function report[2][5]
1153     = { { BUILT_IN_ASAN_REPORT_LOAD1, BUILT_IN_ASAN_REPORT_LOAD2,
1154           BUILT_IN_ASAN_REPORT_LOAD4, BUILT_IN_ASAN_REPORT_LOAD8,
1155           BUILT_IN_ASAN_REPORT_LOAD16 },
1156         { BUILT_IN_ASAN_REPORT_STORE1, BUILT_IN_ASAN_REPORT_STORE2,
1157           BUILT_IN_ASAN_REPORT_STORE4, BUILT_IN_ASAN_REPORT_STORE8,
1158           BUILT_IN_ASAN_REPORT_STORE16 } };
1159   return builtin_decl_implicit (report[is_store][exact_log2 (size_in_bytes)]);
1160 }
1161
1162 #define PROB_VERY_UNLIKELY      (REG_BR_PROB_BASE / 2000 - 1)
1163 #define PROB_ALWAYS             (REG_BR_PROB_BASE)
1164
1165 /* Split the current basic block and create a condition statement
1166    insertion point right before or after the statement pointed to by
1167    ITER.  Return an iterator to the point at which the caller might
1168    safely insert the condition statement.
1169
1170    THEN_BLOCK must be set to the address of an uninitialized instance
1171    of basic_block.  The function will then set *THEN_BLOCK to the
1172    'then block' of the condition statement to be inserted by the
1173    caller.
1174
1175    If CREATE_THEN_FALLTHRU_EDGE is false, no edge will be created from
1176    *THEN_BLOCK to *FALLTHROUGH_BLOCK.
1177
1178    Similarly, the function will set *FALLTRHOUGH_BLOCK to the 'else
1179    block' of the condition statement to be inserted by the caller.
1180
1181    Note that *FALLTHROUGH_BLOCK is a new block that contains the
1182    statements starting from *ITER, and *THEN_BLOCK is a new empty
1183    block.
1184
1185    *ITER is adjusted to point to always point to the first statement
1186     of the basic block * FALLTHROUGH_BLOCK.  That statement is the
1187     same as what ITER was pointing to prior to calling this function,
1188     if BEFORE_P is true; otherwise, it is its following statement.  */
1189
1190 static gimple_stmt_iterator
1191 create_cond_insert_point (gimple_stmt_iterator *iter,
1192                           bool before_p,
1193                           bool then_more_likely_p,
1194                           bool create_then_fallthru_edge,
1195                           basic_block *then_block,
1196                           basic_block *fallthrough_block)
1197 {
1198   gimple_stmt_iterator gsi = *iter;
1199
1200   if (!gsi_end_p (gsi) && before_p)
1201     gsi_prev (&gsi);
1202
1203   basic_block cur_bb = gsi_bb (*iter);
1204
1205   edge e = split_block (cur_bb, gsi_stmt (gsi));
1206
1207   /* Get a hold on the 'condition block', the 'then block' and the
1208      'else block'.  */
1209   basic_block cond_bb = e->src;
1210   basic_block fallthru_bb = e->dest;
1211   basic_block then_bb = create_empty_bb (cond_bb);
1212   if (current_loops)
1213     {
1214       add_bb_to_loop (then_bb, cond_bb->loop_father);
1215       loops_state_set (LOOPS_NEED_FIXUP);
1216     }
1217
1218   /* Set up the newly created 'then block'.  */
1219   e = make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
1220   int fallthrough_probability
1221     = then_more_likely_p
1222     ? PROB_VERY_UNLIKELY
1223     : PROB_ALWAYS - PROB_VERY_UNLIKELY;
1224   e->probability = PROB_ALWAYS - fallthrough_probability;
1225   if (create_then_fallthru_edge)
1226     make_single_succ_edge (then_bb, fallthru_bb, EDGE_FALLTHRU);
1227
1228   /* Set up the fallthrough basic block.  */
1229   e = find_edge (cond_bb, fallthru_bb);
1230   e->flags = EDGE_FALSE_VALUE;
1231   e->count = cond_bb->count;
1232   e->probability = fallthrough_probability;
1233
1234   /* Update dominance info for the newly created then_bb; note that
1235      fallthru_bb's dominance info has already been updated by
1236      split_bock.  */
1237   if (dom_info_available_p (CDI_DOMINATORS))
1238     set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
1239
1240   *then_block = then_bb;
1241   *fallthrough_block = fallthru_bb;
1242   *iter = gsi_start_bb (fallthru_bb);
1243
1244   return gsi_last_bb (cond_bb);
1245 }
1246
1247 /* Insert an if condition followed by a 'then block' right before the
1248    statement pointed to by ITER.  The fallthrough block -- which is the
1249    else block of the condition as well as the destination of the
1250    outcoming edge of the 'then block' -- starts with the statement
1251    pointed to by ITER.
1252
1253    COND is the condition of the if.
1254
1255    If THEN_MORE_LIKELY_P is true, the probability of the edge to the
1256    'then block' is higher than the probability of the edge to the
1257    fallthrough block.
1258
1259    Upon completion of the function, *THEN_BB is set to the newly
1260    inserted 'then block' and similarly, *FALLTHROUGH_BB is set to the
1261    fallthrough block.
1262
1263    *ITER is adjusted to still point to the same statement it was
1264    pointing to initially.  */
1265
1266 static void
1267 insert_if_then_before_iter (gimple cond,
1268                             gimple_stmt_iterator *iter,
1269                             bool then_more_likely_p,
1270                             basic_block *then_bb,
1271                             basic_block *fallthrough_bb)
1272 {
1273   gimple_stmt_iterator cond_insert_point =
1274     create_cond_insert_point (iter,
1275                               /*before_p=*/true,
1276                               then_more_likely_p,
1277                               /*create_then_fallthru_edge=*/true,
1278                               then_bb,
1279                               fallthrough_bb);
1280   gsi_insert_after (&cond_insert_point, cond, GSI_NEW_STMT);
1281 }
1282
1283 /* Instrument the memory access instruction BASE.  Insert new
1284    statements before or after ITER.
1285
1286    Note that the memory access represented by BASE can be either an
1287    SSA_NAME, or a non-SSA expression.  LOCATION is the source code
1288    location.  IS_STORE is TRUE for a store, FALSE for a load.
1289    BEFORE_P is TRUE for inserting the instrumentation code before
1290    ITER, FALSE for inserting it after ITER.  SIZE_IN_BYTES is one of
1291    1, 2, 4, 8, 16.
1292
1293    If BEFORE_P is TRUE, *ITER is arranged to still point to the
1294    statement it was pointing to prior to calling this function,
1295    otherwise, it points to the statement logically following it.  */
1296
1297 static void
1298 build_check_stmt (location_t location, tree base, gimple_stmt_iterator *iter,
1299                   bool before_p, bool is_store, int size_in_bytes)
1300 {
1301   gimple_stmt_iterator gsi;
1302   basic_block then_bb, else_bb;
1303   tree t, base_addr, shadow;
1304   gimple g;
1305   tree shadow_ptr_type = shadow_ptr_types[size_in_bytes == 16 ? 1 : 0];
1306   tree shadow_type = TREE_TYPE (shadow_ptr_type);
1307   tree uintptr_type
1308     = build_nonstandard_integer_type (TYPE_PRECISION (TREE_TYPE (base)), 1);
1309   tree base_ssa = base;
1310
1311   /* Get an iterator on the point where we can add the condition
1312      statement for the instrumentation.  */
1313   gsi = create_cond_insert_point (iter, before_p,
1314                                   /*then_more_likely_p=*/false,
1315                                   /*create_then_fallthru_edge=*/false,
1316                                   &then_bb,
1317                                   &else_bb);
1318
1319   base = unshare_expr (base);
1320
1321   /* BASE can already be an SSA_NAME; in that case, do not create a
1322      new SSA_NAME for it.  */
1323   if (TREE_CODE (base) != SSA_NAME)
1324     {
1325       g = gimple_build_assign_with_ops (TREE_CODE (base),
1326                                         make_ssa_name (TREE_TYPE (base), NULL),
1327                                         base, NULL_TREE);
1328       gimple_set_location (g, location);
1329       gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1330       base_ssa = gimple_assign_lhs (g);
1331     }
1332
1333   g = gimple_build_assign_with_ops (NOP_EXPR,
1334                                     make_ssa_name (uintptr_type, NULL),
1335                                     base_ssa, NULL_TREE);
1336   gimple_set_location (g, location);
1337   gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1338   base_addr = gimple_assign_lhs (g);
1339
1340   /* Build
1341      (base_addr >> ASAN_SHADOW_SHIFT) + targetm.asan_shadow_offset ().  */
1342
1343   t = build_int_cst (uintptr_type, ASAN_SHADOW_SHIFT);
1344   g = gimple_build_assign_with_ops (RSHIFT_EXPR,
1345                                     make_ssa_name (uintptr_type, NULL),
1346                                     base_addr, t);
1347   gimple_set_location (g, location);
1348   gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1349
1350   t = build_int_cst (uintptr_type, targetm.asan_shadow_offset ());
1351   g = gimple_build_assign_with_ops (PLUS_EXPR,
1352                                     make_ssa_name (uintptr_type, NULL),
1353                                     gimple_assign_lhs (g), t);
1354   gimple_set_location (g, location);
1355   gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1356
1357   g = gimple_build_assign_with_ops (NOP_EXPR,
1358                                     make_ssa_name (shadow_ptr_type, NULL),
1359                                     gimple_assign_lhs (g), NULL_TREE);
1360   gimple_set_location (g, location);
1361   gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1362
1363   t = build2 (MEM_REF, shadow_type, gimple_assign_lhs (g),
1364               build_int_cst (shadow_ptr_type, 0));
1365   g = gimple_build_assign_with_ops (MEM_REF,
1366                                     make_ssa_name (shadow_type, NULL),
1367                                     t, NULL_TREE);
1368   gimple_set_location (g, location);
1369   gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1370   shadow = gimple_assign_lhs (g);
1371
1372   if (size_in_bytes < 8)
1373     {
1374       /* Slow path for 1, 2 and 4 byte accesses.
1375          Test (shadow != 0)
1376               & ((base_addr & 7) + (size_in_bytes - 1)) >= shadow).  */
1377       gimple_seq seq = NULL;
1378       gimple shadow_test = build_assign (NE_EXPR, shadow, 0);
1379       gimple_seq_add_stmt (&seq, shadow_test);
1380       gimple_seq_add_stmt (&seq, build_assign (BIT_AND_EXPR, base_addr, 7));
1381       gimple_seq_add_stmt (&seq, build_type_cast (shadow_type,
1382                                                   gimple_seq_last (seq)));
1383       if (size_in_bytes > 1)
1384         gimple_seq_add_stmt (&seq,
1385                              build_assign (PLUS_EXPR, gimple_seq_last (seq),
1386                                            size_in_bytes - 1));
1387       gimple_seq_add_stmt (&seq, build_assign (GE_EXPR, gimple_seq_last (seq),
1388                                                shadow));
1389       gimple_seq_add_stmt (&seq, build_assign (BIT_AND_EXPR, shadow_test,
1390                                                gimple_seq_last (seq)));
1391       t = gimple_assign_lhs (gimple_seq_last (seq));
1392       gimple_seq_set_location (seq, location);
1393       gsi_insert_seq_after (&gsi, seq, GSI_CONTINUE_LINKING);
1394     }
1395   else
1396     t = shadow;
1397
1398   g = gimple_build_cond (NE_EXPR, t, build_int_cst (TREE_TYPE (t), 0),
1399                          NULL_TREE, NULL_TREE);
1400   gimple_set_location (g, location);
1401   gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1402
1403   /* Generate call to the run-time library (e.g. __asan_report_load8).  */
1404   gsi = gsi_start_bb (then_bb);
1405   g = gimple_build_call (report_error_func (is_store, size_in_bytes),
1406                          1, base_addr);
1407   gimple_set_location (g, location);
1408   gsi_insert_after (&gsi, g, GSI_NEW_STMT);
1409
1410   *iter = gsi_start_bb (else_bb);
1411 }
1412
1413 /* If T represents a memory access, add instrumentation code before ITER.
1414    LOCATION is source code location.
1415    IS_STORE is either TRUE (for a store) or FALSE (for a load).  */
1416
1417 static void
1418 instrument_derefs (gimple_stmt_iterator *iter, tree t,
1419                    location_t location, bool is_store)
1420 {
1421   tree type, base;
1422   HOST_WIDE_INT size_in_bytes;
1423
1424   type = TREE_TYPE (t);
1425   switch (TREE_CODE (t))
1426     {
1427     case ARRAY_REF:
1428     case COMPONENT_REF:
1429     case INDIRECT_REF:
1430     case MEM_REF:
1431       break;
1432     default:
1433       return;
1434     }
1435
1436   size_in_bytes = int_size_in_bytes (type);
1437   if ((size_in_bytes & (size_in_bytes - 1)) != 0
1438       || (unsigned HOST_WIDE_INT) size_in_bytes - 1 >= 16)
1439     return;
1440
1441   HOST_WIDE_INT bitsize, bitpos;
1442   tree offset;
1443   enum machine_mode mode;
1444   int volatilep = 0, unsignedp = 0;
1445   get_inner_reference (t, &bitsize, &bitpos, &offset,
1446                        &mode, &unsignedp, &volatilep, false);
1447   if (bitpos % (size_in_bytes * BITS_PER_UNIT)
1448       || bitsize != size_in_bytes * BITS_PER_UNIT)
1449     {
1450       if (TREE_CODE (t) == COMPONENT_REF
1451           && DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t, 1)) != NULL_TREE)
1452         {
1453           tree repr = DECL_BIT_FIELD_REPRESENTATIVE (TREE_OPERAND (t, 1));
1454           instrument_derefs (iter, build3 (COMPONENT_REF, TREE_TYPE (repr),
1455                                            TREE_OPERAND (t, 0), repr,
1456                                            NULL_TREE), location, is_store);
1457         }
1458       return;
1459     }
1460
1461   base = build_fold_addr_expr (t);
1462   if (!has_mem_ref_been_instrumented (base, size_in_bytes))
1463     {
1464       build_check_stmt (location, base, iter, /*before_p=*/true,
1465                         is_store, size_in_bytes);
1466       update_mem_ref_hash_table (base, size_in_bytes);
1467       update_mem_ref_hash_table (t, size_in_bytes);
1468     }
1469
1470 }
1471
1472 /* Instrument an access to a contiguous memory region that starts at
1473    the address pointed to by BASE, over a length of LEN (expressed in
1474    the sizeof (*BASE) bytes).  ITER points to the instruction before
1475    which the instrumentation instructions must be inserted.  LOCATION
1476    is the source location that the instrumentation instructions must
1477    have.  If IS_STORE is true, then the memory access is a store;
1478    otherwise, it's a load.  */
1479
1480 static void
1481 instrument_mem_region_access (tree base, tree len,
1482                               gimple_stmt_iterator *iter,
1483                               location_t location, bool is_store)
1484 {
1485   if (!POINTER_TYPE_P (TREE_TYPE (base))
1486       || !INTEGRAL_TYPE_P (TREE_TYPE (len))
1487       || integer_zerop (len))
1488     return;
1489
1490   gimple_stmt_iterator gsi = *iter;
1491
1492   basic_block fallthrough_bb = NULL, then_bb = NULL;
1493
1494   /* If the beginning of the memory region has already been
1495      instrumented, do not instrument it.  */
1496   bool start_instrumented = has_mem_ref_been_instrumented (base, 1);
1497
1498   /* If the end of the memory region has already been instrumented, do
1499      not instrument it. */
1500   tree end = asan_mem_ref_get_end (base, len);
1501   bool end_instrumented = has_mem_ref_been_instrumented (end, 1);
1502
1503   if (start_instrumented && end_instrumented)
1504     return;
1505
1506   if (!is_gimple_constant (len))
1507     {
1508       /* So, the length of the memory area to asan-protect is
1509          non-constant.  Let's guard the generated instrumentation code
1510          like:
1511
1512          if (len != 0)
1513            {
1514              //asan instrumentation code goes here.
1515            }
1516            // falltrough instructions, starting with *ITER.  */
1517
1518       gimple g = gimple_build_cond (NE_EXPR,
1519                                     len,
1520                                     build_int_cst (TREE_TYPE (len), 0),
1521                                     NULL_TREE, NULL_TREE);
1522       gimple_set_location (g, location);
1523       insert_if_then_before_iter (g, iter, /*then_more_likely_p=*/true,
1524                                   &then_bb, &fallthrough_bb);
1525       /* Note that fallthrough_bb starts with the statement that was
1526          pointed to by ITER.  */
1527
1528       /* The 'then block' of the 'if (len != 0) condition is where
1529          we'll generate the asan instrumentation code now.  */
1530       gsi = gsi_last_bb (then_bb);
1531     }
1532
1533   if (!start_instrumented)
1534     {
1535       /* Instrument the beginning of the memory region to be accessed,
1536          and arrange for the rest of the intrumentation code to be
1537          inserted in the then block *after* the current gsi.  */
1538       build_check_stmt (location, base, &gsi, /*before_p=*/true, is_store, 1);
1539
1540       if (then_bb)
1541         /* We are in the case where the length of the region is not
1542            constant; so instrumentation code is being generated in the
1543            'then block' of the 'if (len != 0) condition.  Let's arrange
1544            for the subsequent instrumentation statements to go in the
1545            'then block'.  */
1546         gsi = gsi_last_bb (then_bb);
1547       else
1548         {
1549           *iter = gsi;
1550           /* Don't remember this access as instrumented, if length
1551              is unknown.  It might be zero and not being actually
1552              instrumented, so we can't rely on it being instrumented.  */
1553           update_mem_ref_hash_table (base, 1);
1554         }
1555     }
1556
1557   if (end_instrumented)
1558     return;
1559
1560   /* We want to instrument the access at the end of the memory region,
1561      which is at (base + len - 1).  */
1562
1563   /* offset = len - 1;  */
1564   len = unshare_expr (len);
1565   tree offset;
1566   gimple_seq seq = NULL;
1567   if (TREE_CODE (len) == INTEGER_CST)
1568     offset = fold_build2 (MINUS_EXPR, size_type_node,
1569                           fold_convert (size_type_node, len),
1570                           build_int_cst (size_type_node, 1));
1571   else
1572     {
1573       gimple g;
1574       tree t;
1575
1576       if (TREE_CODE (len) != SSA_NAME)
1577         {
1578           t = make_ssa_name (TREE_TYPE (len), NULL);
1579           g = gimple_build_assign_with_ops (TREE_CODE (len), t, len, NULL);
1580           gimple_set_location (g, location);
1581           gimple_seq_add_stmt_without_update (&seq, g);
1582           len = t;
1583         }
1584       if (!useless_type_conversion_p (size_type_node, TREE_TYPE (len)))
1585         {
1586           t = make_ssa_name (size_type_node, NULL);
1587           g = gimple_build_assign_with_ops (NOP_EXPR, t, len, NULL);
1588           gimple_set_location (g, location);
1589           gimple_seq_add_stmt_without_update (&seq, g);
1590           len = t;
1591         }
1592
1593       t = make_ssa_name (size_type_node, NULL);
1594       g = gimple_build_assign_with_ops (MINUS_EXPR, t, len,
1595                                         build_int_cst (size_type_node, 1));
1596       gimple_set_location (g, location);
1597       gimple_seq_add_stmt_without_update (&seq, g);
1598       offset = gimple_assign_lhs (g);
1599     }
1600
1601   /* _1 = base;  */
1602   base = unshare_expr (base);
1603   gimple region_end =
1604     gimple_build_assign_with_ops (TREE_CODE (base),
1605                                   make_ssa_name (TREE_TYPE (base), NULL),
1606                                   base, NULL);
1607   gimple_set_location (region_end, location);
1608   gimple_seq_add_stmt_without_update (&seq, region_end);
1609
1610   /* _2 = _1 + offset;  */
1611   region_end =
1612     gimple_build_assign_with_ops (POINTER_PLUS_EXPR,
1613                                   make_ssa_name (TREE_TYPE (base), NULL),
1614                                   gimple_assign_lhs (region_end),
1615                                   offset);
1616   gimple_set_location (region_end, location);
1617   gimple_seq_add_stmt_without_update (&seq, region_end);
1618   gsi_insert_seq_before (&gsi, seq, GSI_SAME_STMT);
1619
1620   /* instrument access at _2;  */
1621   gsi = gsi_for_stmt (region_end);
1622   build_check_stmt (location, gimple_assign_lhs (region_end),
1623                     &gsi, /*before_p=*/false, is_store, 1);
1624
1625   if (then_bb == NULL)
1626     update_mem_ref_hash_table (end, 1);
1627
1628   *iter = gsi_for_stmt (gsi_stmt (*iter));
1629 }
1630
1631 /* Instrument the call (to the builtin strlen function) pointed to by
1632    ITER.
1633
1634    This function instruments the access to the first byte of the
1635    argument, right before the call.  After the call it instruments the
1636    access to the last byte of the argument; it uses the result of the
1637    call to deduce the offset of that last byte.
1638
1639    Upon completion, iff the call has actually been instrumented, this
1640    function returns TRUE and *ITER points to the statement logically
1641    following the built-in strlen function call *ITER was initially
1642    pointing to.  Otherwise, the function returns FALSE and *ITER
1643    remains unchanged.  */
1644
1645 static bool
1646 instrument_strlen_call (gimple_stmt_iterator *iter)
1647 {
1648   gimple call = gsi_stmt (*iter);
1649   gcc_assert (is_gimple_call (call));
1650
1651   tree callee = gimple_call_fndecl (call);
1652   gcc_assert (is_builtin_fn (callee)
1653               && DECL_BUILT_IN_CLASS (callee) == BUILT_IN_NORMAL
1654               && DECL_FUNCTION_CODE (callee) == BUILT_IN_STRLEN);
1655
1656   tree len = gimple_call_lhs (call);
1657   if (len == NULL)
1658     /* Some passes might clear the return value of the strlen call;
1659        bail out in that case.  Return FALSE as we are not advancing
1660        *ITER.  */
1661     return false;
1662   gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (len)));
1663
1664   location_t loc = gimple_location (call);
1665   tree str_arg = gimple_call_arg (call, 0);
1666
1667   /* Instrument the access to the first byte of str_arg.  i.e:
1668
1669      _1 = str_arg; instrument (_1); */
1670   tree cptr_type = build_pointer_type (char_type_node);
1671   gimple str_arg_ssa =
1672     gimple_build_assign_with_ops (NOP_EXPR,
1673                                   make_ssa_name (cptr_type, NULL),
1674                                   str_arg, NULL);
1675   gimple_set_location (str_arg_ssa, loc);
1676   gimple_stmt_iterator gsi = *iter;
1677   gsi_insert_before (&gsi, str_arg_ssa, GSI_NEW_STMT);
1678   build_check_stmt (loc, gimple_assign_lhs (str_arg_ssa), &gsi,
1679                     /*before_p=*/false, /*is_store=*/false, 1);
1680
1681   /* If we initially had an instruction like:
1682
1683          int n = strlen (str)
1684
1685      we now want to instrument the access to str[n], after the
1686      instruction above.*/
1687
1688   /* So let's build the access to str[n] that is, access through the
1689      pointer_plus expr: (_1 + len).  */
1690   gimple stmt =
1691     gimple_build_assign_with_ops (POINTER_PLUS_EXPR,
1692                                   make_ssa_name (cptr_type, NULL),
1693                                   gimple_assign_lhs (str_arg_ssa),
1694                                   len);
1695   gimple_set_location (stmt, loc);
1696   gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
1697
1698   build_check_stmt (loc, gimple_assign_lhs (stmt), &gsi,
1699                     /*before_p=*/false, /*is_store=*/false, 1);
1700
1701   /* Ensure that iter points to the statement logically following the
1702      one it was initially pointing to.  */
1703   *iter = gsi;
1704   /* As *ITER has been advanced to point to the next statement, let's
1705      return true to inform transform_statements that it shouldn't
1706      advance *ITER anymore; otherwises it will skip that next
1707      statement, which wouldn't be instrumented.  */
1708   return true;
1709 }
1710
1711 /* Instrument the call to a built-in memory access function that is
1712    pointed to by the iterator ITER.
1713
1714    Upon completion, return TRUE iff *ITER has been advanced to the
1715    statement following the one it was originally pointing to.  */
1716
1717 static bool
1718 instrument_builtin_call (gimple_stmt_iterator *iter)
1719 {
1720   bool iter_advanced_p = false;
1721   gimple call = gsi_stmt (*iter);
1722
1723   gcc_checking_assert (gimple_call_builtin_p (call, BUILT_IN_NORMAL));
1724
1725   tree callee = gimple_call_fndecl (call);
1726   location_t loc = gimple_location (call);
1727
1728   if (DECL_FUNCTION_CODE (callee) == BUILT_IN_STRLEN)
1729     iter_advanced_p = instrument_strlen_call (iter);
1730   else
1731     {
1732       asan_mem_ref src0, src1, dest;
1733       asan_mem_ref_init (&src0, NULL, 1);
1734       asan_mem_ref_init (&src1, NULL, 1);
1735       asan_mem_ref_init (&dest, NULL, 1);
1736
1737       tree src0_len = NULL_TREE, src1_len = NULL_TREE, dest_len = NULL_TREE;
1738       bool src0_is_store = false, src1_is_store = false,
1739         dest_is_store = false, dest_is_deref = false;
1740
1741       if (get_mem_refs_of_builtin_call (call,
1742                                         &src0, &src0_len, &src0_is_store,
1743                                         &src1, &src1_len, &src1_is_store,
1744                                         &dest, &dest_len, &dest_is_store,
1745                                         &dest_is_deref))
1746         {
1747           if (dest_is_deref)
1748             {
1749               instrument_derefs (iter, dest.start, loc, dest_is_store);
1750               gsi_next (iter);
1751               iter_advanced_p = true;
1752             }
1753           else if (src0_len || src1_len || dest_len)
1754             {
1755               if (src0.start != NULL_TREE)
1756                 instrument_mem_region_access (src0.start, src0_len,
1757                                               iter, loc, /*is_store=*/false);
1758               if (src1.start != NULL_TREE)
1759                 instrument_mem_region_access (src1.start, src1_len,
1760                                               iter, loc, /*is_store=*/false);
1761               if (dest.start != NULL_TREE)
1762                 instrument_mem_region_access (dest.start, dest_len,
1763                                               iter, loc, /*is_store=*/true);
1764               *iter = gsi_for_stmt (call);
1765               gsi_next (iter);
1766               iter_advanced_p = true;
1767             }
1768         }
1769     }
1770   return iter_advanced_p;
1771 }
1772
1773 /*  Instrument the assignment statement ITER if it is subject to
1774     instrumentation.  Return TRUE iff instrumentation actually
1775     happened.  In that case, the iterator ITER is advanced to the next
1776     logical expression following the one initially pointed to by ITER,
1777     and the relevant memory reference that which access has been
1778     instrumented is added to the memory references hash table.  */
1779
1780 static bool
1781 maybe_instrument_assignment (gimple_stmt_iterator *iter)
1782 {
1783   gimple s = gsi_stmt (*iter);
1784
1785   gcc_assert (gimple_assign_single_p (s));
1786
1787   tree ref_expr = NULL_TREE;
1788   bool is_store, is_instrumented = false;
1789
1790   if (gimple_store_p (s))
1791     {
1792       ref_expr = gimple_assign_lhs (s);
1793       is_store = true;
1794       instrument_derefs (iter, ref_expr,
1795                          gimple_location (s),
1796                          is_store);
1797       is_instrumented = true;
1798     }
1799
1800   if (gimple_assign_load_p (s))
1801     {
1802       ref_expr = gimple_assign_rhs1 (s);
1803       is_store = false;
1804       instrument_derefs (iter, ref_expr,
1805                          gimple_location (s),
1806                          is_store);
1807       is_instrumented = true;
1808     }
1809
1810   if (is_instrumented)
1811     gsi_next (iter);
1812
1813   return is_instrumented;
1814 }
1815
1816 /* Instrument the function call pointed to by the iterator ITER, if it
1817    is subject to instrumentation.  At the moment, the only function
1818    calls that are instrumented are some built-in functions that access
1819    memory.  Look at instrument_builtin_call to learn more.
1820
1821    Upon completion return TRUE iff *ITER was advanced to the statement
1822    following the one it was originally pointing to.  */
1823
1824 static bool
1825 maybe_instrument_call (gimple_stmt_iterator *iter)
1826 {
1827   gimple stmt = gsi_stmt (*iter);
1828   bool is_builtin = gimple_call_builtin_p (stmt, BUILT_IN_NORMAL);
1829
1830   if (is_builtin && instrument_builtin_call (iter))
1831     return true;
1832
1833   if (gimple_call_noreturn_p (stmt))
1834     {
1835       if (is_builtin)
1836         {
1837           tree callee = gimple_call_fndecl (stmt);
1838           switch (DECL_FUNCTION_CODE (callee))
1839             {
1840             case BUILT_IN_UNREACHABLE:
1841             case BUILT_IN_TRAP:
1842               /* Don't instrument these.  */
1843               return false;
1844             }
1845         }
1846       tree decl = builtin_decl_implicit (BUILT_IN_ASAN_HANDLE_NO_RETURN);
1847       gimple g = gimple_build_call (decl, 0);
1848       gimple_set_location (g, gimple_location (stmt));
1849       gsi_insert_before (iter, g, GSI_SAME_STMT);
1850     }
1851   return false;
1852 }
1853
1854 /* Walk each instruction of all basic block and instrument those that
1855    represent memory references: loads, stores, or function calls.
1856    In a given basic block, this function avoids instrumenting memory
1857    references that have already been instrumented.  */
1858
1859 static void
1860 transform_statements (void)
1861 {
1862   basic_block bb, last_bb = NULL;
1863   gimple_stmt_iterator i;
1864   int saved_last_basic_block = last_basic_block;
1865
1866   FOR_EACH_BB (bb)
1867     {
1868       basic_block prev_bb = bb;
1869
1870       if (bb->index >= saved_last_basic_block) continue;
1871
1872       /* Flush the mem ref hash table, if current bb doesn't have
1873          exactly one predecessor, or if that predecessor (skipping
1874          over asan created basic blocks) isn't the last processed
1875          basic block.  Thus we effectively flush on extended basic
1876          block boundaries.  */
1877       while (single_pred_p (prev_bb))
1878         {
1879           prev_bb = single_pred (prev_bb);
1880           if (prev_bb->index < saved_last_basic_block)
1881             break;
1882         }
1883       if (prev_bb != last_bb)
1884         empty_mem_ref_hash_table ();
1885       last_bb = bb;
1886
1887       for (i = gsi_start_bb (bb); !gsi_end_p (i);)
1888         {
1889           gimple s = gsi_stmt (i);
1890
1891           if (has_stmt_been_instrumented_p (s))
1892             gsi_next (&i);
1893           else if (gimple_assign_single_p (s)
1894                    && maybe_instrument_assignment (&i))
1895             /*  Nothing to do as maybe_instrument_assignment advanced
1896                 the iterator I.  */;
1897           else if (is_gimple_call (s) && maybe_instrument_call (&i))
1898             /*  Nothing to do as maybe_instrument_call
1899                 advanced the iterator I.  */;
1900           else
1901             {
1902               /* No instrumentation happened.
1903
1904                  If the current instruction is a function call that
1905                  might free something, let's forget about the memory
1906                  references that got instrumented.  Otherwise we might
1907                  miss some instrumentation opportunities.  */
1908               if (is_gimple_call (s) && !nonfreeing_call_p (s))
1909                 empty_mem_ref_hash_table ();
1910
1911               gsi_next (&i);
1912             }
1913         }
1914     }
1915   free_mem_ref_resources ();
1916 }
1917
1918 /* Build
1919    struct __asan_global
1920    {
1921      const void *__beg;
1922      uptr __size;
1923      uptr __size_with_redzone;
1924      const void *__name;
1925      uptr __has_dynamic_init;
1926    } type.  */
1927
1928 static tree
1929 asan_global_struct (void)
1930 {
1931   static const char *field_names[5]
1932     = { "__beg", "__size", "__size_with_redzone",
1933         "__name", "__has_dynamic_init" };
1934   tree fields[5], ret;
1935   int i;
1936
1937   ret = make_node (RECORD_TYPE);
1938   for (i = 0; i < 5; i++)
1939     {
1940       fields[i]
1941         = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
1942                       get_identifier (field_names[i]),
1943                       (i == 0 || i == 3) ? const_ptr_type_node
1944                       : pointer_sized_int_node);
1945       DECL_CONTEXT (fields[i]) = ret;
1946       if (i)
1947         DECL_CHAIN (fields[i - 1]) = fields[i];
1948     }
1949   TYPE_FIELDS (ret) = fields[0];
1950   TYPE_NAME (ret) = get_identifier ("__asan_global");
1951   layout_type (ret);
1952   return ret;
1953 }
1954
1955 /* Append description of a single global DECL into vector V.
1956    TYPE is __asan_global struct type as returned by asan_global_struct.  */
1957
1958 static void
1959 asan_add_global (tree decl, tree type, vec<constructor_elt, va_gc> *v)
1960 {
1961   tree init, uptr = TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (type)));
1962   unsigned HOST_WIDE_INT size;
1963   tree str_cst, refdecl = decl;
1964   vec<constructor_elt, va_gc> *vinner = NULL;
1965
1966   pretty_printer asan_pp;
1967
1968   if (DECL_NAME (decl))
1969     pp_tree_identifier (&asan_pp, DECL_NAME (decl));
1970   else
1971     pp_string (&asan_pp, "<unknown>");
1972   pp_space (&asan_pp);
1973   pp_left_paren (&asan_pp);
1974   pp_string (&asan_pp, main_input_filename);
1975   pp_right_paren (&asan_pp);
1976   str_cst = asan_pp_string (&asan_pp);
1977
1978   if (asan_needs_local_alias (decl))
1979     {
1980       char buf[20];
1981       ASM_GENERATE_INTERNAL_LABEL (buf, "LASAN", vec_safe_length (v) + 1);
1982       refdecl = build_decl (DECL_SOURCE_LOCATION (decl),
1983                             VAR_DECL, get_identifier (buf), TREE_TYPE (decl));
1984       TREE_ADDRESSABLE (refdecl) = TREE_ADDRESSABLE (decl);
1985       TREE_READONLY (refdecl) = TREE_READONLY (decl);
1986       TREE_THIS_VOLATILE (refdecl) = TREE_THIS_VOLATILE (decl);
1987       DECL_GIMPLE_REG_P (refdecl) = DECL_GIMPLE_REG_P (decl);
1988       DECL_ARTIFICIAL (refdecl) = DECL_ARTIFICIAL (decl);
1989       DECL_IGNORED_P (refdecl) = DECL_IGNORED_P (decl);
1990       TREE_STATIC (refdecl) = 1;
1991       TREE_PUBLIC (refdecl) = 0;
1992       TREE_USED (refdecl) = 1;
1993       assemble_alias (refdecl, DECL_ASSEMBLER_NAME (decl));
1994     }
1995
1996   CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE,
1997                           fold_convert (const_ptr_type_node,
1998                                         build_fold_addr_expr (refdecl)));
1999   size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
2000   CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE, build_int_cst (uptr, size));
2001   size += asan_red_zone_size (size);
2002   CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE, build_int_cst (uptr, size));
2003   CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE,
2004                           fold_convert (const_ptr_type_node, str_cst));
2005   CONSTRUCTOR_APPEND_ELT (vinner, NULL_TREE, build_int_cst (uptr, 0));
2006   init = build_constructor (type, vinner);
2007   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init);
2008 }
2009
2010 /* Initialize sanitizer.def builtins if the FE hasn't initialized them.  */
2011 void
2012 initialize_sanitizer_builtins (void)
2013 {
2014   tree decl;
2015
2016   if (builtin_decl_implicit_p (BUILT_IN_ASAN_INIT))
2017     return;
2018
2019   tree BT_FN_VOID = build_function_type_list (void_type_node, NULL_TREE);
2020   tree BT_FN_VOID_PTR
2021     = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
2022   tree BT_FN_VOID_PTR_PTR_PTR
2023     = build_function_type_list (void_type_node, ptr_type_node,
2024                                 ptr_type_node, ptr_type_node, NULL_TREE);
2025   tree BT_FN_VOID_PTR_PTRMODE
2026     = build_function_type_list (void_type_node, ptr_type_node,
2027                                 pointer_sized_int_node, NULL_TREE);
2028   tree BT_FN_VOID_INT
2029     = build_function_type_list (void_type_node, integer_type_node, NULL_TREE);
2030   tree BT_FN_BOOL_VPTR_PTR_IX_INT_INT[5];
2031   tree BT_FN_IX_CONST_VPTR_INT[5];
2032   tree BT_FN_IX_VPTR_IX_INT[5];
2033   tree BT_FN_VOID_VPTR_IX_INT[5];
2034   tree vptr
2035     = build_pointer_type (build_qualified_type (void_type_node,
2036                                                 TYPE_QUAL_VOLATILE));
2037   tree cvptr
2038     = build_pointer_type (build_qualified_type (void_type_node,
2039                                                 TYPE_QUAL_VOLATILE
2040                                                 |TYPE_QUAL_CONST));
2041   tree boolt
2042     = lang_hooks.types.type_for_size (BOOL_TYPE_SIZE, 1);
2043   int i;
2044   for (i = 0; i < 5; i++)
2045     {
2046       tree ix = build_nonstandard_integer_type (BITS_PER_UNIT * (1 << i), 1);
2047       BT_FN_BOOL_VPTR_PTR_IX_INT_INT[i]
2048         = build_function_type_list (boolt, vptr, ptr_type_node, ix,
2049                                     integer_type_node, integer_type_node,
2050                                     NULL_TREE);
2051       BT_FN_IX_CONST_VPTR_INT[i]
2052         = build_function_type_list (ix, cvptr, integer_type_node, NULL_TREE);
2053       BT_FN_IX_VPTR_IX_INT[i]
2054         = build_function_type_list (ix, vptr, ix, integer_type_node,
2055                                     NULL_TREE);
2056       BT_FN_VOID_VPTR_IX_INT[i]
2057         = build_function_type_list (void_type_node, vptr, ix,
2058                                     integer_type_node, NULL_TREE);
2059     }
2060 #define BT_FN_BOOL_VPTR_PTR_I1_INT_INT BT_FN_BOOL_VPTR_PTR_IX_INT_INT[0]
2061 #define BT_FN_I1_CONST_VPTR_INT BT_FN_IX_CONST_VPTR_INT[0]
2062 #define BT_FN_I1_VPTR_I1_INT BT_FN_IX_VPTR_IX_INT[0]
2063 #define BT_FN_VOID_VPTR_I1_INT BT_FN_VOID_VPTR_IX_INT[0]
2064 #define BT_FN_BOOL_VPTR_PTR_I2_INT_INT BT_FN_BOOL_VPTR_PTR_IX_INT_INT[1]
2065 #define BT_FN_I2_CONST_VPTR_INT BT_FN_IX_CONST_VPTR_INT[1]
2066 #define BT_FN_I2_VPTR_I2_INT BT_FN_IX_VPTR_IX_INT[1]
2067 #define BT_FN_VOID_VPTR_I2_INT BT_FN_VOID_VPTR_IX_INT[1]
2068 #define BT_FN_BOOL_VPTR_PTR_I4_INT_INT BT_FN_BOOL_VPTR_PTR_IX_INT_INT[2]
2069 #define BT_FN_I4_CONST_VPTR_INT BT_FN_IX_CONST_VPTR_INT[2]
2070 #define BT_FN_I4_VPTR_I4_INT BT_FN_IX_VPTR_IX_INT[2]
2071 #define BT_FN_VOID_VPTR_I4_INT BT_FN_VOID_VPTR_IX_INT[2]
2072 #define BT_FN_BOOL_VPTR_PTR_I8_INT_INT BT_FN_BOOL_VPTR_PTR_IX_INT_INT[3]
2073 #define BT_FN_I8_CONST_VPTR_INT BT_FN_IX_CONST_VPTR_INT[3]
2074 #define BT_FN_I8_VPTR_I8_INT BT_FN_IX_VPTR_IX_INT[3]
2075 #define BT_FN_VOID_VPTR_I8_INT BT_FN_VOID_VPTR_IX_INT[3]
2076 #define BT_FN_BOOL_VPTR_PTR_I16_INT_INT BT_FN_BOOL_VPTR_PTR_IX_INT_INT[4]
2077 #define BT_FN_I16_CONST_VPTR_INT BT_FN_IX_CONST_VPTR_INT[4]
2078 #define BT_FN_I16_VPTR_I16_INT BT_FN_IX_VPTR_IX_INT[4]
2079 #define BT_FN_VOID_VPTR_I16_INT BT_FN_VOID_VPTR_IX_INT[4]
2080 #undef ATTR_NOTHROW_LEAF_LIST
2081 #define ATTR_NOTHROW_LEAF_LIST ECF_NOTHROW | ECF_LEAF
2082 #undef ATTR_TMPURE_NOTHROW_LEAF_LIST
2083 #define ATTR_TMPURE_NOTHROW_LEAF_LIST ECF_TM_PURE | ATTR_NOTHROW_LEAF_LIST
2084 #undef ATTR_NORETURN_NOTHROW_LEAF_LIST
2085 #define ATTR_NORETURN_NOTHROW_LEAF_LIST ECF_NORETURN | ATTR_NOTHROW_LEAF_LIST
2086 #undef ATTR_TMPURE_NORETURN_NOTHROW_LEAF_LIST
2087 #define ATTR_TMPURE_NORETURN_NOTHROW_LEAF_LIST \
2088   ECF_TM_PURE | ATTR_NORETURN_NOTHROW_LEAF_LIST
2089 #undef ATTR_COLD_NOTHROW_LEAF_LIST
2090 #define ATTR_COLD_NOTHROW_LEAF_LIST \
2091   /* ECF_COLD missing */ ATTR_NOTHROW_LEAF_LIST
2092 #undef ATTR_COLD_NORETURN_NOTHROW_LEAF_LIST
2093 #define ATTR_COLD_NORETURN_NOTHROW_LEAF_LIST \
2094   /* ECF_COLD missing */ ATTR_NORETURN_NOTHROW_LEAF_LIST
2095 #undef DEF_SANITIZER_BUILTIN
2096 #define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
2097   decl = add_builtin_function ("__builtin_" NAME, TYPE, ENUM,           \
2098                                BUILT_IN_NORMAL, NAME, NULL_TREE);       \
2099   set_call_expr_flags (decl, ATTRS);                                    \
2100   set_builtin_decl (ENUM, decl, true);
2101
2102 #include "sanitizer.def"
2103
2104 #undef DEF_SANITIZER_BUILTIN
2105 }
2106
2107 /* Called via htab_traverse.  Count number of emitted
2108    STRING_CSTs in the constant hash table.  */
2109
2110 static int
2111 count_string_csts (void **slot, void *data)
2112 {
2113   struct constant_descriptor_tree *desc
2114     = (struct constant_descriptor_tree *) *slot;
2115   if (TREE_CODE (desc->value) == STRING_CST
2116       && TREE_ASM_WRITTEN (desc->value)
2117       && asan_protect_global (desc->value))
2118     ++*((unsigned HOST_WIDE_INT *) data);
2119   return 1;
2120 }
2121
2122 /* Helper structure to pass two parameters to
2123    add_string_csts.  */
2124
2125 struct asan_add_string_csts_data
2126 {
2127   tree type;
2128   vec<constructor_elt, va_gc> *v;
2129 };
2130
2131 /* Called via htab_traverse.  Call asan_add_global
2132    on emitted STRING_CSTs from the constant hash table.  */
2133
2134 static int
2135 add_string_csts (void **slot, void *data)
2136 {
2137   struct constant_descriptor_tree *desc
2138     = (struct constant_descriptor_tree *) *slot;
2139   if (TREE_CODE (desc->value) == STRING_CST
2140       && TREE_ASM_WRITTEN (desc->value)
2141       && asan_protect_global (desc->value))
2142     {
2143       struct asan_add_string_csts_data *aascd
2144         = (struct asan_add_string_csts_data *) data;
2145       asan_add_global (SYMBOL_REF_DECL (XEXP (desc->rtl, 0)),
2146                        aascd->type, aascd->v);
2147     }
2148   return 1;
2149 }
2150
2151 /* Needs to be GTY(()), because cgraph_build_static_cdtor may
2152    invoke ggc_collect.  */
2153 static GTY(()) tree asan_ctor_statements;
2154
2155 /* Module-level instrumentation.
2156    - Insert __asan_init() into the list of CTORs.
2157    - TODO: insert redzones around globals.
2158  */
2159
2160 void
2161 asan_finish_file (void)
2162 {
2163   struct varpool_node *vnode;
2164   unsigned HOST_WIDE_INT gcount = 0;
2165
2166   if (shadow_ptr_types[0] == NULL_TREE)
2167     asan_init_shadow_ptr_types ();
2168   /* Avoid instrumenting code in the asan ctors/dtors.
2169      We don't need to insert padding after the description strings,
2170      nor after .LASAN* array.  */
2171   flag_sanitize &= ~SANITIZE_ADDRESS;
2172
2173   tree fn = builtin_decl_implicit (BUILT_IN_ASAN_INIT);
2174   append_to_statement_list (build_call_expr (fn, 0), &asan_ctor_statements);
2175   FOR_EACH_DEFINED_VARIABLE (vnode)
2176     if (TREE_ASM_WRITTEN (vnode->symbol.decl)
2177         && asan_protect_global (vnode->symbol.decl))
2178       ++gcount;
2179   htab_t const_desc_htab = constant_pool_htab ();
2180   htab_traverse (const_desc_htab, count_string_csts, &gcount);
2181   if (gcount)
2182     {
2183       tree type = asan_global_struct (), var, ctor;
2184       tree dtor_statements = NULL_TREE;
2185       vec<constructor_elt, va_gc> *v;
2186       char buf[20];
2187
2188       type = build_array_type_nelts (type, gcount);
2189       ASM_GENERATE_INTERNAL_LABEL (buf, "LASAN", 0);
2190       var = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (buf),
2191                         type);
2192       TREE_STATIC (var) = 1;
2193       TREE_PUBLIC (var) = 0;
2194       DECL_ARTIFICIAL (var) = 1;
2195       DECL_IGNORED_P (var) = 1;
2196       vec_alloc (v, gcount);
2197       FOR_EACH_DEFINED_VARIABLE (vnode)
2198         if (TREE_ASM_WRITTEN (vnode->symbol.decl)
2199             && asan_protect_global (vnode->symbol.decl))
2200           asan_add_global (vnode->symbol.decl, TREE_TYPE (type), v);
2201       struct asan_add_string_csts_data aascd;
2202       aascd.type = TREE_TYPE (type);
2203       aascd.v = v;
2204       htab_traverse (const_desc_htab, add_string_csts, &aascd);
2205       ctor = build_constructor (type, v);
2206       TREE_CONSTANT (ctor) = 1;
2207       TREE_STATIC (ctor) = 1;
2208       DECL_INITIAL (var) = ctor;
2209       varpool_assemble_decl (varpool_node_for_decl (var));
2210
2211       fn = builtin_decl_implicit (BUILT_IN_ASAN_REGISTER_GLOBALS);
2212       tree gcount_tree = build_int_cst (pointer_sized_int_node, gcount);
2213       append_to_statement_list (build_call_expr (fn, 2,
2214                                                  build_fold_addr_expr (var),
2215                                                  gcount_tree),
2216                                 &asan_ctor_statements);
2217
2218       fn = builtin_decl_implicit (BUILT_IN_ASAN_UNREGISTER_GLOBALS);
2219       append_to_statement_list (build_call_expr (fn, 2,
2220                                                  build_fold_addr_expr (var),
2221                                                  gcount_tree),
2222                                 &dtor_statements);
2223       cgraph_build_static_cdtor ('D', dtor_statements,
2224                                  MAX_RESERVED_INIT_PRIORITY - 1);
2225     }
2226   cgraph_build_static_cdtor ('I', asan_ctor_statements,
2227                              MAX_RESERVED_INIT_PRIORITY - 1);
2228   flag_sanitize |= SANITIZE_ADDRESS;
2229 }
2230
2231 /* Instrument the current function.  */
2232
2233 static unsigned int
2234 asan_instrument (void)
2235 {
2236   if (shadow_ptr_types[0] == NULL_TREE)
2237     asan_init_shadow_ptr_types ();
2238   transform_statements ();
2239   return 0;
2240 }
2241
2242 static bool
2243 gate_asan (void)
2244 {
2245   return (flag_sanitize & SANITIZE_ADDRESS) != 0
2246           && !lookup_attribute ("no_sanitize_address",
2247                                 DECL_ATTRIBUTES (current_function_decl));
2248 }
2249
2250 namespace {
2251
2252 const pass_data pass_data_asan =
2253 {
2254   GIMPLE_PASS, /* type */
2255   "asan", /* name */
2256   OPTGROUP_NONE, /* optinfo_flags */
2257   true, /* has_gate */
2258   true, /* has_execute */
2259   TV_NONE, /* tv_id */
2260   ( PROP_ssa | PROP_cfg | PROP_gimple_leh ), /* properties_required */
2261   0, /* properties_provided */
2262   0, /* properties_destroyed */
2263   0, /* todo_flags_start */
2264   ( TODO_verify_flow | TODO_verify_stmts
2265     | TODO_update_ssa ), /* todo_flags_finish */
2266 };
2267
2268 class pass_asan : public gimple_opt_pass
2269 {
2270 public:
2271   pass_asan(gcc::context *ctxt)
2272     : gimple_opt_pass(pass_data_asan, ctxt)
2273   {}
2274
2275   /* opt_pass methods: */
2276   opt_pass * clone () { return new pass_asan (ctxt_); }
2277   bool gate () { return gate_asan (); }
2278   unsigned int execute () { return asan_instrument (); }
2279
2280 }; // class pass_asan
2281
2282 } // anon namespace
2283
2284 gimple_opt_pass *
2285 make_pass_asan (gcc::context *ctxt)
2286 {
2287   return new pass_asan (ctxt);
2288 }
2289
2290 static bool
2291 gate_asan_O0 (void)
2292 {
2293   return !optimize && gate_asan ();
2294 }
2295
2296 namespace {
2297
2298 const pass_data pass_data_asan_O0 =
2299 {
2300   GIMPLE_PASS, /* type */
2301   "asan0", /* name */
2302   OPTGROUP_NONE, /* optinfo_flags */
2303   true, /* has_gate */
2304   true, /* has_execute */
2305   TV_NONE, /* tv_id */
2306   ( PROP_ssa | PROP_cfg | PROP_gimple_leh ), /* properties_required */
2307   0, /* properties_provided */
2308   0, /* properties_destroyed */
2309   0, /* todo_flags_start */
2310   ( TODO_verify_flow | TODO_verify_stmts
2311     | TODO_update_ssa ), /* todo_flags_finish */
2312 };
2313
2314 class pass_asan_O0 : public gimple_opt_pass
2315 {
2316 public:
2317   pass_asan_O0(gcc::context *ctxt)
2318     : gimple_opt_pass(pass_data_asan_O0, ctxt)
2319   {}
2320
2321   /* opt_pass methods: */
2322   bool gate () { return gate_asan_O0 (); }
2323   unsigned int execute () { return asan_instrument (); }
2324
2325 }; // class pass_asan_O0
2326
2327 } // anon namespace
2328
2329 gimple_opt_pass *
2330 make_pass_asan_O0 (gcc::context *ctxt)
2331 {
2332   return new pass_asan_O0 (ctxt);
2333 }
2334
2335 #include "gt-asan.h"