1//===-- msan_interface.h --------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file is a part of MemorySanitizer.
10//
11// Public interface header.
12//===----------------------------------------------------------------------===//
13#ifndef MSAN_INTERFACE_H
14#define MSAN_INTERFACE_H
15
16#include <sanitizer/common_interface_defs.h>
17
18#ifdef __cplusplus
19extern "C" {
20#endif
21/* Set raw origin for the memory range. */
22void SANITIZER_CDECL __msan_set_origin(const volatile void *a, size_t size,
23 uint32_t origin);
24
25/* Get raw origin for an address. */
26uint32_t SANITIZER_CDECL __msan_get_origin(const volatile void *a);
27
28/* Test that this_id is a descendant of prev_id (or they are simply equal).
29 * "descendant" here means they are part of the same chain, created with
30 * __msan_chain_origin. */
31int SANITIZER_CDECL __msan_origin_is_descendant_or_same(uint32_t this_id,
32 uint32_t prev_id);
33
34/* Returns non-zero if tracking origins. */
35int SANITIZER_CDECL __msan_get_track_origins(void);
36
37/* Returns the origin id of the latest UMR in the calling thread. */
38uint32_t SANITIZER_CDECL __msan_get_umr_origin(void);
39
40/* Make memory region fully initialized (without changing its contents). */
41void SANITIZER_CDECL __msan_unpoison(const volatile void *a, size_t size);
42
43/* Make a null-terminated string fully initialized (without changing its
44 contents). */
45void SANITIZER_CDECL __msan_unpoison_string(const volatile char *a);
46
47/* Make first n parameters of the next function call fully initialized. */
48void SANITIZER_CDECL __msan_unpoison_param(size_t n);
49
50/* Make memory region fully uninitialized (without changing its contents).
51 This is a legacy interface that does not update origin information. Use
52 __msan_allocated_memory() instead. */
53void SANITIZER_CDECL __msan_poison(const volatile void *a, size_t size);
54
55/* Make memory region partially uninitialized (without changing its contents).
56 */
57void SANITIZER_CDECL __msan_partial_poison(const volatile void *data,
58 void *shadow, size_t size);
59
60/* Returns the offset of the first (at least partially) poisoned byte in the
61 memory range, or -1 if the whole range is good. */
62intptr_t SANITIZER_CDECL __msan_test_shadow(const volatile void *x,
63 size_t size);
64
65/* Checks that memory range is fully initialized, and reports an error if it
66 * is not. */
67void SANITIZER_CDECL __msan_check_mem_is_initialized(const volatile void *x,
68 size_t size);
69
70/* For testing:
71 __msan_set_expect_umr(1);
72 ... some buggy code ...
73 __msan_set_expect_umr(0);
74 The last line will verify that a UMR happened. */
75void SANITIZER_CDECL __msan_set_expect_umr(int expect_umr);
76
77/* Change the value of keep_going flag. Non-zero value means don't terminate
78 program execution when an error is detected. This will not affect error in
79 modules that were compiled without the corresponding compiler flag. */
80void SANITIZER_CDECL __msan_set_keep_going(int keep_going);
81
82/* Print shadow and origin for the memory range to stderr in a human-readable
83 format. */
84void SANITIZER_CDECL __msan_print_shadow(const volatile void *x, size_t size);
85
86/* Print shadow for the memory range to stderr in a minimalistic
87 human-readable format. */
88void SANITIZER_CDECL __msan_dump_shadow(const volatile void *x, size_t size);
89
90/* Returns true if running under a dynamic tool (DynamoRio-based). */
91int SANITIZER_CDECL __msan_has_dynamic_component(void);
92
93/* Tell MSan about newly allocated memory (ex.: custom allocator).
94 Memory will be marked uninitialized, with origin at the call site. */
95void SANITIZER_CDECL __msan_allocated_memory(const volatile void *data,
96 size_t size);
97
98/* Tell MSan about newly destroyed memory. Mark memory as uninitialized. */
99void SANITIZER_CDECL __sanitizer_dtor_callback(const volatile void *data,
100 size_t size);
101void SANITIZER_CDECL __sanitizer_dtor_callback_fields(const volatile void *data,
102 size_t size);
103void SANITIZER_CDECL __sanitizer_dtor_callback_vptr(const volatile void *data);
104
105/* This function may be optionally provided by user and should return
106 a string containing Msan runtime options. See msan_flags.h for details. */
107const char *SANITIZER_CDECL __msan_default_options(void);
108
109/* Deprecated. Call __sanitizer_set_death_callback instead. */
110void SANITIZER_CDECL
111__msan_set_death_callback(void(SANITIZER_CDECL *callback)(void));
112
113/* Update shadow for the application copy of size bytes from src to dst.
114 Src and dst are application addresses. This function does not copy the
115 actual application memory, it only updates shadow and origin for such
116 copy. Source and destination regions can overlap. */
117void SANITIZER_CDECL __msan_copy_shadow(const volatile void *dst,
118 const volatile void *src, size_t size);
119
120/* Disables uninitialized memory checks in interceptors. */
121void SANITIZER_CDECL __msan_scoped_disable_interceptor_checks(void);
122
123/* Re-enables uninitialized memory checks in interceptors after a previous
124 call to __msan_scoped_disable_interceptor_checks. */
125void SANITIZER_CDECL __msan_scoped_enable_interceptor_checks(void);
126
127void SANITIZER_CDECL __msan_start_switch_fiber(const void *bottom, size_t size);
128void SANITIZER_CDECL __msan_finish_switch_fiber(const void **bottom_old,
129 size_t *size_old);
130
131#ifdef __cplusplus
132} // extern "C"
133#endif
134
135#endif
136

source code of compiler-rt/include/sanitizer/msan_interface.h