1//===--------- ExecutorSymbolDef.h - (Addr, Flags) pair ---------*- C++ -*-===//
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// Represents a defining location for a JIT symbol.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_EXECUTORSYMBOLDEF_H
14#define LLVM_EXECUTIONENGINE_ORC_SHARED_EXECUTORSYMBOLDEF_H
15
16#include "llvm/ExecutionEngine/JITSymbol.h"
17#include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
18#include "llvm/ExecutionEngine/Orc/Shared/SimplePackedSerialization.h"
19
20namespace llvm {
21namespace orc {
22
23/// Represents a defining location for a JIT symbol.
24class ExecutorSymbolDef {
25public:
26 ExecutorSymbolDef() = default;
27 ExecutorSymbolDef(ExecutorAddr Addr, JITSymbolFlags Flags)
28 : Addr(Addr), Flags(Flags) {}
29
30 const ExecutorAddr &getAddress() const { return Addr; }
31
32 const JITSymbolFlags &getFlags() const { return Flags; }
33
34 void setFlags(JITSymbolFlags Flags) { this->Flags = Flags; }
35
36 friend bool operator==(const ExecutorSymbolDef &LHS,
37 const ExecutorSymbolDef &RHS) {
38 return LHS.getAddress() == RHS.getAddress() &&
39 LHS.getFlags() == RHS.getFlags();
40 }
41
42 friend bool operator!=(const ExecutorSymbolDef &LHS,
43 const ExecutorSymbolDef &RHS) {
44 return !(LHS == RHS);
45 }
46
47private:
48 ExecutorAddr Addr;
49 JITSymbolFlags Flags;
50};
51
52namespace shared {
53
54using SPSJITSymbolFlags =
55 SPSTuple<JITSymbolFlags::UnderlyingType, JITSymbolFlags::TargetFlagsType>;
56
57/// SPS serializatior for JITSymbolFlags.
58template <> class SPSSerializationTraits<SPSJITSymbolFlags, JITSymbolFlags> {
59 using FlagsArgList = SPSJITSymbolFlags::AsArgList;
60
61public:
62 static size_t size(const JITSymbolFlags &F) {
63 return FlagsArgList::size(Arg: F.getRawFlagsValue(), Args: F.getTargetFlags());
64 }
65
66 static bool serialize(SPSOutputBuffer &BOB, const JITSymbolFlags &F) {
67 return FlagsArgList::serialize(OB&: BOB, Arg: F.getRawFlagsValue(),
68 Args: F.getTargetFlags());
69 }
70
71 static bool deserialize(SPSInputBuffer &BIB, JITSymbolFlags &F) {
72 JITSymbolFlags::UnderlyingType RawFlags;
73 JITSymbolFlags::TargetFlagsType TargetFlags;
74 if (!FlagsArgList::deserialize(IB&: BIB, Arg&: RawFlags, Args&: TargetFlags))
75 return false;
76 F = JITSymbolFlags{static_cast<JITSymbolFlags::FlagNames>(RawFlags),
77 TargetFlags};
78 return true;
79 }
80};
81
82using SPSExecutorSymbolDef = SPSTuple<SPSExecutorAddr, SPSJITSymbolFlags>;
83
84/// SPS serializatior for ExecutorSymbolDef.
85template <>
86class SPSSerializationTraits<SPSExecutorSymbolDef, ExecutorSymbolDef> {
87 using DefArgList = SPSExecutorSymbolDef::AsArgList;
88
89public:
90 static size_t size(const ExecutorSymbolDef &ESD) {
91 return DefArgList::size(Arg: ESD.getAddress(), Args: ESD.getFlags());
92 }
93
94 static bool serialize(SPSOutputBuffer &BOB, const ExecutorSymbolDef &ESD) {
95 return DefArgList::serialize(OB&: BOB, Arg: ESD.getAddress(), Args: ESD.getFlags());
96 }
97
98 static bool deserialize(SPSInputBuffer &BIB, ExecutorSymbolDef &ESD) {
99 ExecutorAddr Addr;
100 JITSymbolFlags Flags;
101 if (!DefArgList::deserialize(IB&: BIB, Arg&: Addr, Args&: Flags))
102 return false;
103 ESD = ExecutorSymbolDef{Addr, Flags};
104 return true;
105 }
106};
107
108} // End namespace shared.
109} // End namespace orc.
110} // End namespace llvm.
111
112#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_EXECUTORSYMBOLDEF_H
113

source code of llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h