File: | tools/llvm-objcopy/llvm-objcopy.cpp |
Warning: | line 319, column 1 Potential memory leak |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- llvm-objcopy.cpp ---------------------------------------------------===// | |||
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 | #include "llvm-objcopy.h" | |||
11 | #include "Object.h" | |||
12 | #include "llvm/ADT/STLExtras.h" | |||
13 | #include "llvm/ADT/StringRef.h" | |||
14 | #include "llvm/ADT/Twine.h" | |||
15 | #include "llvm/BinaryFormat/ELF.h" | |||
16 | #include "llvm/Object/Binary.h" | |||
17 | #include "llvm/Object/ELFObjectFile.h" | |||
18 | #include "llvm/Object/ELFTypes.h" | |||
19 | #include "llvm/Object/Error.h" | |||
20 | #include "llvm/Support/Casting.h" | |||
21 | #include "llvm/Support/CommandLine.h" | |||
22 | #include "llvm/Support/Compiler.h" | |||
23 | #include "llvm/Support/Error.h" | |||
24 | #include "llvm/Support/ErrorHandling.h" | |||
25 | #include "llvm/Support/ErrorOr.h" | |||
26 | #include "llvm/Support/FileOutputBuffer.h" | |||
27 | #include "llvm/Support/ManagedStatic.h" | |||
28 | #include "llvm/Support/PrettyStackTrace.h" | |||
29 | #include "llvm/Support/Signals.h" | |||
30 | #include "llvm/Support/raw_ostream.h" | |||
31 | #include <algorithm> | |||
32 | #include <cassert> | |||
33 | #include <cstdlib> | |||
34 | #include <functional> | |||
35 | #include <iterator> | |||
36 | #include <memory> | |||
37 | #include <string> | |||
38 | #include <system_error> | |||
39 | #include <utility> | |||
40 | ||||
41 | using namespace llvm; | |||
42 | using namespace object; | |||
43 | using namespace ELF; | |||
44 | ||||
45 | // The name this program was invoked as. | |||
46 | static StringRef ToolName; | |||
47 | ||||
48 | namespace llvm { | |||
49 | ||||
50 | LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void error(Twine Message) { | |||
51 | errs() << ToolName << ": " << Message << ".\n"; | |||
52 | errs().flush(); | |||
53 | exit(1); | |||
54 | } | |||
55 | ||||
56 | LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void reportError(StringRef File, std::error_code EC) { | |||
57 | assert(EC)(static_cast <bool> (EC) ? void (0) : __assert_fail ("EC" , "/build/llvm-toolchain-snapshot-7~svn329677/tools/llvm-objcopy/llvm-objcopy.cpp" , 57, __extension__ __PRETTY_FUNCTION__)); | |||
58 | errs() << ToolName << ": '" << File << "': " << EC.message() << ".\n"; | |||
59 | exit(1); | |||
60 | } | |||
61 | ||||
62 | LLVM_ATTRIBUTE_NORETURN__attribute__((noreturn)) void reportError(StringRef File, Error E) { | |||
63 | assert(E)(static_cast <bool> (E) ? void (0) : __assert_fail ("E" , "/build/llvm-toolchain-snapshot-7~svn329677/tools/llvm-objcopy/llvm-objcopy.cpp" , 63, __extension__ __PRETTY_FUNCTION__)); | |||
64 | std::string Buf; | |||
65 | raw_string_ostream OS(Buf); | |||
66 | logAllUnhandledErrors(std::move(E), OS, ""); | |||
67 | OS.flush(); | |||
68 | errs() << ToolName << ": '" << File << "': " << Buf; | |||
69 | exit(1); | |||
70 | } | |||
71 | ||||
72 | } // end namespace llvm | |||
73 | ||||
74 | static cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input>")); | |||
75 | static cl::opt<std::string> OutputFilename(cl::Positional, cl::desc("[ <output> ]")); | |||
76 | ||||
77 | static cl::opt<std::string> | |||
78 | OutputFormat("O", cl::desc("Set output format to one of the following:" | |||
79 | "\n\tbinary")); | |||
80 | static cl::list<std::string> ToRemove("remove-section", | |||
81 | cl::desc("Remove <section>"), | |||
82 | cl::value_desc("section")); | |||
83 | static cl::alias ToRemoveA("R", cl::desc("Alias for remove-section"), | |||
84 | cl::aliasopt(ToRemove)); | |||
85 | static cl::opt<bool> StripAll( | |||
86 | "strip-all", | |||
87 | cl::desc( | |||
88 | "Removes non-allocated sections other than .gnu.warning* sections")); | |||
89 | static cl::opt<bool> | |||
90 | StripAllGNU("strip-all-gnu", | |||
91 | cl::desc("Removes symbol, relocation, and debug information")); | |||
92 | static cl::list<std::string> Keep("keep", cl::desc("Keep <section>"), | |||
93 | cl::value_desc("section")); | |||
94 | static cl::list<std::string> OnlyKeep("only-keep", | |||
95 | cl::desc("Remove all but <section>"), | |||
96 | cl::value_desc("section")); | |||
97 | static cl::alias OnlyKeepA("j", cl::desc("Alias for only-keep"), | |||
98 | cl::aliasopt(OnlyKeep)); | |||
99 | static cl::opt<bool> StripDebug("strip-debug", | |||
100 | cl::desc("Removes all debug information")); | |||
101 | static cl::opt<bool> StripSections("strip-sections", | |||
102 | cl::desc("Remove all section headers")); | |||
103 | static cl::opt<bool> | |||
104 | StripNonAlloc("strip-non-alloc", | |||
105 | cl::desc("Remove all non-allocated sections")); | |||
106 | static cl::opt<bool> | |||
107 | StripDWO("strip-dwo", cl::desc("Remove all DWARF .dwo sections from file")); | |||
108 | static cl::opt<bool> ExtractDWO( | |||
109 | "extract-dwo", | |||
110 | cl::desc("Remove all sections that are not DWARF .dwo sections from file")); | |||
111 | static cl::opt<std::string> | |||
112 | SplitDWO("split-dwo", | |||
113 | cl::desc("Equivalent to extract-dwo on the input file to " | |||
114 | "<dwo-file>, then strip-dwo on the input file"), | |||
115 | cl::value_desc("dwo-file")); | |||
116 | static cl::list<std::string> AddSection( | |||
117 | "add-section", | |||
118 | cl::desc("Make a section named <section> with the contents of <file>."), | |||
119 | cl::value_desc("section=file")); | |||
120 | static cl::opt<bool> LocalizeHidden( | |||
121 | "localize-hidden", | |||
122 | cl::desc( | |||
123 | "Mark all symbols that have hidden or internal visibility as local")); | |||
124 | static cl::opt<std::string> | |||
125 | AddGnuDebugLink("add-gnu-debuglink", | |||
126 | cl::desc("adds a .gnu_debuglink for <debug-file>"), | |||
127 | cl::value_desc("debug-file")); | |||
128 | ||||
129 | using SectionPred = std::function<bool(const SectionBase &Sec)>; | |||
130 | ||||
131 | bool IsDWOSection(const SectionBase &Sec) { return Sec.Name.endswith(".dwo"); } | |||
132 | ||||
133 | bool OnlyKeepDWOPred(const Object &Obj, const SectionBase &Sec) { | |||
134 | // We can't remove the section header string table. | |||
135 | if (&Sec == Obj.SectionNames) | |||
136 | return false; | |||
137 | // Short of keeping the string table we want to keep everything that is a DWO | |||
138 | // section and remove everything else. | |||
139 | return !IsDWOSection(Sec); | |||
140 | } | |||
141 | ||||
142 | static ElfType OutputElfType; | |||
143 | ||||
144 | std::unique_ptr<Writer> CreateWriter(Object &Obj, StringRef File) { | |||
145 | if (OutputFormat == "binary") { | |||
146 | return llvm::make_unique<BinaryWriter>(OutputFilename, Obj); | |||
147 | } | |||
148 | // Depending on the initial ELFT and OutputFormat we need a different Writer. | |||
149 | switch (OutputElfType) { | |||
150 | case ELFT_ELF32LE: | |||
151 | return llvm::make_unique<ELFWriter<ELF32LE>>(File, Obj, !StripSections); | |||
152 | case ELFT_ELF64LE: | |||
153 | return llvm::make_unique<ELFWriter<ELF64LE>>(File, Obj, !StripSections); | |||
154 | case ELFT_ELF32BE: | |||
155 | return llvm::make_unique<ELFWriter<ELF32BE>>(File, Obj, !StripSections); | |||
156 | case ELFT_ELF64BE: | |||
157 | return llvm::make_unique<ELFWriter<ELF64BE>>(File, Obj, !StripSections); | |||
158 | } | |||
159 | llvm_unreachable("Invalid output format")::llvm::llvm_unreachable_internal("Invalid output format", "/build/llvm-toolchain-snapshot-7~svn329677/tools/llvm-objcopy/llvm-objcopy.cpp" , 159); | |||
160 | } | |||
161 | ||||
162 | void SplitDWOToFile(const Reader &Reader, StringRef File) { | |||
163 | auto DWOFile = Reader.create(); | |||
164 | DWOFile->removeSections( | |||
165 | [&](const SectionBase &Sec) { return OnlyKeepDWOPred(*DWOFile, Sec); }); | |||
166 | auto Writer = CreateWriter(*DWOFile, File); | |||
167 | Writer->finalize(); | |||
168 | Writer->write(); | |||
169 | } | |||
170 | ||||
171 | // This function handles the high level operations of GNU objcopy including | |||
172 | // handling command line options. It's important to outline certain properties | |||
173 | // we expect to hold of the command line operations. Any operation that "keeps" | |||
174 | // should keep regardless of a remove. Additionally any removal should respect | |||
175 | // any previous removals. Lastly whether or not something is removed shouldn't | |||
176 | // depend a) on the order the options occur in or b) on some opaque priority | |||
177 | // system. The only priority is that keeps/copies overrule removes. | |||
178 | void HandleArgs(Object &Obj, const Reader &Reader) { | |||
179 | ||||
180 | if (!SplitDWO.empty()) { | |||
181 | SplitDWOToFile(Reader, SplitDWO); | |||
182 | } | |||
183 | ||||
184 | // Localize: | |||
185 | ||||
186 | if (LocalizeHidden) { | |||
187 | Obj.SymbolTable->localize([](const Symbol &Sym) { | |||
188 | return Sym.Visibility == STV_HIDDEN || Sym.Visibility == STV_INTERNAL; | |||
189 | }); | |||
190 | } | |||
191 | ||||
192 | SectionPred RemovePred = [](const SectionBase &) { return false; }; | |||
193 | ||||
194 | // Removes: | |||
195 | ||||
196 | if (!ToRemove.empty()) { | |||
197 | RemovePred = [&](const SectionBase &Sec) { | |||
198 | return std::find(std::begin(ToRemove), std::end(ToRemove), Sec.Name) != | |||
199 | std::end(ToRemove); | |||
200 | }; | |||
201 | } | |||
202 | ||||
203 | if (StripDWO || !SplitDWO.empty()) | |||
204 | RemovePred = [RemovePred](const SectionBase &Sec) { | |||
205 | return IsDWOSection(Sec) || RemovePred(Sec); | |||
206 | }; | |||
207 | ||||
208 | if (ExtractDWO) | |||
209 | RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { | |||
210 | return OnlyKeepDWOPred(Obj, Sec) || RemovePred(Sec); | |||
211 | }; | |||
212 | ||||
213 | if (StripAllGNU) | |||
214 | RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { | |||
215 | if (RemovePred(Sec)) | |||
216 | return true; | |||
217 | if ((Sec.Flags & SHF_ALLOC) != 0) | |||
218 | return false; | |||
219 | if (&Sec == Obj.SectionNames) | |||
220 | return false; | |||
221 | switch (Sec.Type) { | |||
222 | case SHT_SYMTAB: | |||
223 | case SHT_REL: | |||
224 | case SHT_RELA: | |||
225 | case SHT_STRTAB: | |||
226 | return true; | |||
227 | } | |||
228 | return Sec.Name.startswith(".debug"); | |||
229 | }; | |||
230 | ||||
231 | if (StripSections) { | |||
232 | RemovePred = [RemovePred](const SectionBase &Sec) { | |||
233 | return RemovePred(Sec) || (Sec.Flags & SHF_ALLOC) == 0; | |||
234 | }; | |||
235 | } | |||
236 | ||||
237 | if (StripDebug) { | |||
238 | RemovePred = [RemovePred](const SectionBase &Sec) { | |||
239 | return RemovePred(Sec) || Sec.Name.startswith(".debug"); | |||
240 | }; | |||
241 | } | |||
242 | ||||
243 | if (StripNonAlloc) | |||
244 | RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { | |||
245 | if (RemovePred(Sec)) | |||
246 | return true; | |||
247 | if (&Sec == Obj.SectionNames) | |||
248 | return false; | |||
249 | return (Sec.Flags & SHF_ALLOC) == 0; | |||
250 | }; | |||
251 | ||||
252 | if (StripAll) | |||
253 | RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { | |||
254 | if (RemovePred(Sec)) | |||
255 | return true; | |||
256 | if (&Sec == Obj.SectionNames) | |||
257 | return false; | |||
258 | if (Sec.Name.startswith(".gnu.warning")) | |||
259 | return false; | |||
260 | return (Sec.Flags & SHF_ALLOC) == 0; | |||
261 | }; | |||
262 | ||||
263 | // Explicit copies: | |||
264 | ||||
265 | if (!OnlyKeep.empty()) { | |||
266 | RemovePred = [RemovePred, &Obj](const SectionBase &Sec) { | |||
267 | // Explicitly keep these sections regardless of previous removes. | |||
268 | if (std::find(std::begin(OnlyKeep), std::end(OnlyKeep), Sec.Name) != | |||
269 | std::end(OnlyKeep)) | |||
270 | return false; | |||
271 | ||||
272 | // Allow all implicit removes. | |||
273 | if (RemovePred(Sec)) | |||
274 | return true; | |||
275 | ||||
276 | // Keep special sections. | |||
277 | if (Obj.SectionNames == &Sec) | |||
278 | return false; | |||
279 | if (Obj.SymbolTable == &Sec || Obj.SymbolTable->getStrTab() == &Sec) | |||
280 | return false; | |||
281 | ||||
282 | // Remove everything else. | |||
283 | return true; | |||
284 | }; | |||
285 | } | |||
286 | ||||
287 | if (!Keep.empty()) { | |||
288 | RemovePred = [RemovePred](const SectionBase &Sec) { | |||
289 | // Explicitly keep these sections regardless of previous removes. | |||
290 | if (std::find(std::begin(Keep), std::end(Keep), Sec.Name) != | |||
291 | std::end(Keep)) | |||
292 | return false; | |||
293 | // Otherwise defer to RemovePred. | |||
294 | return RemovePred(Sec); | |||
295 | }; | |||
296 | } | |||
297 | ||||
298 | Obj.removeSections(RemovePred); | |||
299 | ||||
300 | if (!AddSection.empty()) { | |||
301 | for (const auto &Flag : AddSection) { | |||
302 | auto SecPair = StringRef(Flag).split("="); | |||
303 | auto SecName = SecPair.first; | |||
304 | auto File = SecPair.second; | |||
305 | auto BufOrErr = MemoryBuffer::getFile(File); | |||
306 | if (!BufOrErr) | |||
307 | reportError(File, BufOrErr.getError()); | |||
308 | auto Buf = std::move(*BufOrErr); | |||
309 | auto BufPtr = reinterpret_cast<const uint8_t *>(Buf->getBufferStart()); | |||
310 | auto BufSize = Buf->getBufferSize(); | |||
311 | Obj.addSection<OwnedDataSection>(SecName, | |||
312 | ArrayRef<uint8_t>(BufPtr, BufSize)); | |||
313 | } | |||
314 | } | |||
315 | ||||
316 | if (!AddGnuDebugLink.empty()) { | |||
317 | Obj.addSection<GnuDebugLinkSection>(StringRef(AddGnuDebugLink)); | |||
318 | } | |||
319 | } | |||
| ||||
320 | ||||
321 | std::unique_ptr<Reader> CreateReader() { | |||
322 | // Right now we can only read ELF files so there's only one reader; | |||
323 | auto Out = llvm::make_unique<ELFReader>(StringRef(InputFilename)); | |||
324 | // We need to set the default ElfType for output. | |||
325 | OutputElfType = Out->getElfType(); | |||
326 | return std::move(Out); | |||
327 | } | |||
328 | ||||
329 | int main(int argc, char **argv) { | |||
330 | // Print a stack trace if we signal out. | |||
331 | sys::PrintStackTraceOnErrorSignal(argv[0]); | |||
332 | PrettyStackTraceProgram X(argc, argv); | |||
333 | llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. | |||
334 | cl::ParseCommandLineOptions(argc, argv, "llvm objcopy utility\n"); | |||
335 | ToolName = argv[0]; | |||
336 | if (InputFilename.empty()) { | |||
| ||||
337 | cl::PrintHelpMessage(); | |||
338 | return 2; | |||
339 | } | |||
340 | ||||
341 | auto Reader = CreateReader(); | |||
342 | auto Obj = Reader->create(); | |||
343 | StringRef Output = | |||
344 | OutputFilename.getNumOccurrences() ? OutputFilename : InputFilename; | |||
345 | auto Writer = CreateWriter(*Obj, Output); | |||
346 | HandleArgs(*Obj, *Reader); | |||
347 | Writer->finalize(); | |||
348 | Writer->write(); | |||
349 | } |
1 | // Implementation of std::function -*- C++ -*- |
2 | |
3 | // Copyright (C) 2004-2017 Free Software Foundation, Inc. |
4 | // |
5 | // This file is part of the GNU ISO C++ Library. This library is free |
6 | // software; you can redistribute it and/or modify it under the |
7 | // terms of the GNU General Public License as published by the |
8 | // Free Software Foundation; either version 3, or (at your option) |
9 | // any later version. |
10 | |
11 | // This library is distributed in the hope that it will be useful, |
12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | // GNU General Public License for more details. |
15 | |
16 | // Under Section 7 of GPL version 3, you are granted additional |
17 | // permissions described in the GCC Runtime Library Exception, version |
18 | // 3.1, as published by the Free Software Foundation. |
19 | |
20 | // You should have received a copy of the GNU General Public License and |
21 | // a copy of the GCC Runtime Library Exception along with this program; |
22 | // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
23 | // <http://www.gnu.org/licenses/>. |
24 | |
25 | /** @file include/bits/function.h |
26 | * This is an internal header file, included by other library headers. |
27 | * Do not attempt to use it directly. @headername{functional} |
28 | */ |
29 | |
30 | #ifndef _GLIBCXX_STD_FUNCTION_H1 |
31 | #define _GLIBCXX_STD_FUNCTION_H1 1 |
32 | |
33 | #pragma GCC system_header |
34 | |
35 | #if __cplusplus201103L < 201103L |
36 | # include <bits/c++0x_warning.h> |
37 | #else |
38 | |
39 | #if __cpp_rtti199711 |
40 | # include <typeinfo> |
41 | #endif |
42 | #include <bits/stl_function.h> |
43 | #include <bits/invoke.h> |
44 | #include <bits/refwrap.h> |
45 | #include <bits/functexcept.h> |
46 | |
47 | namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default"))) |
48 | { |
49 | _GLIBCXX_BEGIN_NAMESPACE_VERSION |
50 | |
51 | /** |
52 | * Derives from @c unary_function or @c binary_function, or perhaps |
53 | * nothing, depending on the number of arguments provided. The |
54 | * primary template is the basis case, which derives nothing. |
55 | */ |
56 | template<typename _Res, typename... _ArgTypes> |
57 | struct _Maybe_unary_or_binary_function { }; |
58 | |
59 | /// Derives from @c unary_function, as appropriate. |
60 | template<typename _Res, typename _T1> |
61 | struct _Maybe_unary_or_binary_function<_Res, _T1> |
62 | : std::unary_function<_T1, _Res> { }; |
63 | |
64 | /// Derives from @c binary_function, as appropriate. |
65 | template<typename _Res, typename _T1, typename _T2> |
66 | struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> |
67 | : std::binary_function<_T1, _T2, _Res> { }; |
68 | |
69 | |
70 | /** |
71 | * @brief Exception class thrown when class template function's |
72 | * operator() is called with an empty target. |
73 | * @ingroup exceptions |
74 | */ |
75 | class bad_function_call : public std::exception |
76 | { |
77 | public: |
78 | virtual ~bad_function_call() noexcept; |
79 | |
80 | const char* what() const noexcept; |
81 | }; |
82 | |
83 | /** |
84 | * Trait identifying "location-invariant" types, meaning that the |
85 | * address of the object (or any of its members) will not escape. |
86 | * Trivially copyable types are location-invariant and users can |
87 | * specialize this trait for other types. |
88 | */ |
89 | template<typename _Tp> |
90 | struct __is_location_invariant |
91 | : is_trivially_copyable<_Tp>::type |
92 | { }; |
93 | |
94 | class _Undefined_class; |
95 | |
96 | union _Nocopy_types |
97 | { |
98 | void* _M_object; |
99 | const void* _M_const_object; |
100 | void (*_M_function_pointer)(); |
101 | void (_Undefined_class::*_M_member_pointer)(); |
102 | }; |
103 | |
104 | union [[gnu::may_alias]] _Any_data |
105 | { |
106 | void* _M_access() { return &_M_pod_data[0]; } |
107 | const void* _M_access() const { return &_M_pod_data[0]; } |
108 | |
109 | template<typename _Tp> |
110 | _Tp& |
111 | _M_access() |
112 | { return *static_cast<_Tp*>(_M_access()); } |
113 | |
114 | template<typename _Tp> |
115 | const _Tp& |
116 | _M_access() const |
117 | { return *static_cast<const _Tp*>(_M_access()); } |
118 | |
119 | _Nocopy_types _M_unused; |
120 | char _M_pod_data[sizeof(_Nocopy_types)]; |
121 | }; |
122 | |
123 | enum _Manager_operation |
124 | { |
125 | __get_type_info, |
126 | __get_functor_ptr, |
127 | __clone_functor, |
128 | __destroy_functor |
129 | }; |
130 | |
131 | // Simple type wrapper that helps avoid annoying const problems |
132 | // when casting between void pointers and pointers-to-pointers. |
133 | template<typename _Tp> |
134 | struct _Simple_type_wrapper |
135 | { |
136 | _Simple_type_wrapper(_Tp __value) : __value(__value) { } |
137 | |
138 | _Tp __value; |
139 | }; |
140 | |
141 | template<typename _Tp> |
142 | struct __is_location_invariant<_Simple_type_wrapper<_Tp> > |
143 | : __is_location_invariant<_Tp> |
144 | { }; |
145 | |
146 | template<typename _Signature> |
147 | class function; |
148 | |
149 | /// Base class of all polymorphic function object wrappers. |
150 | class _Function_base |
151 | { |
152 | public: |
153 | static const std::size_t _M_max_size = sizeof(_Nocopy_types); |
154 | static const std::size_t _M_max_align = __alignof__(_Nocopy_types); |
155 | |
156 | template<typename _Functor> |
157 | class _Base_manager |
158 | { |
159 | protected: |
160 | static const bool __stored_locally = |
161 | (__is_location_invariant<_Functor>::value |
162 | && sizeof(_Functor) <= _M_max_size |
163 | && __alignof__(_Functor) <= _M_max_align |
164 | && (_M_max_align % __alignof__(_Functor) == 0)); |
165 | |
166 | typedef integral_constant<bool, __stored_locally> _Local_storage; |
167 | |
168 | // Retrieve a pointer to the function object |
169 | static _Functor* |
170 | _M_get_pointer(const _Any_data& __source) |
171 | { |
172 | const _Functor* __ptr = |
173 | __stored_locally? std::__addressof(__source._M_access<_Functor>()) |
174 | /* have stored a pointer */ : __source._M_access<_Functor*>(); |
175 | return const_cast<_Functor*>(__ptr); |
176 | } |
177 | |
178 | // Clone a location-invariant function object that fits within |
179 | // an _Any_data structure. |
180 | static void |
181 | _M_clone(_Any_data& __dest, const _Any_data& __source, true_type) |
182 | { |
183 | ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>()); |
184 | } |
185 | |
186 | // Clone a function object that is not location-invariant or |
187 | // that cannot fit into an _Any_data structure. |
188 | static void |
189 | _M_clone(_Any_data& __dest, const _Any_data& __source, false_type) |
190 | { |
191 | __dest._M_access<_Functor*>() = |
192 | new _Functor(*__source._M_access<_Functor*>()); |
193 | } |
194 | |
195 | // Destroying a location-invariant object may still require |
196 | // destruction. |
197 | static void |
198 | _M_destroy(_Any_data& __victim, true_type) |
199 | { |
200 | __victim._M_access<_Functor>().~_Functor(); |
201 | } |
202 | |
203 | // Destroying an object located on the heap. |
204 | static void |
205 | _M_destroy(_Any_data& __victim, false_type) |
206 | { |
207 | delete __victim._M_access<_Functor*>(); |
208 | } |
209 | |
210 | public: |
211 | static bool |
212 | _M_manager(_Any_data& __dest, const _Any_data& __source, |
213 | _Manager_operation __op) |
214 | { |
215 | switch (__op) |
216 | { |
217 | #if __cpp_rtti199711 |
218 | case __get_type_info: |
219 | __dest._M_access<const type_info*>() = &typeid(_Functor); |
220 | break; |
221 | #endif |
222 | case __get_functor_ptr: |
223 | __dest._M_access<_Functor*>() = _M_get_pointer(__source); |
224 | break; |
225 | |
226 | case __clone_functor: |
227 | _M_clone(__dest, __source, _Local_storage()); |
228 | break; |
229 | |
230 | case __destroy_functor: |
231 | _M_destroy(__dest, _Local_storage()); |
232 | break; |
233 | } |
234 | return false; |
235 | } |
236 | |
237 | static void |
238 | _M_init_functor(_Any_data& __functor, _Functor&& __f) |
239 | { _M_init_functor(__functor, std::move(__f), _Local_storage()); } |
240 | |
241 | template<typename _Signature> |
242 | static bool |
243 | _M_not_empty_function(const function<_Signature>& __f) |
244 | { return static_cast<bool>(__f); } |
245 | |
246 | template<typename _Tp> |
247 | static bool |
248 | _M_not_empty_function(_Tp* __fp) |
249 | { return __fp != nullptr; } |
250 | |
251 | template<typename _Class, typename _Tp> |
252 | static bool |
253 | _M_not_empty_function(_Tp _Class::* __mp) |
254 | { return __mp != nullptr; } |
255 | |
256 | template<typename _Tp> |
257 | static bool |
258 | _M_not_empty_function(const _Tp&) |
259 | { return true; } |
260 | |
261 | private: |
262 | static void |
263 | _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type) |
264 | { ::new (__functor._M_access()) _Functor(std::move(__f)); } |
265 | |
266 | static void |
267 | _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type) |
268 | { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); } |
269 | }; |
270 | |
271 | _Function_base() : _M_manager(nullptr) { } |
272 | |
273 | ~_Function_base() |
274 | { |
275 | if (_M_manager) |
276 | _M_manager(_M_functor, _M_functor, __destroy_functor); |
277 | } |
278 | |
279 | bool _M_empty() const { return !_M_manager; } |
280 | |
281 | typedef bool (*_Manager_type)(_Any_data&, const _Any_data&, |
282 | _Manager_operation); |
283 | |
284 | _Any_data _M_functor; |
285 | _Manager_type _M_manager; |
286 | }; |
287 | |
288 | template<typename _Signature, typename _Functor> |
289 | class _Function_handler; |
290 | |
291 | template<typename _Res, typename _Functor, typename... _ArgTypes> |
292 | class _Function_handler<_Res(_ArgTypes...), _Functor> |
293 | : public _Function_base::_Base_manager<_Functor> |
294 | { |
295 | typedef _Function_base::_Base_manager<_Functor> _Base; |
296 | |
297 | public: |
298 | static _Res |
299 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
300 | { |
301 | return (*_Base::_M_get_pointer(__functor))( |
302 | std::forward<_ArgTypes>(__args)...); |
303 | } |
304 | }; |
305 | |
306 | template<typename _Functor, typename... _ArgTypes> |
307 | class _Function_handler<void(_ArgTypes...), _Functor> |
308 | : public _Function_base::_Base_manager<_Functor> |
309 | { |
310 | typedef _Function_base::_Base_manager<_Functor> _Base; |
311 | |
312 | public: |
313 | static void |
314 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
315 | { |
316 | (*_Base::_M_get_pointer(__functor))( |
317 | std::forward<_ArgTypes>(__args)...); |
318 | } |
319 | }; |
320 | |
321 | template<typename _Class, typename _Member, typename _Res, |
322 | typename... _ArgTypes> |
323 | class _Function_handler<_Res(_ArgTypes...), _Member _Class::*> |
324 | : public _Function_handler<void(_ArgTypes...), _Member _Class::*> |
325 | { |
326 | typedef _Function_handler<void(_ArgTypes...), _Member _Class::*> |
327 | _Base; |
328 | |
329 | public: |
330 | static _Res |
331 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
332 | { |
333 | return std::__invoke(_Base::_M_get_pointer(__functor)->__value, |
334 | std::forward<_ArgTypes>(__args)...); |
335 | } |
336 | }; |
337 | |
338 | template<typename _Class, typename _Member, typename... _ArgTypes> |
339 | class _Function_handler<void(_ArgTypes...), _Member _Class::*> |
340 | : public _Function_base::_Base_manager< |
341 | _Simple_type_wrapper< _Member _Class::* > > |
342 | { |
343 | typedef _Member _Class::* _Functor; |
344 | typedef _Simple_type_wrapper<_Functor> _Wrapper; |
345 | typedef _Function_base::_Base_manager<_Wrapper> _Base; |
346 | |
347 | public: |
348 | static bool |
349 | _M_manager(_Any_data& __dest, const _Any_data& __source, |
350 | _Manager_operation __op) |
351 | { |
352 | switch (__op) |
353 | { |
354 | #if __cpp_rtti199711 |
355 | case __get_type_info: |
356 | __dest._M_access<const type_info*>() = &typeid(_Functor); |
357 | break; |
358 | #endif |
359 | case __get_functor_ptr: |
360 | __dest._M_access<_Functor*>() = |
361 | &_Base::_M_get_pointer(__source)->__value; |
362 | break; |
363 | |
364 | default: |
365 | _Base::_M_manager(__dest, __source, __op); |
366 | } |
367 | return false; |
368 | } |
369 | |
370 | static void |
371 | _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) |
372 | { |
373 | std::__invoke(_Base::_M_get_pointer(__functor)->__value, |
374 | std::forward<_ArgTypes>(__args)...); |
375 | } |
376 | }; |
377 | |
378 | template<typename _From, typename _To> |
379 | using __check_func_return_type |
380 | = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>; |
381 | |
382 | /** |
383 | * @brief Primary class template for std::function. |
384 | * @ingroup functors |
385 | * |
386 | * Polymorphic function wrapper. |
387 | */ |
388 | template<typename _Res, typename... _ArgTypes> |
389 | class function<_Res(_ArgTypes...)> |
390 | : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, |
391 | private _Function_base |
392 | { |
393 | template<typename _Func, |
394 | typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type> |
395 | struct _Callable : __check_func_return_type<_Res2, _Res> { }; |
396 | |
397 | // Used so the return type convertibility checks aren't done when |
398 | // performing overload resolution for copy construction/assignment. |
399 | template<typename _Tp> |
400 | struct _Callable<function, _Tp> : false_type { }; |
401 | |
402 | template<typename _Cond, typename _Tp> |
403 | using _Requires = typename enable_if<_Cond::value, _Tp>::type; |
404 | |
405 | public: |
406 | typedef _Res result_type; |
407 | |
408 | // [3.7.2.1] construct/copy/destroy |
409 | |
410 | /** |
411 | * @brief Default construct creates an empty function call wrapper. |
412 | * @post @c !(bool)*this |
413 | */ |
414 | function() noexcept |
415 | : _Function_base() { } |
416 | |
417 | /** |
418 | * @brief Creates an empty function call wrapper. |
419 | * @post @c !(bool)*this |
420 | */ |
421 | function(nullptr_t) noexcept |
422 | : _Function_base() { } |
423 | |
424 | /** |
425 | * @brief %Function copy constructor. |
426 | * @param __x A %function object with identical call signature. |
427 | * @post @c bool(*this) == bool(__x) |
428 | * |
429 | * The newly-created %function contains a copy of the target of @a |
430 | * __x (if it has one). |
431 | */ |
432 | function(const function& __x); |
433 | |
434 | /** |
435 | * @brief %Function move constructor. |
436 | * @param __x A %function object rvalue with identical call signature. |
437 | * |
438 | * The newly-created %function contains the target of @a __x |
439 | * (if it has one). |
440 | */ |
441 | function(function&& __x) noexcept : _Function_base() |
442 | { |
443 | __x.swap(*this); |
444 | } |
445 | |
446 | /** |
447 | * @brief Builds a %function that targets a copy of the incoming |
448 | * function object. |
449 | * @param __f A %function object that is callable with parameters of |
450 | * type @c T1, @c T2, ..., @c TN and returns a value convertible |
451 | * to @c Res. |
452 | * |
453 | * The newly-created %function object will target a copy of |
454 | * @a __f. If @a __f is @c reference_wrapper<F>, then this function |
455 | * object will contain a reference to the function object @c |
456 | * __f.get(). If @a __f is a NULL function pointer or NULL |
457 | * pointer-to-member, the newly-created object will be empty. |
458 | * |
459 | * If @a __f is a non-NULL function pointer or an object of type @c |
460 | * reference_wrapper<F>, this function will not throw. |
461 | */ |
462 | template<typename _Functor, |
463 | typename = _Requires<__not_<is_same<_Functor, function>>, void>, |
464 | typename = _Requires<_Callable<_Functor>, void>> |
465 | function(_Functor); |
466 | |
467 | /** |
468 | * @brief %Function assignment operator. |
469 | * @param __x A %function with identical call signature. |
470 | * @post @c (bool)*this == (bool)x |
471 | * @returns @c *this |
472 | * |
473 | * The target of @a __x is copied to @c *this. If @a __x has no |
474 | * target, then @c *this will be empty. |
475 | * |
476 | * If @a __x targets a function pointer or a reference to a function |
477 | * object, then this operation will not throw an %exception. |
478 | */ |
479 | function& |
480 | operator=(const function& __x) |
481 | { |
482 | function(__x).swap(*this); |
483 | return *this; |
484 | } |
485 | |
486 | /** |
487 | * @brief %Function move-assignment operator. |
488 | * @param __x A %function rvalue with identical call signature. |
489 | * @returns @c *this |
490 | * |
491 | * The target of @a __x is moved to @c *this. If @a __x has no |
492 | * target, then @c *this will be empty. |
493 | * |
494 | * If @a __x targets a function pointer or a reference to a function |
495 | * object, then this operation will not throw an %exception. |
496 | */ |
497 | function& |
498 | operator=(function&& __x) noexcept |
499 | { |
500 | function(std::move(__x)).swap(*this); |
501 | return *this; |
502 | } |
503 | |
504 | /** |
505 | * @brief %Function assignment to zero. |
506 | * @post @c !(bool)*this |
507 | * @returns @c *this |
508 | * |
509 | * The target of @c *this is deallocated, leaving it empty. |
510 | */ |
511 | function& |
512 | operator=(nullptr_t) noexcept |
513 | { |
514 | if (_M_manager) |
515 | { |
516 | _M_manager(_M_functor, _M_functor, __destroy_functor); |
517 | _M_manager = nullptr; |
518 | _M_invoker = nullptr; |
519 | } |
520 | return *this; |
521 | } |
522 | |
523 | /** |
524 | * @brief %Function assignment to a new target. |
525 | * @param __f A %function object that is callable with parameters of |
526 | * type @c T1, @c T2, ..., @c TN and returns a value convertible |
527 | * to @c Res. |
528 | * @return @c *this |
529 | * |
530 | * This %function object wrapper will target a copy of @a |
531 | * __f. If @a __f is @c reference_wrapper<F>, then this function |
532 | * object will contain a reference to the function object @c |
533 | * __f.get(). If @a __f is a NULL function pointer or NULL |
534 | * pointer-to-member, @c this object will be empty. |
535 | * |
536 | * If @a __f is a non-NULL function pointer or an object of type @c |
537 | * reference_wrapper<F>, this function will not throw. |
538 | */ |
539 | template<typename _Functor> |
540 | _Requires<_Callable<typename decay<_Functor>::type>, function&> |
541 | operator=(_Functor&& __f) |
542 | { |
543 | function(std::forward<_Functor>(__f)).swap(*this); |
544 | return *this; |
545 | } |
546 | |
547 | /// @overload |
548 | template<typename _Functor> |
549 | function& |
550 | operator=(reference_wrapper<_Functor> __f) noexcept |
551 | { |
552 | function(__f).swap(*this); |
553 | return *this; |
554 | } |
555 | |
556 | // [3.7.2.2] function modifiers |
557 | |
558 | /** |
559 | * @brief Swap the targets of two %function objects. |
560 | * @param __x A %function with identical call signature. |
561 | * |
562 | * Swap the targets of @c this function object and @a __f. This |
563 | * function will not throw an %exception. |
564 | */ |
565 | void swap(function& __x) noexcept |
566 | { |
567 | std::swap(_M_functor, __x._M_functor); |
568 | std::swap(_M_manager, __x._M_manager); |
569 | std::swap(_M_invoker, __x._M_invoker); |
570 | } |
571 | |
572 | // [3.7.2.3] function capacity |
573 | |
574 | /** |
575 | * @brief Determine if the %function wrapper has a target. |
576 | * |
577 | * @return @c true when this %function object contains a target, |
578 | * or @c false when it is empty. |
579 | * |
580 | * This function will not throw an %exception. |
581 | */ |
582 | explicit operator bool() const noexcept |
583 | { return !_M_empty(); } |
584 | |
585 | // [3.7.2.4] function invocation |
586 | |
587 | /** |
588 | * @brief Invokes the function targeted by @c *this. |
589 | * @returns the result of the target. |
590 | * @throws bad_function_call when @c !(bool)*this |
591 | * |
592 | * The function call operator invokes the target function object |
593 | * stored by @c this. |
594 | */ |
595 | _Res operator()(_ArgTypes... __args) const; |
596 | |
597 | #if __cpp_rtti199711 |
598 | // [3.7.2.5] function target access |
599 | /** |
600 | * @brief Determine the type of the target of this function object |
601 | * wrapper. |
602 | * |
603 | * @returns the type identifier of the target function object, or |
604 | * @c typeid(void) if @c !(bool)*this. |
605 | * |
606 | * This function will not throw an %exception. |
607 | */ |
608 | const type_info& target_type() const noexcept; |
609 | |
610 | /** |
611 | * @brief Access the stored target function object. |
612 | * |
613 | * @return Returns a pointer to the stored target function object, |
614 | * if @c typeid(_Functor).equals(target_type()); otherwise, a NULL |
615 | * pointer. |
616 | * |
617 | * This function does not throw exceptions. |
618 | * |
619 | * @{ |
620 | */ |
621 | template<typename _Functor> _Functor* target() noexcept; |
622 | |
623 | template<typename _Functor> const _Functor* target() const noexcept; |
624 | // @} |
625 | #endif |
626 | |
627 | private: |
628 | using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); |
629 | _Invoker_type _M_invoker; |
630 | }; |
631 | |
632 | #if __cpp_deduction_guides >= 201606 |
633 | template<typename> |
634 | struct __function_guide_helper |
635 | { }; |
636 | |
637 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
638 | struct __function_guide_helper< |
639 | _Res (_Tp::*) (_Args...) noexcept(_Nx) |
640 | > |
641 | { using type = _Res(_Args...); }; |
642 | |
643 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
644 | struct __function_guide_helper< |
645 | _Res (_Tp::*) (_Args...) & noexcept(_Nx) |
646 | > |
647 | { using type = _Res(_Args...); }; |
648 | |
649 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
650 | struct __function_guide_helper< |
651 | _Res (_Tp::*) (_Args...) const noexcept(_Nx) |
652 | > |
653 | { using type = _Res(_Args...); }; |
654 | |
655 | template<typename _Res, typename _Tp, bool _Nx, typename... _Args> |
656 | struct __function_guide_helper< |
657 | _Res (_Tp::*) (_Args...) const & noexcept(_Nx) |
658 | > |
659 | { using type = _Res(_Args...); }; |
660 | |
661 | template<typename _Res, typename... _ArgTypes> |
662 | function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; |
663 | |
664 | template<typename _Functor, typename _Signature = typename |
665 | __function_guide_helper<decltype(&_Functor::operator())>::type> |
666 | function(_Functor) -> function<_Signature>; |
667 | #endif |
668 | |
669 | // Out-of-line member definitions. |
670 | template<typename _Res, typename... _ArgTypes> |
671 | function<_Res(_ArgTypes...)>:: |
672 | function(const function& __x) |
673 | : _Function_base() |
674 | { |
675 | if (static_cast<bool>(__x)) |
676 | { |
677 | __x._M_manager(_M_functor, __x._M_functor, __clone_functor); |
678 | _M_invoker = __x._M_invoker; |
679 | _M_manager = __x._M_manager; |
680 | } |
681 | } |
682 | |
683 | template<typename _Res, typename... _ArgTypes> |
684 | template<typename _Functor, typename, typename> |
685 | function<_Res(_ArgTypes...)>:: |
686 | function(_Functor __f) |
687 | : _Function_base() |
688 | { |
689 | typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler; |
690 | |
691 | if (_My_handler::_M_not_empty_function(__f)) |
692 | { |
693 | _My_handler::_M_init_functor(_M_functor, std::move(__f)); |
694 | _M_invoker = &_My_handler::_M_invoke; |
695 | _M_manager = &_My_handler::_M_manager; |
696 | } |
697 | } |
698 | |
699 | template<typename _Res, typename... _ArgTypes> |
700 | _Res |
701 | function<_Res(_ArgTypes...)>:: |
702 | operator()(_ArgTypes... __args) const |
703 | { |
704 | if (_M_empty()) |
705 | __throw_bad_function_call(); |
706 | return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); |
707 | } |
708 | |
709 | #if __cpp_rtti199711 |
710 | template<typename _Res, typename... _ArgTypes> |
711 | const type_info& |
712 | function<_Res(_ArgTypes...)>:: |
713 | target_type() const noexcept |
714 | { |
715 | if (_M_manager) |
716 | { |
717 | _Any_data __typeinfo_result; |
718 | _M_manager(__typeinfo_result, _M_functor, __get_type_info); |
719 | return *__typeinfo_result._M_access<const type_info*>(); |
720 | } |
721 | else |
722 | return typeid(void); |
723 | } |
724 | |
725 | template<typename _Res, typename... _ArgTypes> |
726 | template<typename _Functor> |
727 | _Functor* |
728 | function<_Res(_ArgTypes...)>:: |
729 | target() noexcept |
730 | { |
731 | const function* __const_this = this; |
732 | const _Functor* __func = __const_this->template target<_Functor>(); |
733 | return const_cast<_Functor*>(__func); |
734 | } |
735 | |
736 | template<typename _Res, typename... _ArgTypes> |
737 | template<typename _Functor> |
738 | const _Functor* |
739 | function<_Res(_ArgTypes...)>:: |
740 | target() const noexcept |
741 | { |
742 | if (typeid(_Functor) == target_type() && _M_manager) |
743 | { |
744 | _Any_data __ptr; |
745 | _M_manager(__ptr, _M_functor, __get_functor_ptr); |
746 | return __ptr._M_access<const _Functor*>(); |
747 | } |
748 | else |
749 | return nullptr; |
750 | } |
751 | #endif |
752 | |
753 | // [20.7.15.2.6] null pointer comparisons |
754 | |
755 | /** |
756 | * @brief Compares a polymorphic function object wrapper against 0 |
757 | * (the NULL pointer). |
758 | * @returns @c true if the wrapper has no target, @c false otherwise |
759 | * |
760 | * This function will not throw an %exception. |
761 | */ |
762 | template<typename _Res, typename... _Args> |
763 | inline bool |
764 | operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept |
765 | { return !static_cast<bool>(__f); } |
766 | |
767 | /// @overload |
768 | template<typename _Res, typename... _Args> |
769 | inline bool |
770 | operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept |
771 | { return !static_cast<bool>(__f); } |
772 | |
773 | /** |
774 | * @brief Compares a polymorphic function object wrapper against 0 |
775 | * (the NULL pointer). |
776 | * @returns @c false if the wrapper has no target, @c true otherwise |
777 | * |
778 | * This function will not throw an %exception. |
779 | */ |
780 | template<typename _Res, typename... _Args> |
781 | inline bool |
782 | operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept |
783 | { return static_cast<bool>(__f); } |
784 | |
785 | /// @overload |
786 | template<typename _Res, typename... _Args> |
787 | inline bool |
788 | operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept |
789 | { return static_cast<bool>(__f); } |
790 | |
791 | |
792 | // [20.7.15.2.7] specialized algorithms |
793 | |
794 | /** |
795 | * @brief Swap the targets of two polymorphic function object wrappers. |
796 | * |
797 | * This function will not throw an %exception. |
798 | */ |
799 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |
800 | // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps |
801 | template<typename _Res, typename... _Args> |
802 | inline void |
803 | swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept |
804 | { __x.swap(__y); } |
805 | |
806 | _GLIBCXX_END_NAMESPACE_VERSION |
807 | } // namespace std |
808 | |
809 | #endif // C++11 |
810 | |
811 | #endif // _GLIBCXX_STD_FUNCTION_H |