src/compiler-rt/lib/msan/msan.h

   1 //===-- msan.h --------------------------------------------------*- C++ -*-===//
   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 MemorySanitizer.
  11 //
  12 // Private MSan header.
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef MSAN_H
  16 #define MSAN_H
  17
  18 #include "sanitizer_common/sanitizer_flags.h"
  19 #include "sanitizer_common/sanitizer_internal_defs.h"
  20 #include "sanitizer_common/sanitizer_stacktrace.h"
  21 #include "msan_interface_internal.h"
  22 #include "msan_flags.h"
  23
  24 #ifndef MSAN_REPLACE_OPERATORS_NEW_AND_DELETE
  25 # define MSAN_REPLACE_OPERATORS_NEW_AND_DELETE 1
  26 #endif
  27
  28 #define MEM_TO_SHADOW(mem)       (((uptr)mem) & ~0x400000000000ULL)
  29 #define SHADOW_TO_ORIGIN(shadow) (((uptr)shadow) + 0x200000000000ULL)
  30 #define MEM_TO_ORIGIN(mem)       (SHADOW_TO_ORIGIN(MEM_TO_SHADOW(mem)))
  31 #define MEM_IS_APP(mem)          ((uptr)mem >= 0x600000000000ULL)
  32 #define MEM_IS_SHADOW(mem) \
  33   ((uptr)mem >= 0x200000000000ULL && (uptr)mem <= 0x400000000000ULL)
  34
  35 // Chained stack trace format.
  36 #define TRACE_MAGIC_MASK 0xFFFFFFFF00000000LLU
  37 #define TRACE_MAKE_CHAINED(id) ((uptr)id | TRACE_MAGIC_MASK)
  38 #define TRACE_TO_CHAINED_ID(u) ((uptr)u & (~TRACE_MAGIC_MASK))
  39 #define TRACE_IS_CHAINED(u) ((((uptr)u) & TRACE_MAGIC_MASK) == TRACE_MAGIC_MASK)
  40
  41 const int kMsanParamTlsSizeInWords = 100;
  42 const int kMsanRetvalTlsSizeInWords = 100;
  43
  44 namespace __msan {
  45 extern int msan_inited;
  46 extern bool msan_init_is_running;
  47 extern int msan_report_count;
  48
  49 bool ProtectRange(uptr beg, uptr end);
  50 bool InitShadow(bool prot1, bool prot2, bool map_shadow, bool init_origins);
  51 char *GetProcSelfMaps();
  52 void InitializeInterceptors();
  53
  54 void MsanAllocatorThreadFinish();
  55 void *MsanReallocate(StackTrace *stack, void *oldp, uptr size,
  56                      uptr alignment, bool zeroise);
  57 void MsanDeallocate(StackTrace *stack, void *ptr);
  58 void InstallTrapHandler();
  59 void InstallAtExitHandler();
  60 void ReplaceOperatorsNewAndDelete();
  61
  62 const char *GetOriginDescrIfStack(u32 id, uptr *pc);
  63
  64 void EnterSymbolizer();
  65 void ExitSymbolizer();
  66 bool IsInSymbolizer();
  67
  68 struct SymbolizerScope {
  69   SymbolizerScope() { EnterSymbolizer(); }
  70   ~SymbolizerScope() { ExitSymbolizer(); }
  71 };
  72
  73 void EnterLoader();
  74 void ExitLoader();
  75
  76 void MsanDie();
  77 void PrintWarning(uptr pc, uptr bp);
  78 void PrintWarningWithOrigin(uptr pc, uptr bp, u32 origin);
  79
  80 void GetStackTrace(StackTrace *stack, uptr max_s, uptr pc, uptr bp,
  81                    bool request_fast_unwind);
  82
  83 void ReportUMR(StackTrace *stack, u32 origin);
  84 void ReportExpectedUMRNotFound(StackTrace *stack);
  85 void ReportAtExitStatistics();
  86 void DescribeMemoryRange(const void *x, uptr size);
  87
  88 // Unpoison first n function arguments.
  89 void UnpoisonParam(uptr n);
  90 void UnpoisonThreadLocalState();
  91
  92 u32 GetOriginIfPoisoned(uptr a, uptr size);
  93 void SetOriginIfPoisoned(uptr addr, uptr src_shadow, uptr size, u32 src_origin);
  94 void CopyOrigin(void *dst, const void *src, uptr size, StackTrace *stack);
  95 void MovePoison(void *dst, const void *src, uptr size, StackTrace *stack);
  96 void CopyPoison(void *dst, const void *src, uptr size, StackTrace *stack);
  97
  98 // Returns a "chained" origin id, pointing to the given stack trace followed by
  99 // the previous origin id.
 100 u32 ChainOrigin(u32 id, StackTrace *stack);
 101
 102 #define GET_MALLOC_STACK_TRACE                                     \
 103   StackTrace stack;                                                \
 104   stack.size = 0;                                                  \
 105   if (__msan_get_track_origins() && msan_inited)                   \
 106     GetStackTrace(&stack, common_flags()->malloc_context_size,     \
 107         StackTrace::GetCurrentPc(), GET_CURRENT_FRAME(),           \
 108         common_flags()->fast_unwind_on_malloc)
 109
 110 #define GET_STORE_STACK_TRACE_PC_BP(pc, bp)                            \
 111   StackTrace stack;                                                    \
 112   stack.size = 0;                                                      \
 113   if (__msan_get_track_origins() > 1 && msan_inited)                   \
 114     GetStackTrace(&stack, common_flags()->malloc_context_size, pc, bp, \
 115                   common_flags()->fast_unwind_on_malloc)
 116
 117 #define GET_STORE_STACK_TRACE \
 118   GET_STORE_STACK_TRACE_PC_BP(StackTrace::GetCurrentPc(), GET_CURRENT_FRAME())
 119
 120 class ScopedThreadLocalStateBackup {
 121  public:
 122   ScopedThreadLocalStateBackup() { Backup(); }
 123   ~ScopedThreadLocalStateBackup() { Restore(); }
 124   void Backup();
 125   void Restore();
 126  private:
 127   u64 va_arg_overflow_size_tls;
 128 };
 129
 130 extern void (*death_callback)(void);
 131
 132 void MsanTSDInit(void (*destructor)(void *tsd));
 133 void *MsanTSDGet();
 134 void MsanTSDSet(void *tsd);
 135 void MsanTSDDtor(void *tsd);
 136
 137 }  // namespace __msan
 138
 139 #define MSAN_MALLOC_HOOK(ptr, size) \
 140   if (&__msan_malloc_hook) __msan_malloc_hook(ptr, size)
 141 #define MSAN_FREE_HOOK(ptr) \
 142   if (&__msan_free_hook) __msan_free_hook(ptr)
 143
 144 #endif  // MSAN_H