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 20 namespace llvm { 21 namespace orc { 22 23 /// Represents a defining location for a JIT symbol. 24 class ExecutorSymbolDef { 25 public: 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 47 private: 48 ExecutorAddr Addr; 49 JITSymbolFlags Flags; 50 }; 51 52 namespace shared { 53 54 using SPSJITSymbolFlags = 55 SPSTuple<JITSymbolFlags::UnderlyingType, JITSymbolFlags::TargetFlagsType>; 56 57 /// SPS serializatior for JITSymbolFlags. 58 template <> class SPSSerializationTraits<SPSJITSymbolFlags, JITSymbolFlags> { 59 using FlagsArgList = SPSJITSymbolFlags::AsArgList; 60 61 public: 62 static size_t size(const JITSymbolFlags &F) { 63 return FlagsArgList::size(F.getRawFlagsValue(), F.getTargetFlags()); 64 } 65 66 static bool serialize(SPSOutputBuffer &BOB, const JITSymbolFlags &F) { 67 return FlagsArgList::serialize(BOB, F.getRawFlagsValue(), 68 F.getTargetFlags()); 69 } 70 71 static bool deserialize(SPSInputBuffer &BIB, JITSymbolFlags &F) { 72 JITSymbolFlags::UnderlyingType RawFlags; 73 JITSymbolFlags::TargetFlagsType TargetFlags; 74 if (!FlagsArgList::deserialize(BIB, RawFlags, TargetFlags)) 75 return false; 76 F = JITSymbolFlags{static_cast<JITSymbolFlags::FlagNames>(RawFlags), 77 TargetFlags}; 78 return true; 79 } 80 }; 81 82 using SPSExecutorSymbolDef = SPSTuple<SPSExecutorAddr, SPSJITSymbolFlags>; 83 84 /// SPS serializatior for ExecutorSymbolDef. 85 template <> 86 class SPSSerializationTraits<SPSExecutorSymbolDef, ExecutorSymbolDef> { 87 using DefArgList = SPSExecutorSymbolDef::AsArgList; 88 89 public: 90 static size_t size(const ExecutorSymbolDef &ESD) { 91 return DefArgList::size(ESD.getAddress(), ESD.getFlags()); 92 } 93 94 static bool serialize(SPSOutputBuffer &BOB, const ExecutorSymbolDef &ESD) { 95 return DefArgList::serialize(BOB, ESD.getAddress(), ESD.getFlags()); 96 } 97 98 static bool deserialize(SPSInputBuffer &BIB, ExecutorSymbolDef &ESD) { 99 ExecutorAddr Addr; 100 JITSymbolFlags Flags; 101 if (!DefArgList::deserialize(BIB, Addr, 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