CbC/CbC_gcc: gcc/asan.c comparison

comparison gcc/asan.c @ 132:d34655255c78

update gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 10:21:07 +0900
parents	84e7813d76e9
children	1830386684a0

comparison

equal deleted inserted replaced

-:e108057fa461
+:d34655255c78
 /* AddressSanitizer, a fast memory error detector.
-Copyright (C) 2012-2017 Free Software Foundation, Inc.
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
 Contributed by Kostya Serebryany <kcc@google.com>
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 static tree last_alloca_addr;
 /* Set of variable declarations that are going to be guarded by
 use-after-scope sanitizer.  */
-static hash_set<tree> *asan_handled_variables = NULL;
+hash_set<tree> *asan_handled_variables = NULL;
 hash_set <tree> *asan_used_labels = NULL;
 /* Sets shadow offset to value in string VAL.  */
 edge e = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
 gsi_insert_on_edge_immediate (e, g);
 return last_alloca_addr;
 }
-/* Insert __asan_allocas_unpoison (top, bottom) call after
+/* Insert __asan_allocas_unpoison (top, bottom) call before
 __builtin_stack_restore (new_sp) call.
 The pseudocode of this routine should look like this:
-__builtin_stack_restore (new_sp);
 top = last_alloca_addr;
 bot = new_sp;
 __asan_allocas_unpoison (top, bot);
 last_alloca_addr = new_sp;
+__builtin_stack_restore (new_sp);
 In general, we can't use new_sp as bot parameter because on some
 architectures SP has non zero offset from dynamic stack area.  Moreover, on
 some architectures this offset (STACK_DYNAMIC_OFFSET) becomes known for each
 particular function only after all callees were expanded to rtl.
 The most noticeable example is PowerPC{,64}, see
 http://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi.html#DYNAM-STACK.
 To overcome the issue we use following trick: pass new_sp as a second
 parameter to __asan_allocas_unpoison and rewrite it during expansion with
-virtual_dynamic_stack_rtx later in expand_asan_emit_allocas_unpoison
+new_sp + (virtual_dynamic_stack_rtx - sp) later in
-function.
+expand_asan_emit_allocas_unpoison function.  */
-*/
 static void
 handle_builtin_stack_restore (gcall *call, gimple_stmt_iterator *iter)
 {
 if (!iter || !asan_sanitize_allocas_p ())
 tree last_alloca = get_last_alloca_addr ();
 tree restored_stack = gimple_call_arg (call, 0);
 tree fn = builtin_decl_implicit (BUILT_IN_ASAN_ALLOCAS_UNPOISON);
 gimple *g = gimple_build_call (fn, 2, last_alloca, restored_stack);
-gsi_insert_after (iter, g, GSI_NEW_STMT);
+gsi_insert_before (iter, g, GSI_SAME_STMT);
 g = gimple_build_assign (last_alloca, restored_stack);
-gsi_insert_after (iter, g, GSI_NEW_STMT);
+gsi_insert_before (iter, g, GSI_SAME_STMT);
 }
 /* Deploy and poison redzones around __builtin_alloca call.  To do this, we
 should replace this call with another one with changed parameters and
 replace all its uses with new address, so
 of SIZE bytes.  */
 static unsigned HOST_WIDE_INT
 shadow_mem_size (unsigned HOST_WIDE_INT size)
 {
+/* It must be possible to align stack variables to granularity
+of shadow memory.  */
+gcc_assert (BITS_PER_UNIT
+	      * ASAN_SHADOW_GRANULARITY <= MAX_SUPPORTED_STACK_ALIGNMENT);
 return ROUND_UP (size, ASAN_SHADOW_GRANULARITY) / ASAN_SHADOW_GRANULARITY;
 }
 /* Insert code to protect stack vars.  The prologue sequence should be emitted
 directly, epilogue sequence returned.  BASE is the register holding the
 int use_after_return_class = -1;
 if (shadow_ptr_types[0] == NULL_TREE)
 asan_init_shadow_ptr_types ();
+expanded_location cfun_xloc
+= expand_location (DECL_SOURCE_LOCATION (current_function_decl));
 /* First of all, prepare the description string.  */
 pretty_printer asan_pp;
 pp_decimal_int (&asan_pp, length / 2 - 1);
 pp_space (&asan_pp);
 tree decl = decls[l / 2 - 1];
 pp_wide_integer (&asan_pp, offsets[l] - base_offset);
 pp_space (&asan_pp);
 pp_wide_integer (&asan_pp, offsets[l - 1] - offsets[l]);
 pp_space (&asan_pp);
