1 //===-- asan_rtl.cc -------------------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file is a part of AddressSanitizer, an address sanity checker.
11 //
12 // Main file of the ASan run-time library.
13 //===----------------------------------------------------------------------===//
14 #include "asan_allocator.h"
15 #include "asan_interceptors.h"
16 #include "asan_internal.h"
17 #include "asan_mapping.h"
18 #include "asan_poisoning.h"
19 #include "asan_report.h"
20 #include "asan_stack.h"
21 #include "asan_stats.h"
22 #include "asan_thread.h"
23 #include "sanitizer_common/sanitizer_atomic.h"
24 #include "sanitizer_common/sanitizer_flags.h"
25 #include "sanitizer_common/sanitizer_libc.h"
26 #include "sanitizer_common/sanitizer_symbolizer.h"
27 #include "lsan/lsan_common.h"
28
29 namespace __asan {
30
31 uptr AsanMappingProfile[kAsanMappingProfileSize];
32
AsanDie()33 static void AsanDie() {
34 static atomic_uint32_t num_calls;
35 if (atomic_fetch_add(&num_calls, 1, memory_order_relaxed) != 0) {
36 // Don't die twice - run a busy loop.
37 while (1) { }
38 }
39 if (flags()->sleep_before_dying) {
40 Report("Sleeping for %d second(s)\n", flags()->sleep_before_dying);
41 SleepForSeconds(flags()->sleep_before_dying);
42 }
43 if (flags()->unmap_shadow_on_exit) {
44 if (kMidMemBeg) {
45 UnmapOrDie((void*)kLowShadowBeg, kMidMemBeg - kLowShadowBeg);
46 UnmapOrDie((void*)kMidMemEnd, kHighShadowEnd - kMidMemEnd);
47 } else {
48 UnmapOrDie((void*)kLowShadowBeg, kHighShadowEnd - kLowShadowBeg);
49 }
50 }
51 if (death_callback)
52 death_callback();
53 if (flags()->abort_on_error)
54 Abort();
55 internal__exit(flags()->exitcode);
56 }
57
AsanCheckFailed(const char * file,int line,const char * cond,u64 v1,u64 v2)58 static void AsanCheckFailed(const char *file, int line, const char *cond,
59 u64 v1, u64 v2) {
60 Report("AddressSanitizer CHECK failed: %s:%d \"%s\" (0x%zx, 0x%zx)\n",
61 file, line, cond, (uptr)v1, (uptr)v2);
62 // FIXME: check for infinite recursion without a thread-local counter here.
63 PRINT_CURRENT_STACK();
64 Die();
65 }
66
67 // -------------------------- Flags ------------------------- {{{1
68 static const int kDefaultMallocContextSize = 30;
69
70 Flags asan_flags_dont_use_directly; // use via flags().
71
MaybeCallAsanDefaultOptions()72 static const char *MaybeCallAsanDefaultOptions() {
73 return (&__asan_default_options) ? __asan_default_options() : "";
74 }
75
MaybeUseAsanDefaultOptionsCompileDefiniton()76 static const char *MaybeUseAsanDefaultOptionsCompileDefiniton() {
77 #ifdef ASAN_DEFAULT_OPTIONS
78 // Stringize the macro value.
79 # define ASAN_STRINGIZE(x) #x
80 # define ASAN_STRINGIZE_OPTIONS(options) ASAN_STRINGIZE(options)
81 return ASAN_STRINGIZE_OPTIONS(ASAN_DEFAULT_OPTIONS);
82 #else
83 return "";
84 #endif
85 }
86
ParseFlagsFromString(Flags * f,const char * str)87 static void ParseFlagsFromString(Flags *f, const char *str) {
88 ParseCommonFlagsFromString(str);
89 CHECK((uptr)common_flags()->malloc_context_size <= kStackTraceMax);
90
91 ParseFlag(str, &f->quarantine_size, "quarantine_size");
92 ParseFlag(str, &f->verbosity, "verbosity");
93 ParseFlag(str, &f->redzone, "redzone");
94 CHECK_GE(f->redzone, 16);
95 CHECK(IsPowerOfTwo(f->redzone));
96
97 ParseFlag(str, &f->debug, "debug");
98 ParseFlag(str, &f->report_globals, "report_globals");
99 ParseFlag(str, &f->check_initialization_order, "check_initialization_order");
100
101 ParseFlag(str, &f->replace_str, "replace_str");
102 ParseFlag(str, &f->replace_intrin, "replace_intrin");
103 ParseFlag(str, &f->mac_ignore_invalid_free, "mac_ignore_invalid_free");
104 ParseFlag(str, &f->use_fake_stack, "use_fake_stack");
105 ParseFlag(str, &f->max_malloc_fill_size, "max_malloc_fill_size");
106 ParseFlag(str, &f->malloc_fill_byte, "malloc_fill_byte");
107 ParseFlag(str, &f->exitcode, "exitcode");
108 ParseFlag(str, &f->allow_user_poisoning, "allow_user_poisoning");
109 ParseFlag(str, &f->sleep_before_dying, "sleep_before_dying");
110 ParseFlag(str, &f->handle_segv, "handle_segv");
111 ParseFlag(str, &f->allow_user_segv_handler, "allow_user_segv_handler");
112 ParseFlag(str, &f->use_sigaltstack, "use_sigaltstack");
113 ParseFlag(str, &f->check_malloc_usable_size, "check_malloc_usable_size");
114 ParseFlag(str, &f->unmap_shadow_on_exit, "unmap_shadow_on_exit");
115 ParseFlag(str, &f->abort_on_error, "abort_on_error");
116 ParseFlag(str, &f->print_stats, "print_stats");
117 ParseFlag(str, &f->print_legend, "print_legend");
118 ParseFlag(str, &f->atexit, "atexit");
119 ParseFlag(str, &f->disable_core, "disable_core");
120 ParseFlag(str, &f->allow_reexec, "allow_reexec");
121 ParseFlag(str, &f->print_full_thread_history, "print_full_thread_history");
122 ParseFlag(str, &f->poison_heap, "poison_heap");
123 ParseFlag(str, &f->alloc_dealloc_mismatch, "alloc_dealloc_mismatch");
124 ParseFlag(str, &f->use_stack_depot, "use_stack_depot");
125 ParseFlag(str, &f->strict_memcmp, "strict_memcmp");
126 ParseFlag(str, &f->strict_init_order, "strict_init_order");
127 }
128
InitializeFlags(Flags * f,const char * env)129 void InitializeFlags(Flags *f, const char *env) {
130 CommonFlags *cf = common_flags();
131 cf->external_symbolizer_path = GetEnv("ASAN_SYMBOLIZER_PATH");
132 cf->symbolize = true;
133 cf->malloc_context_size = kDefaultMallocContextSize;
134 cf->fast_unwind_on_fatal = false;
135 cf->fast_unwind_on_malloc = true;
136 cf->strip_path_prefix = "";
137 cf->handle_ioctl = false;
138 cf->log_path = 0;
139 cf->detect_leaks = false;
140 cf->leak_check_at_exit = true;
141
142 internal_memset(f, 0, sizeof(*f));
143 f->quarantine_size = (ASAN_LOW_MEMORY) ? 1UL << 26 : 1UL << 28;
144 f->verbosity = 0;
145 f->redzone = 16;
146 f->debug = false;
147 f->report_globals = 1;
148 f->check_initialization_order = false;
149 f->replace_str = true;
150 f->replace_intrin = true;
151 f->mac_ignore_invalid_free = false;
152 f->use_fake_stack = true;
153 f->max_malloc_fill_size = 0x1000; // By default, fill only the first 4K.
154 f->malloc_fill_byte = 0xbe;
155 f->exitcode = ASAN_DEFAULT_FAILURE_EXITCODE;
156 f->allow_user_poisoning = true;
157 f->sleep_before_dying = 0;
158 f->handle_segv = ASAN_NEEDS_SEGV;
159 f->allow_user_segv_handler = false;
160 f->use_sigaltstack = false;
161 f->check_malloc_usable_size = true;
162 f->unmap_shadow_on_exit = false;
163 f->abort_on_error = false;
164 f->print_stats = false;
165 f->print_legend = true;
166 f->atexit = false;
167 f->disable_core = (SANITIZER_WORDSIZE == 64);
168 f->allow_reexec = true;
169 f->print_full_thread_history = true;
170 f->poison_heap = true;
171 // Turn off alloc/dealloc mismatch checker on Mac for now.
172 // TODO(glider): Fix known issues and enable this back.
173 f->alloc_dealloc_mismatch = (SANITIZER_MAC == 0);;
174 f->use_stack_depot = true;
175 f->strict_memcmp = true;
176 f->strict_init_order = false;
177
178 // Override from compile definition.
179 ParseFlagsFromString(f, MaybeUseAsanDefaultOptionsCompileDefiniton());
180
181 // Override from user-specified string.
182 ParseFlagsFromString(f, MaybeCallAsanDefaultOptions());
183 if (flags()->verbosity) {
184 Report("Using the defaults from __asan_default_options: %s\n",
185 MaybeCallAsanDefaultOptions());
186 }
187
188 // Override from command line.
189 ParseFlagsFromString(f, env);
190
191 #if !CAN_SANITIZE_LEAKS
192 if (cf->detect_leaks) {
193 Report("%s: detect_leaks is not supported on this platform.\n",
194 SanitizerToolName);
195 cf->detect_leaks = false;
196 }
197 #endif
198
199 if (cf->detect_leaks && !f->use_stack_depot) {
200 Report("%s: detect_leaks is ignored (requires use_stack_depot).\n",
201 SanitizerToolName);
202 cf->detect_leaks = false;
203 }
204 }
205
206 // -------------------------- Globals --------------------- {{{1
207 int asan_inited;
208 bool asan_init_is_running;
209 void (*death_callback)(void);
210
211 #if !ASAN_FIXED_MAPPING
212 uptr kHighMemEnd, kMidMemBeg, kMidMemEnd;
213 #endif
214
215 // -------------------------- Misc ---------------- {{{1
ShowStatsAndAbort()216 void ShowStatsAndAbort() {
217 __asan_print_accumulated_stats();
218 Die();
219 }
220
221 // ---------------------- mmap -------------------- {{{1
222 // Reserve memory range [beg, end].
ReserveShadowMemoryRange(uptr beg,uptr end)223 static void ReserveShadowMemoryRange(uptr beg, uptr end) {
224 CHECK_EQ((beg % GetPageSizeCached()), 0);
225 CHECK_EQ(((end + 1) % GetPageSizeCached()), 0);
226 uptr size = end - beg + 1;
227 void *res = MmapFixedNoReserve(beg, size);
228 if (res != (void*)beg) {
229 Report("ReserveShadowMemoryRange failed while trying to map 0x%zx bytes. "
230 "Perhaps you're using ulimit -v\n", size);
231 Abort();
232 }
233 }
234
235 // --------------- LowLevelAllocateCallbac ---------- {{{1
OnLowLevelAllocate(uptr ptr,uptr size)236 static void OnLowLevelAllocate(uptr ptr, uptr size) {
237 PoisonShadow(ptr, size, kAsanInternalHeapMagic);
238 }
239
240 // -------------------------- Run-time entry ------------------- {{{1
241 // exported functions
242 #define ASAN_REPORT_ERROR(type, is_write, size) \
243 extern "C" NOINLINE INTERFACE_ATTRIBUTE \
244 void __asan_report_ ## type ## size(uptr addr); \
245 void __asan_report_ ## type ## size(uptr addr) { \
246 GET_CALLER_PC_BP_SP; \
247 __asan_report_error(pc, bp, sp, addr, is_write, size); \
248 }
249
250 ASAN_REPORT_ERROR(load, false, 1)
251 ASAN_REPORT_ERROR(load, false, 2)
252 ASAN_REPORT_ERROR(load, false, 4)
253 ASAN_REPORT_ERROR(load, false, 8)
254 ASAN_REPORT_ERROR(load, false, 16)
255 ASAN_REPORT_ERROR(store, true, 1)
256 ASAN_REPORT_ERROR(store, true, 2)
257 ASAN_REPORT_ERROR(store, true, 4)
258 ASAN_REPORT_ERROR(store, true, 8)
259 ASAN_REPORT_ERROR(store, true, 16)
260
261 #define ASAN_REPORT_ERROR_N(type, is_write) \
262 extern "C" NOINLINE INTERFACE_ATTRIBUTE \
263 void __asan_report_ ## type ## _n(uptr addr, uptr size); \
264 void __asan_report_ ## type ## _n(uptr addr, uptr size) { \
265 GET_CALLER_PC_BP_SP; \
266 __asan_report_error(pc, bp, sp, addr, is_write, size); \
267 }
268
ASAN_REPORT_ERROR_N(load,false)269 ASAN_REPORT_ERROR_N(load, false)
270 ASAN_REPORT_ERROR_N(store, true)
271
272 // Force the linker to keep the symbols for various ASan interface functions.
273 // We want to keep those in the executable in order to let the instrumented
274 // dynamic libraries access the symbol even if it is not used by the executable
275 // itself. This should help if the build system is removing dead code at link
276 // time.
277 static NOINLINE void force_interface_symbols() {
278 volatile int fake_condition = 0; // prevent dead condition elimination.
279 // __asan_report_* functions are noreturn, so we need a switch to prevent
280 // the compiler from removing any of them.
281 switch (fake_condition) {
282 case 1: __asan_report_load1(0); break;
283 case 2: __asan_report_load2(0); break;
284 case 3: __asan_report_load4(0); break;
285 case 4: __asan_report_load8(0); break;
286 case 5: __asan_report_load16(0); break;
287 case 6: __asan_report_store1(0); break;
288 case 7: __asan_report_store2(0); break;
289 case 8: __asan_report_store4(0); break;
290 case 9: __asan_report_store8(0); break;
291 case 10: __asan_report_store16(0); break;
292 case 12: __asan_register_globals(0, 0); break;
293 case 13: __asan_unregister_globals(0, 0); break;
294 case 14: __asan_set_death_callback(0); break;
295 case 15: __asan_set_error_report_callback(0); break;
296 case 16: __asan_handle_no_return(); break;
297 case 17: __asan_address_is_poisoned(0); break;
298 case 18: __asan_get_allocated_size(0); break;
299 case 19: __asan_get_current_allocated_bytes(); break;
300 case 20: __asan_get_estimated_allocated_size(0); break;
301 case 21: __asan_get_free_bytes(); break;
302 case 22: __asan_get_heap_size(); break;
303 case 23: __asan_get_ownership(0); break;
304 case 24: __asan_get_unmapped_bytes(); break;
305 case 25: __asan_poison_memory_region(0, 0); break;
306 case 26: __asan_unpoison_memory_region(0, 0); break;
307 case 27: __asan_set_error_exit_code(0); break;
308 case 28: __asan_stack_free(0, 0, 0); break;
309 case 29: __asan_stack_malloc(0, 0); break;
310 case 30: __asan_before_dynamic_init(0); break;
311 case 31: __asan_after_dynamic_init(); break;
312 case 32: __asan_poison_stack_memory(0, 0); break;
313 case 33: __asan_unpoison_stack_memory(0, 0); break;
314 case 34: __asan_region_is_poisoned(0, 0); break;
315 case 35: __asan_describe_address(0); break;
316 }
317 }
318
asan_atexit()319 static void asan_atexit() {
320 Printf("AddressSanitizer exit stats:\n");
321 __asan_print_accumulated_stats();
322 // Print AsanMappingProfile.
323 for (uptr i = 0; i < kAsanMappingProfileSize; i++) {
324 if (AsanMappingProfile[i] == 0) continue;
325 Printf("asan_mapping.h:%zd -- %zd\n", i, AsanMappingProfile[i]);
326 }
327 }
328
InitializeHighMemEnd()329 static void InitializeHighMemEnd() {
330 #if !ASAN_FIXED_MAPPING
331 kHighMemEnd = GetMaxVirtualAddress();
332 // Increase kHighMemEnd to make sure it's properly
333 // aligned together with kHighMemBeg:
334 kHighMemEnd |= SHADOW_GRANULARITY * GetPageSizeCached() - 1;
335 #endif // !ASAN_FIXED_MAPPING
336 CHECK_EQ((kHighMemBeg % GetPageSizeCached()), 0);
337 }
338
ProtectGap(uptr a,uptr size)339 static void ProtectGap(uptr a, uptr size) {
340 CHECK_EQ(a, (uptr)Mprotect(a, size));
341 }
342
PrintAddressSpaceLayout()343 static void PrintAddressSpaceLayout() {
344 Printf("|| `[%p, %p]` || HighMem ||\n",
345 (void*)kHighMemBeg, (void*)kHighMemEnd);
346 Printf("|| `[%p, %p]` || HighShadow ||\n",
347 (void*)kHighShadowBeg, (void*)kHighShadowEnd);
348 if (kMidMemBeg) {
349 Printf("|| `[%p, %p]` || ShadowGap3 ||\n",
350 (void*)kShadowGap3Beg, (void*)kShadowGap3End);
351 Printf("|| `[%p, %p]` || MidMem ||\n",
352 (void*)kMidMemBeg, (void*)kMidMemEnd);
353 Printf("|| `[%p, %p]` || ShadowGap2 ||\n",
354 (void*)kShadowGap2Beg, (void*)kShadowGap2End);
355 Printf("|| `[%p, %p]` || MidShadow ||\n",
356 (void*)kMidShadowBeg, (void*)kMidShadowEnd);
357 }
358 Printf("|| `[%p, %p]` || ShadowGap ||\n",
359 (void*)kShadowGapBeg, (void*)kShadowGapEnd);
360 if (kLowShadowBeg) {
361 Printf("|| `[%p, %p]` || LowShadow ||\n",
362 (void*)kLowShadowBeg, (void*)kLowShadowEnd);
363 Printf("|| `[%p, %p]` || LowMem ||\n",
364 (void*)kLowMemBeg, (void*)kLowMemEnd);
365 }
366 Printf("MemToShadow(shadow): %p %p %p %p",
367 (void*)MEM_TO_SHADOW(kLowShadowBeg),
368 (void*)MEM_TO_SHADOW(kLowShadowEnd),
369 (void*)MEM_TO_SHADOW(kHighShadowBeg),
370 (void*)MEM_TO_SHADOW(kHighShadowEnd));
371 if (kMidMemBeg) {
372 Printf(" %p %p",
373 (void*)MEM_TO_SHADOW(kMidShadowBeg),
374 (void*)MEM_TO_SHADOW(kMidShadowEnd));
375 }
376 Printf("\n");
377 Printf("red_zone=%zu\n", (uptr)flags()->redzone);
378 Printf("malloc_context_size=%zu\n",
379 (uptr)common_flags()->malloc_context_size);
380
381 Printf("SHADOW_SCALE: %zx\n", (uptr)SHADOW_SCALE);
382 Printf("SHADOW_GRANULARITY: %zx\n", (uptr)SHADOW_GRANULARITY);
383 Printf("SHADOW_OFFSET: %zx\n", (uptr)SHADOW_OFFSET);
384 CHECK(SHADOW_SCALE >= 3 && SHADOW_SCALE <= 7);
385 if (kMidMemBeg)
386 CHECK(kMidShadowBeg > kLowShadowEnd &&
387 kMidMemBeg > kMidShadowEnd &&
388 kHighShadowBeg > kMidMemEnd);
389 }
390
391 } // namespace __asan
392
393 // ---------------------- Interface ---------------- {{{1
394 using namespace __asan; // NOLINT
395
396 #if !SANITIZER_SUPPORTS_WEAK_HOOKS
397 extern "C" {
398 SANITIZER_WEAK_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
__asan_default_options()399 const char* __asan_default_options() { return ""; }
400 } // extern "C"
401 #endif
402
__asan_set_error_exit_code(int exit_code)403 int NOINLINE __asan_set_error_exit_code(int exit_code) {
404 int old = flags()->exitcode;
405 flags()->exitcode = exit_code;
406 return old;
407 }
408
__asan_handle_no_return()409 void NOINLINE __asan_handle_no_return() {
410 int local_stack;
411 AsanThread *curr_thread = GetCurrentThread();
412 CHECK(curr_thread);
413 uptr PageSize = GetPageSizeCached();
414 uptr top = curr_thread->stack_top();
415 uptr bottom = ((uptr)&local_stack - PageSize) & ~(PageSize-1);
416 static const uptr kMaxExpectedCleanupSize = 64 << 20; // 64M
417 if (top - bottom > kMaxExpectedCleanupSize) {
418 static bool reported_warning = false;
419 if (reported_warning)
420 return;
421 reported_warning = true;
422 Report("WARNING: ASan is ignoring requested __asan_handle_no_return: "
423 "stack top: %p; bottom %p; size: %p (%zd)\n"
424 "False positive error reports may follow\n"
425 "For details see "
426 "http://code.google.com/p/address-sanitizer/issues/detail?id=189\n",
427 top, bottom, top - bottom, top - bottom);
428 return;
429 }
430 PoisonShadow(bottom, top - bottom, 0);
431 }
432
__asan_set_death_callback(void (* callback)(void))433 void NOINLINE __asan_set_death_callback(void (*callback)(void)) {
434 death_callback = callback;
435 }
436
__asan_init()437 void __asan_init() {
438 if (asan_inited) return;
439 SanitizerToolName = "AddressSanitizer";
440 CHECK(!asan_init_is_running && "ASan init calls itself!");
441 asan_init_is_running = true;
442 InitializeHighMemEnd();
443
444 // Make sure we are not statically linked.
445 AsanDoesNotSupportStaticLinkage();
446
447 // Install tool-specific callbacks in sanitizer_common.
448 SetDieCallback(AsanDie);
449 SetCheckFailedCallback(AsanCheckFailed);
450 SetPrintfAndReportCallback(AppendToErrorMessageBuffer);
451
452 // Initialize flags. This must be done early, because most of the
453 // initialization steps look at flags().
454 const char *options = GetEnv("ASAN_OPTIONS");
455 InitializeFlags(flags(), options);
456 __sanitizer_set_report_path(common_flags()->log_path);
457
458 if (flags()->verbosity && options) {
459 Report("Parsed ASAN_OPTIONS: %s\n", options);
460 }
461
462 // Re-exec ourselves if we need to set additional env or command line args.
463 MaybeReexec();
464
465 // Setup internal allocator callback.
466 SetLowLevelAllocateCallback(OnLowLevelAllocate);
467
468 if (flags()->atexit) {
469 Atexit(asan_atexit);
470 }
471
472 // interceptors
473 InitializeAsanInterceptors();
474
475 ReplaceSystemMalloc();
476 ReplaceOperatorsNewAndDelete();
477
478 uptr shadow_start = kLowShadowBeg;
479 if (kLowShadowBeg)
480 shadow_start -= GetMmapGranularity();
481 bool full_shadow_is_available =
482 MemoryRangeIsAvailable(shadow_start, kHighShadowEnd);
483
484 #if SANITIZER_LINUX && defined(__x86_64__) && !ASAN_FIXED_MAPPING
485 if (!full_shadow_is_available) {
486 kMidMemBeg = kLowMemEnd < 0x3000000000ULL ? 0x3000000000ULL : 0;
487 kMidMemEnd = kLowMemEnd < 0x3000000000ULL ? 0x4fffffffffULL : 0;
488 }
489 #endif
490
491 if (flags()->verbosity)
492 PrintAddressSpaceLayout();
493
494 if (flags()->disable_core) {
495 DisableCoreDumper();
496 }
497
498 if (full_shadow_is_available) {
499 // mmap the low shadow plus at least one page at the left.
500 if (kLowShadowBeg)
501 ReserveShadowMemoryRange(shadow_start, kLowShadowEnd);
502 // mmap the high shadow.
503 ReserveShadowMemoryRange(kHighShadowBeg, kHighShadowEnd);
504 // protect the gap.
505 ProtectGap(kShadowGapBeg, kShadowGapEnd - kShadowGapBeg + 1);
506 } else if (kMidMemBeg &&
507 MemoryRangeIsAvailable(shadow_start, kMidMemBeg - 1) &&
508 MemoryRangeIsAvailable(kMidMemEnd + 1, kHighShadowEnd)) {
509 CHECK(kLowShadowBeg != kLowShadowEnd);
510 // mmap the low shadow plus at least one page at the left.
511 ReserveShadowMemoryRange(shadow_start, kLowShadowEnd);
512 // mmap the mid shadow.
513 ReserveShadowMemoryRange(kMidShadowBeg, kMidShadowEnd);
514 // mmap the high shadow.
515 ReserveShadowMemoryRange(kHighShadowBeg, kHighShadowEnd);
516 // protect the gaps.
517 ProtectGap(kShadowGapBeg, kShadowGapEnd - kShadowGapBeg + 1);
518 ProtectGap(kShadowGap2Beg, kShadowGap2End - kShadowGap2Beg + 1);
519 ProtectGap(kShadowGap3Beg, kShadowGap3End - kShadowGap3Beg + 1);
520 } else {
521 Report("Shadow memory range interleaves with an existing memory mapping. "
522 "ASan cannot proceed correctly. ABORTING.\n");
523 DumpProcessMap();
524 Die();
525 }
526
527 InstallSignalHandlers();
528
529 AsanTSDInit(AsanThread::TSDDtor);
530 // Allocator should be initialized before starting external symbolizer, as
531 // fork() on Mac locks the allocator.
532 InitializeAllocator();
533
534 // Start symbolizer process if necessary.
535 const char* external_symbolizer = common_flags()->external_symbolizer_path;
536 if (common_flags()->symbolize && external_symbolizer &&
537 external_symbolizer[0]) {
538 InitializeExternalSymbolizer(external_symbolizer);
539 }
540
541 // On Linux AsanThread::ThreadStart() calls malloc() that's why asan_inited
542 // should be set to 1 prior to initializing the threads.
543 asan_inited = 1;
544 asan_init_is_running = false;
545
546 InitTlsSize();
547
548 // Create main thread.
549 AsanThread *main_thread = AsanThread::Create(0, 0);
550 CreateThreadContextArgs create_main_args = { main_thread, 0 };
551 u32 main_tid = asanThreadRegistry().CreateThread(
552 0, true, 0, &create_main_args);
553 CHECK_EQ(0, main_tid);
554 SetCurrentThread(main_thread);
555 main_thread->ThreadStart(internal_getpid());
556 force_interface_symbols(); // no-op.
557
558 #if CAN_SANITIZE_LEAKS
559 __lsan::InitCommonLsan();
560 if (common_flags()->detect_leaks && common_flags()->leak_check_at_exit) {
561 Atexit(__lsan::DoLeakCheck);
562 }
563 #endif // CAN_SANITIZE_LEAKS
564
565 if (flags()->verbosity) {
566 Report("AddressSanitizer Init done\n");
567 }
568 }
569