Debian Codegraph @

src/backend/jit/llvm/llvmjit_error.cpp

raw
1 /*-------------------------------------------------------------------------
2 *
3 * llvmjit_error.cpp
4 * LLVM error related handling that requires interfacing with C++
5 *
6 * Unfortunately neither (re)setting the C++ new handler, nor the LLVM OOM
7 * handler are exposed to C. Therefore this file wraps the necessary code.
8 *
9 * Copyright (c) 2016-2025, PostgreSQL Global Development Group
10 *
11 * IDENTIFICATION
12 * src/backend/jit/llvm/llvmjit_error.cpp
13 *
14 *-------------------------------------------------------------------------
15 */
16
17 extern "C"
18 {
19 #include "postgres.h"
20 }
21
22 #include <llvm/Support/ErrorHandling.h>
23
24 #include "jit/llvmjit.h"
25
26 #include <new>
27
28 static int fatal_new_handler_depth = 0;
29 static std::new_handler old_new_handler = NULL;
30
31 static void fatal_system_new_handler(void);
32 static void fatal_llvm_new_handler(void *user_data, const char *reason, bool gen_crash_diag);
33 static void fatal_llvm_error_handler(void *user_data, const char *reason, bool gen_crash_diag);
34
35
36 /*
37 * Enter a section in which C++ and LLVM errors are treated as FATAL errors.
38 *
39 * This is necessary for LLVM as LLVM's error handling for such cases
40 * (exit()ing, throwing std::bad_alloc() if compiled with exceptions, abort())
41 * isn't compatible with postgres error handling. Thus in sections where LLVM
42 * code, not LLVM generated functions!, is executing, standard new, LLVM OOM
43 * and LLVM fatal errors (some OOM errors masquerade as those) are redirected
44 * to our own error handlers.
45 *
46 * These error handlers use FATAL, because there's no reliable way from within
47 * LLVM to throw an error that's guaranteed not to corrupt LLVM's state.
48 *
49 * To avoid disturbing extensions using C++ and/or LLVM, these handlers are
50 * unset when not executing LLVM code. There is no need to call
51 * llvm_leave_fatal_on_oom() when ERRORing out, error recovery resets the
52 * handlers in that case.
53 */
54 void
55 llvm_enter_fatal_on_oom(void)
56 {
57 if (fatal_new_handler_depth == 0)
58 {
59 old_new_handler = std::set_new_handler(fatal_system_new_handler);
60 llvm::install_bad_alloc_error_handler(fatal_llvm_new_handler);
61 llvm::install_fatal_error_handler(fatal_llvm_error_handler);
62 }
63 fatal_new_handler_depth++;
64 }
65
66 /*
67 * Leave fatal error section started with llvm_enter_fatal_on_oom().
68 */
69 void
70 llvm_leave_fatal_on_oom(void)
71 {
72 fatal_new_handler_depth--;
73 if (fatal_new_handler_depth == 0)
74 {
75 std::set_new_handler(old_new_handler);
76 llvm::remove_bad_alloc_error_handler();
77 llvm::remove_fatal_error_handler();
78 }
79 }
80
81 /*
82 * Are we currently in a fatal-on-oom section? Useful to skip cleanup in case
83 * of errors.
84 */
85 bool
86 llvm_in_fatal_on_oom(void)
87 {
88 return fatal_new_handler_depth > 0;
89 }
90
91 /*
92 * Reset fatal error handling. This should only be called in error recovery
93 * loops like PostgresMain()'s.
94 */
95 void
96 llvm_reset_after_error(void)
97 {
98 if (fatal_new_handler_depth != 0)
99 {
100 std::set_new_handler(old_new_handler);
101 llvm::remove_bad_alloc_error_handler();
102 llvm::remove_fatal_error_handler();
103 }
104 fatal_new_handler_depth = 0;
105 }
106
107 void
108 llvm_assert_in_fatal_section(void)
109 {
110 Assert(fatal_new_handler_depth > 0);
111 }
112
113 static void
114 fatal_system_new_handler(void)
115 {
116 ereport(FATAL,
117 (errcode(ERRCODE_OUT_OF_MEMORY),
118 errmsg("out of memory"),
119 errdetail("while in LLVM")));
120 }
121
122 static void
123 fatal_llvm_new_handler(void *user_data,
124 const char *reason,
125 bool gen_crash_diag)
126 {
127 ereport(FATAL,
128 (errcode(ERRCODE_OUT_OF_MEMORY),
129 errmsg("out of memory"),
130 errdetail("While in LLVM: %s", reason)));
131 }
132
133 static void
134 fatal_llvm_error_handler(void *user_data,
135 const char *reason,
136 bool gen_crash_diag)
137 {
138 ereport(FATAL,
139 (errcode(ERRCODE_OUT_OF_MEMORY),
140 errmsg("fatal llvm error: %s", reason)));
141 }