+expanded_location xloc
+	= expand_location (DECL_SOURCE_LOCATION (decl));
+char location[32];
+if (xloc.file == cfun_xloc.file)
+	sprintf (location, ":%d", xloc.line);
+else
+	location[0] = '\0';
 if (DECL_P (decl) && DECL_NAME (decl))
 	{
-	  pp_decimal_int (&asan_pp, IDENTIFIER_LENGTH (DECL_NAME (decl)));
+	  unsigned idlen
+	    = IDENTIFIER_LENGTH (DECL_NAME (decl)) + strlen (location);
+	  pp_decimal_int (&asan_pp, idlen);
 	  pp_space (&asan_pp);
 	  pp_tree_identifier (&asan_pp, DECL_NAME (decl));
+	  pp_string (&asan_pp, location);
 	}
 else
 	pp_string (&asan_pp, "9 <unknown>");
-pp_space (&asan_pp);
+if (l > 2)
+	pp_space (&asan_pp);
 }
 str_cst = asan_pp_string (&asan_pp);
 /* Emit the prologue sequence.  */
 if (asan_frame_size > 32 && asan_frame_size <= 65536 && pbase
 DECL_INITIAL (decl) = decl;
 TREE_ASM_WRITTEN (decl) = 1;
 TREE_ASM_WRITTEN (id) = 1;
 emit_move_insn (mem, expand_normal (build_fold_addr_expr (decl)));
 shadow_base = expand_binop (Pmode, lshr_optab, base,
-			      GEN_INT (ASAN_SHADOW_SHIFT),
+			      gen_int_shift_amount (Pmode, ASAN_SHADOW_SHIFT),
 			      NULL_RTX, 1, OPTAB_DIRECT);
 shadow_base
 = plus_constant (Pmode, shadow_base,
 		     asan_shadow_offset ()
 		     + (base_align_bias >> ASAN_SHADOW_SHIFT));
 by Address Sanitizer, by appending a red zone with protected
 shadow memory after it and aligning it to at least
 ASAN_RED_ZONE_SIZE bytes.  */
 bool
-asan_protect_global (tree decl)
+asan_protect_global (tree decl, bool ignore_decl_rtl_set_p)
 {
 if (!ASAN_GLOBALS)
 return false;
 rtx rtl, symbol;
 if (!VAR_P (decl)
 /* TLS vars aren't statically protectable.  */
 || DECL_THREAD_LOCAL_P (decl)
 /* Externs will be protected elsewhere.  */
 || DECL_EXTERNAL (decl)
-|| !DECL_RTL_SET_P (decl)
+/* PR sanitizer/81697: For architectures that use section anchors first
+	 call to asan_protect_global may occur before DECL_RTL (decl) is set.
+	 We should ignore DECL_RTL_SET_P then, because otherwise the first call
+	 to asan_protect_global will return FALSE and the following calls on the
+	 same decl after setting DECL_RTL (decl) will return TRUE and we'll end
+	 up with inconsistency at runtime.  */
+|| (!DECL_RTL_SET_P (decl) && !ignore_decl_rtl_set_p)
 /* Comdat vars pose an ABI problem, we can't know if
 	 the var that is selected by the linker will have
 	 padding or not.  */
 || DECL_ONE_ONLY (decl)
 /* Similarly for common vars.  People can use -fno-common.
 || (DECL_SECTION_NAME (decl) != NULL
 	  && !symtab_node::get (decl)->implicit_section
 	  && !section_sanitized_p (DECL_SECTION_NAME (decl)))
 || DECL_SIZE (decl) == 0
 || ASAN_RED_ZONE_SIZE * BITS_PER_UNIT > MAX_OFILE_ALIGNMENT
+|| TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
 || !valid_constant_size_p (DECL_SIZE_UNIT (decl))
 || DECL_ALIGN_UNIT (decl) > 2 * ASAN_RED_ZONE_SIZE
 || TREE_TYPE (decl) == ubsan_get_source_location_type ()
 || is_odr_indicator (decl))
 return false;
-rtl = DECL_RTL (decl);
+if (!ignore_decl_rtl_set_p || DECL_RTL_SET_P (decl))
-if (!MEM_P (rtl) || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF)
+{
-return false;
-symbol = XEXP (rtl, 0);
+rtl = DECL_RTL (decl);
+if (!MEM_P (rtl) || GET_CODE (XEXP (rtl, 0)) != SYMBOL_REF)
-if (CONSTANT_POOL_ADDRESS_P (symbol)
+	return false;
-|| TREE_CONSTANT_POOL_ADDRESS_P (symbol))
+symbol = XEXP (rtl, 0);
-return false;
+if (CONSTANT_POOL_ADDRESS_P (symbol)
+	  || TREE_CONSTANT_POOL_ADDRESS_P (symbol))
+	return false;
+}
 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
 return false;
 if (!TARGET_SUPPORTS_ALIASES && asan_needs_local_alias (decl))
 profile_probability fallthrough_probability
 = then_more_likely_p
 ? profile_probability::very_unlikely ()
 : profile_probability::very_likely ();
 e->probability = fallthrough_probability.invert ();
+then_bb->count = e->count ();
 if (create_then_fallthru_edge)
 make_single_succ_edge (then_bb, fallthru_bb, EDGE_FALLTHRU);
 /* Set up the fallthrough basic block.  */
 e = find_edge (cond_bb, fallthru_bb);
 size_in_bytes = int_size_in_bytes (type);
 if (size_in_bytes <= 0)
 return;
-HOST_WIDE_INT bitsize, bitpos;
+poly_int64 bitsize, bitpos;
 tree offset;
 machine_mode mode;
 int unsignedp, reversep, volatilep = 0;
 tree inner = get_inner_reference (t, &bitsize, &bitpos, &offset, &mode,
 				    &unsignedp, &reversep, &volatilep);
 				       TREE_OPERAND (t, 2)),
 			 location, is_store);
 return;
 }
