compiler-rt/lib/orc/executor_symbol_def.h

   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 symbol in the executing program.
  10 //
  11 // This file was derived from
  12 // llvm/include/llvm/ExecutionEngine/Orc/Shared/ExecutorSymbolDef.h.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef ORC_RT_EXECUTOR_SYMBOL_DEF_H
  17 #define ORC_RT_EXECUTOR_SYMBOL_DEF_H
  18
  19 #include "bitmask_enum.h"
  20 #include "executor_address.h"
  21 #include "simple_packed_serialization.h"
  22
  23 namespace orc_rt {
  24
  25 /// Flags for symbols in the JIT.
  26 class JITSymbolFlags {
  27 public:
  28   using UnderlyingType = uint8_t;
  29   using TargetFlagsType = uint8_t;
  30
  31   /// These values must be kept in sync with \c JITSymbolFlags in the JIT.
  32   enum FlagNames : UnderlyingType {
  33     None = 0,
  34     HasError = 1U << 0,
  35     Weak = 1U << 1,
  36     Common = 1U << 2,
  37     Absolute = 1U << 3,
  38     Exported = 1U << 4,
  39     Callable = 1U << 5,
  40     MaterializationSideEffectsOnly = 1U << 6,
  41     ORC_RT_MARK_AS_BITMASK_ENUM( // LargestValue =
  42         MaterializationSideEffectsOnly)
  43   };
  44
  45   /// Default-construct a JITSymbolFlags instance.
  46   JITSymbolFlags() = default;
  47
  48   /// Construct a JITSymbolFlags instance from the given flags and target
  49   ///        flags.
  50   JITSymbolFlags(FlagNames Flags, TargetFlagsType TargetFlags)
  51       : TargetFlags(TargetFlags), Flags(Flags) {}
  52
  53   bool operator==(const JITSymbolFlags &RHS) const {
  54     return Flags == RHS.Flags && TargetFlags == RHS.TargetFlags;
  55   }
  56
  57   /// Get the underlying flags value as an integer.
  58   UnderlyingType getRawFlagsValue() const {
  59     return static_cast<UnderlyingType>(Flags);
  60   }
  61
  62   /// Return a reference to the target-specific flags.
  63   TargetFlagsType &getTargetFlags() { return TargetFlags; }
  64
  65   /// Return a reference to the target-specific flags.
  66   const TargetFlagsType &getTargetFlags() const { return TargetFlags; }
  67
  68 private:
  69   TargetFlagsType TargetFlags = 0;
  70   FlagNames Flags = None;
  71 };
  72
  73 /// Represents a defining location for a JIT symbol.
  74 class ExecutorSymbolDef {
  75 public:
  76   ExecutorSymbolDef() = default;
  77   ExecutorSymbolDef(ExecutorAddr Addr, JITSymbolFlags Flags)
  78       : Addr(Addr), Flags(Flags) {}
  79
  80   const ExecutorAddr &getAddress() const { return Addr; }
  81
  82   const JITSymbolFlags &getFlags() const { return Flags; }
  83
  84   friend bool operator==(const ExecutorSymbolDef &LHS,
  85                          const ExecutorSymbolDef &RHS) {
  86     return LHS.getAddress() == RHS.getAddress() &&
  87            LHS.getFlags() == RHS.getFlags();
  88   }
  89
  90 private:
  91   ExecutorAddr Addr;
  92   JITSymbolFlags Flags;
  93 };
  94
  95 using SPSJITSymbolFlags =
  96     SPSTuple<JITSymbolFlags::UnderlyingType, JITSymbolFlags::TargetFlagsType>;
  97
  98 /// SPS serializatior for JITSymbolFlags.
  99 template <> class SPSSerializationTraits<SPSJITSymbolFlags, JITSymbolFlags> {
 100   using FlagsArgList = SPSJITSymbolFlags::AsArgList;
 101
 102 public:
 103   static size_t size(const JITSymbolFlags &F) {
 104     return FlagsArgList::size(F.getRawFlagsValue(), F.getTargetFlags());
 105   }
 106
 107   static bool serialize(SPSOutputBuffer &BOB, const JITSymbolFlags &F) {
 108     return FlagsArgList::serialize(BOB, F.getRawFlagsValue(),
 109                                    F.getTargetFlags());
 110   }
 111
 112   static bool deserialize(SPSInputBuffer &BIB, JITSymbolFlags &F) {
 113     JITSymbolFlags::UnderlyingType RawFlags;
 114     JITSymbolFlags::TargetFlagsType TargetFlags;
 115     if (!FlagsArgList::deserialize(BIB, RawFlags, TargetFlags))
 116       return false;
 117     F = JITSymbolFlags{static_cast<JITSymbolFlags::FlagNames>(RawFlags),
 118                        TargetFlags};
 119     return true;
 120   }
 121 };
 122
 123 using SPSExecutorSymbolDef = SPSTuple<SPSExecutorAddr, SPSJITSymbolFlags>;
 124
 125 /// SPS serializatior for ExecutorSymbolDef.
 126 template <>
 127 class SPSSerializationTraits<SPSExecutorSymbolDef, ExecutorSymbolDef> {
 128   using DefArgList = SPSExecutorSymbolDef::AsArgList;
 129
 130 public:
 131   static size_t size(const ExecutorSymbolDef &ESD) {
 132     return DefArgList::size(ESD.getAddress(), ESD.getFlags());
 133   }
 134
 135   static bool serialize(SPSOutputBuffer &BOB, const ExecutorSymbolDef &ESD) {
 136     return DefArgList::serialize(BOB, ESD.getAddress(), ESD.getFlags());
 137   }
 138
 139   static bool deserialize(SPSInputBuffer &BIB, ExecutorSymbolDef &ESD) {
 140     ExecutorAddr Addr;
 141     JITSymbolFlags Flags;
 142     if (!DefArgList::deserialize(BIB, Addr, Flags))
 143       return false;
 144     ESD = ExecutorSymbolDef{Addr, Flags};
 145     return true;
 146   }
 147 };
 148
 149 } // End namespace orc_rt
 150
 151 #endif // ORC_RT_EXECUTOR_SYMBOL_DEF_H