Orc/Shared/PerfSharedStructs.h

0001 //===--- PerfSharedStructs.h --- RPC Structs for perf support ---*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008 //
0009 // Structs and serialization to share perf-related information
0010 //
0011 //===----------------------------------------------------------------------===//
0012
0013 #ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_PERFSHAREDSTRUCTS_H
0014 #define LLVM_EXECUTIONENGINE_ORC_SHARED_PERFSHAREDSTRUCTS_H
0015
0016 #include "llvm/ExecutionEngine/Orc/Shared/SimplePackedSerialization.h"
0017
0018 namespace llvm {
0019
0020 namespace orc {
0021
0022 // The following are POD struct definitions from the perf jit specification
0023
0024 enum class PerfJITRecordType {
0025   JIT_CODE_LOAD = 0,
0026   JIT_CODE_MOVE = 1, // not emitted, code isn't moved
0027   JIT_CODE_DEBUG_INFO = 2,
0028   JIT_CODE_CLOSE = 3,          // not emitted, unnecessary
0029   JIT_CODE_UNWINDING_INFO = 4, // not emitted
0030
0031   JIT_CODE_MAX
0032 };
0033
0034 struct PerfJITRecordPrefix {
0035   PerfJITRecordType Id; // record type identifier, uint32_t
0036   uint32_t TotalSize;
0037 };
0038 struct PerfJITCodeLoadRecord {
0039   PerfJITRecordPrefix Prefix;
0040
0041   uint32_t Pid;
0042   uint32_t Tid;
0043   uint64_t Vma;
0044   uint64_t CodeAddr;
0045   uint64_t CodeSize;
0046   uint64_t CodeIndex;
0047   std::string Name;
0048 };
0049
0050 struct PerfJITDebugEntry {
0051   uint64_t Addr;
0052   uint32_t Lineno;  // source line number starting at 1
0053   uint32_t Discrim; // column discriminator, 0 is default
0054   std::string Name;
0055 };
0056
0057 struct PerfJITDebugInfoRecord {
0058   PerfJITRecordPrefix Prefix;
0059
0060   uint64_t CodeAddr;
0061   std::vector<PerfJITDebugEntry> Entries;
0062 };
0063
0064 struct PerfJITCodeUnwindingInfoRecord {
0065   PerfJITRecordPrefix Prefix;
0066
0067   uint64_t UnwindDataSize;
0068   uint64_t EHFrameHdrSize;
0069   uint64_t MappedSize;
0070   // Union, one will always be 0/"", the other has data
0071   uint64_t EHFrameHdrAddr;
0072   std::string EHFrameHdr;
0073
0074   uint64_t EHFrameAddr;
0075   // size is UnwindDataSize - EHFrameHdrSize
0076 };
0077
0078 // Batch vehicle for minimizing RPC calls for perf jit records
0079 struct PerfJITRecordBatch {
0080   std::vector<PerfJITDebugInfoRecord> DebugInfoRecords;
0081   std::vector<PerfJITCodeLoadRecord> CodeLoadRecords;
0082   // only valid if record size > 0
0083   PerfJITCodeUnwindingInfoRecord UnwindingRecord;
0084 };
0085
0086 // SPS traits for Records
0087
0088 namespace shared {
0089
0090 using SPSPerfJITRecordPrefix = SPSTuple<uint32_t, uint32_t>;
0091
0092 template <>
0093 class SPSSerializationTraits<SPSPerfJITRecordPrefix, PerfJITRecordPrefix> {
0094 public:
0095   static size_t size(const PerfJITRecordPrefix &Val) {
0096     return SPSPerfJITRecordPrefix::AsArgList::size(
0097         static_cast<uint32_t>(Val.Id), Val.TotalSize);
0098   }
0099   static bool deserialize(SPSInputBuffer &IB, PerfJITRecordPrefix &Val) {
0100     uint32_t Id;
0101     if (!SPSPerfJITRecordPrefix::AsArgList::deserialize(IB, Id, Val.TotalSize))
0102       return false;
0103     Val.Id = static_cast<PerfJITRecordType>(Id);
0104     return true;
0105   }
0106   static bool serialize(SPSOutputBuffer &OB, const PerfJITRecordPrefix &Val) {
0107     return SPSPerfJITRecordPrefix::AsArgList::serialize(
0108         OB, static_cast<uint32_t>(Val.Id), Val.TotalSize);
0109   }
0110 };
0111
0112 using SPSPerfJITCodeLoadRecord =
0113     SPSTuple<SPSPerfJITRecordPrefix, uint32_t, uint32_t, uint64_t, uint64_t,
0114              uint64_t, uint64_t, SPSString>;
0115
0116 template <>
0117 class SPSSerializationTraits<SPSPerfJITCodeLoadRecord, PerfJITCodeLoadRecord> {
0118 public:
0119   static size_t size(const PerfJITCodeLoadRecord &Val) {
0120     return SPSPerfJITCodeLoadRecord::AsArgList::size(
0121         Val.Prefix, Val.Pid, Val.Tid, Val.Vma, Val.CodeAddr, Val.CodeSize,
0122         Val.CodeIndex, Val.Name);
0123   }
0124
0125   static bool deserialize(SPSInputBuffer &IB, PerfJITCodeLoadRecord &Val) {
0126     return SPSPerfJITCodeLoadRecord::AsArgList::deserialize(
0127         IB, Val.Prefix, Val.Pid, Val.Tid, Val.Vma, Val.CodeAddr, Val.CodeSize,
0128         Val.CodeIndex, Val.Name);
0129   }
0130
0131   static bool serialize(SPSOutputBuffer &OB, const PerfJITCodeLoadRecord &Val) {
0132     return SPSPerfJITCodeLoadRecord::AsArgList::serialize(
0133         OB, Val.Prefix, Val.Pid, Val.Tid, Val.Vma, Val.CodeAddr, Val.CodeSize,
0134         Val.CodeIndex, Val.Name);
0135   }
0136 };
0137
0138 using SPSPerfJITDebugEntry = SPSTuple<uint64_t, uint32_t, uint32_t, SPSString>;
0139
0140 template <>
0141 class SPSSerializationTraits<SPSPerfJITDebugEntry, PerfJITDebugEntry> {
0142 public:
0143   static size_t size(const PerfJITDebugEntry &Val) {
0144     return SPSPerfJITDebugEntry::AsArgList::size(Val.Addr, Val.Lineno,
0145                                                  Val.Discrim, Val.Name);
0146   }
0147
0148   static bool deserialize(SPSInputBuffer &IB, PerfJITDebugEntry &Val) {
0149     return SPSPerfJITDebugEntry::AsArgList::deserialize(
0150         IB, Val.Addr, Val.Lineno, Val.Discrim, Val.Name);
0151   }
0152
0153   static bool serialize(SPSOutputBuffer &OB, const PerfJITDebugEntry &Val) {
0154     return SPSPerfJITDebugEntry::AsArgList::serialize(OB, Val.Addr, Val.Lineno,
0155                                                       Val.Discrim, Val.Name);
0156   }
0157 };
0158
0159 using SPSPerfJITDebugInfoRecord = SPSTuple<SPSPerfJITRecordPrefix, uint64_t,
0160                                            SPSSequence<SPSPerfJITDebugEntry>>;
0161
0162 template <>
0163 class SPSSerializationTraits<SPSPerfJITDebugInfoRecord,
0164                              PerfJITDebugInfoRecord> {
0165 public:
0166   static size_t size(const PerfJITDebugInfoRecord &Val) {
0167     return SPSPerfJITDebugInfoRecord::AsArgList::size(Val.Prefix, Val.CodeAddr,
0168                                                       Val.Entries);
0169   }
0170   static bool deserialize(SPSInputBuffer &IB, PerfJITDebugInfoRecord &Val) {
0171     return SPSPerfJITDebugInfoRecord::AsArgList::deserialize(
0172         IB, Val.Prefix, Val.CodeAddr, Val.Entries);
0173   }
0174   static bool serialize(SPSOutputBuffer &OB,
0175                         const PerfJITDebugInfoRecord &Val) {
0176     return SPSPerfJITDebugInfoRecord::AsArgList::serialize(
0177         OB, Val.Prefix, Val.CodeAddr, Val.Entries);
0178   }
0179 };
0180
0181 using SPSPerfJITCodeUnwindingInfoRecord =
0182     SPSTuple<SPSPerfJITRecordPrefix, uint64_t, uint64_t, uint64_t, uint64_t,
0183              SPSString, uint64_t>;
0184 template <>
0185 class SPSSerializationTraits<SPSPerfJITCodeUnwindingInfoRecord,
0186                              PerfJITCodeUnwindingInfoRecord> {
0187 public:
0188   static size_t size(const PerfJITCodeUnwindingInfoRecord &Val) {
0189     return SPSPerfJITCodeUnwindingInfoRecord::AsArgList::size(
0190         Val.Prefix, Val.UnwindDataSize, Val.EHFrameHdrSize, Val.MappedSize,
0191         Val.EHFrameHdrAddr, Val.EHFrameHdr, Val.EHFrameAddr);
0192   }
0193   static bool deserialize(SPSInputBuffer &IB,
0194                           PerfJITCodeUnwindingInfoRecord &Val) {
0195     return SPSPerfJITCodeUnwindingInfoRecord::AsArgList::deserialize(
0196         IB, Val.Prefix, Val.UnwindDataSize, Val.EHFrameHdrSize, Val.MappedSize,
0197         Val.EHFrameHdrAddr, Val.EHFrameHdr, Val.EHFrameAddr);
0198   }
0199   static bool serialize(SPSOutputBuffer &OB,
0200                         const PerfJITCodeUnwindingInfoRecord &Val) {
0201     return SPSPerfJITCodeUnwindingInfoRecord::AsArgList::serialize(
0202         OB, Val.Prefix, Val.UnwindDataSize, Val.EHFrameHdrSize, Val.MappedSize,
0203         Val.EHFrameHdrAddr, Val.EHFrameHdr, Val.EHFrameAddr);
0204   }
0205 };
0206
0207 using SPSPerfJITRecordBatch = SPSTuple<SPSSequence<SPSPerfJITCodeLoadRecord>,
0208                                        SPSSequence<SPSPerfJITDebugInfoRecord>,
0209                                        SPSPerfJITCodeUnwindingInfoRecord>;
0210 template <>
0211 class SPSSerializationTraits<SPSPerfJITRecordBatch, PerfJITRecordBatch> {
0212 public:
0213   static size_t size(const PerfJITRecordBatch &Val) {
0214     return SPSPerfJITRecordBatch::AsArgList::size(
0215         Val.CodeLoadRecords, Val.DebugInfoRecords, Val.UnwindingRecord);
0216   }
0217   static bool deserialize(SPSInputBuffer &IB, PerfJITRecordBatch &Val) {
0218     return SPSPerfJITRecordBatch::AsArgList::deserialize(
0219         IB, Val.CodeLoadRecords, Val.DebugInfoRecords, Val.UnwindingRecord);
0220   }
0221   static bool serialize(SPSOutputBuffer &OB, const PerfJITRecordBatch &Val) {
0222     return SPSPerfJITRecordBatch::AsArgList::serialize(
0223         OB, Val.CodeLoadRecords, Val.DebugInfoRecords, Val.UnwindingRecord);
0224   }
0225 };
0226
0227 } // namespace shared
0228
0229 } // namespace orc
0230
0231 } // namespace llvm
0232
0233 #endif