-if (bitpos % BITS_PER_UNIT
+if (!multiple_p (bitpos, BITS_PER_UNIT)
-|| bitsize != size_in_bytes * BITS_PER_UNIT)
+|| maybe_ne (bitsize, size_in_bytes * BITS_PER_UNIT))
 return;
 if (VAR_P (inner) && DECL_HARD_REGISTER (inner))
 return;
+poly_int64 decl_size;
 if (VAR_P (inner)
 && offset == NULL_TREE
-&& bitpos >= 0
 && DECL_SIZE (inner)
-&& tree_fits_shwi_p (DECL_SIZE (inner))
+&& poly_int_tree_p (DECL_SIZE (inner), &decl_size)
-&& bitpos + bitsize <= tree_to_shwi (DECL_SIZE (inner)))
+&& known_subrange_p (bitpos, bitsize, 0, decl_size))
 {
 if (DECL_THREAD_LOCAL_P (inner))
 	return;
 if (!ASAN_GLOBALS && is_global_var (inner))
 return;
 /* ECF_COLD missing */ ATTR_CONST_NORETURN_NOTHROW_LEAF_LIST
 #undef ATTR_PURE_NOTHROW_LEAF_LIST
 #define ATTR_PURE_NOTHROW_LEAF_LIST ECF_PURE | ATTR_NOTHROW_LEAF_LIST
 #undef DEF_BUILTIN_STUB
 #define DEF_BUILTIN_STUB(ENUM, NAME)
-#undef DEF_SANITIZER_BUILTIN
+#undef DEF_SANITIZER_BUILTIN_1
-#define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS) \
+#define DEF_SANITIZER_BUILTIN_1(ENUM, NAME, TYPE, ATTRS)		\
 do {									\
 decl = add_builtin_function ("__builtin_" NAME, TYPE, ENUM,		\
 				 BUILT_IN_NORMAL, NAME, NULL_TREE);	\
 set_call_expr_flags (decl, ATTRS);					\
 set_builtin_decl (ENUM, decl, true);				\
-} while (0);
+} while (0)
+#undef DEF_SANITIZER_BUILTIN
+#define DEF_SANITIZER_BUILTIN(ENUM, NAME, TYPE, ATTRS)	\
+DEF_SANITIZER_BUILTIN_1 (ENUM, NAME, TYPE, ATTRS);
 #include "sanitizer.def"
 /* -fsanitize=object-size uses __builtin_object_size, but that might
 not be available for e.g. Fortran at this point.  We use
 DEF_SANITIZER_BUILTIN here only as a convenience macro.  */
 if ((flag_sanitize & SANITIZE_OBJECT_SIZE)
 && !builtin_decl_implicit_p (BUILT_IN_OBJECT_SIZE))
-DEF_SANITIZER_BUILTIN (BUILT_IN_OBJECT_SIZE, "object_size",
+DEF_SANITIZER_BUILTIN_1 (BUILT_IN_OBJECT_SIZE, "object_size",
-			   BT_FN_SIZE_CONST_PTR_INT,
+			     BT_FN_SIZE_CONST_PTR_INT,
-			   ATTR_PURE_NOTHROW_LEAF_LIST)
+			     ATTR_PURE_NOTHROW_LEAF_LIST);
+#undef DEF_SANITIZER_BUILTIN_1
 #undef DEF_SANITIZER_BUILTIN
 #undef DEF_BUILTIN_STUB
 }
 /* Called via htab_traverse.  Count number of emitted
 	(&aascd);
 ctor = build_constructor (type, v);
 TREE_CONSTANT (ctor) = 1;
 TREE_STATIC (ctor) = 1;
 DECL_INITIAL (var) = ctor;
+SET_DECL_ALIGN (var, MAX (DECL_ALIGN (var),
+				ASAN_SHADOW_GRANULARITY * BITS_PER_UNIT));
 varpool_node::finalize_decl (var);
 tree fn = builtin_decl_implicit (BUILT_IN_ASAN_REGISTER_GLOBALS);
 tree gcount_tree = build_int_cst (pointer_sized_int_node, gcount);
 append_to_statement_list (build_call_expr (fn, 2,

Mercurial > hg > CbC > CbC_gcc

comparison gcc/asan.c @ 132:d34655255c78