1 //===- PseudoProbe.h - Pseudo Probe IR Helpers ------------------*- 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 // Pseudo probe IR intrinsic and dwarf discriminator manipulation routines. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_IR_PSEUDOPROBE_H 14 #define LLVM_IR_PSEUDOPROBE_H 15 16 #include "llvm/ADT/Optional.h" 17 #include <cassert> 18 #include <cstdint> 19 #include <limits> 20 21 namespace llvm { 22 23 class Instruction; 24 class BasicBlock; 25 26 constexpr const char *PseudoProbeDescMetadataName = "llvm.pseudo_probe_desc"; 27 28 enum class PseudoProbeType { Block = 0, IndirectCall, DirectCall }; 29 30 enum class PseudoProbeAttributes { 31 Reserved = 0x1, // Reserved for future use. 32 Dangling = 0x2, // The probe is dangling. 33 }; 34 35 // The saturated distrution factor representing 100% for block probes. 36 constexpr static uint64_t PseudoProbeFullDistributionFactor = 37 std::numeric_limits<uint64_t>::max(); 38 39 struct PseudoProbeDwarfDiscriminator { 40 public: 41 // The following APIs encodes/decodes per-probe information to/from a 42 // 32-bit integer which is organized as: 43 // [2:0] - 0x7, this is reserved for regular discriminator, 44 // see DWARF discriminator encoding rule 45 // [18:3] - probe id 46 // [25:19] - probe distribution factor 47 // [28:26] - probe type, see PseudoProbeType 48 // [31:29] - reserved for probe attributes packProbeDataPseudoProbeDwarfDiscriminator49 static uint32_t packProbeData(uint32_t Index, uint32_t Type, uint32_t Flags, 50 uint32_t Factor) { 51 assert(Index <= 0xFFFF && "Probe index too big to encode, exceeding 2^16"); 52 assert(Type <= 0x7 && "Probe type too big to encode, exceeding 7"); 53 assert(Flags <= 0x7); 54 assert(Factor <= 100 && 55 "Probe distribution factor too big to encode, exceeding 100"); 56 return (Index << 3) | (Factor << 19) | (Type << 26) | 0x7; 57 } 58 extractProbeIndexPseudoProbeDwarfDiscriminator59 static uint32_t extractProbeIndex(uint32_t Value) { 60 return (Value >> 3) & 0xFFFF; 61 } 62 extractProbeTypePseudoProbeDwarfDiscriminator63 static uint32_t extractProbeType(uint32_t Value) { 64 return (Value >> 26) & 0x7; 65 } 66 extractProbeAttributesPseudoProbeDwarfDiscriminator67 static uint32_t extractProbeAttributes(uint32_t Value) { 68 return (Value >> 29) & 0x7; 69 } 70 extractProbeFactorPseudoProbeDwarfDiscriminator71 static uint32_t extractProbeFactor(uint32_t Value) { 72 return (Value >> 19) & 0x7F; 73 } 74 75 // The saturated distrution factor representing 100% for callsites. 76 constexpr static uint8_t FullDistributionFactor = 100; 77 }; 78 79 struct PseudoProbe { 80 uint32_t Id; 81 uint32_t Type; 82 uint32_t Attr; 83 // Distribution factor that estimates the portion of the real execution count. 84 // A saturated distribution factor stands for 1.0 or 100%. A pesudo probe has 85 // a factor with the value ranged from 0.0 to 1.0. 86 float Factor; 87 isDanglingPseudoProbe88 bool isDangling() const { 89 return Attr & (uint32_t)PseudoProbeAttributes::Dangling; 90 } 91 }; 92 93 Optional<PseudoProbe> extractProbe(const Instruction &Inst); 94 95 void setProbeDistributionFactor(Instruction &Inst, float Factor); 96 97 bool moveAndDanglePseudoProbes(BasicBlock *From, Instruction *To); 98 99 bool removeRedundantPseudoProbes(BasicBlock *Block); 100 } // end namespace llvm 101 102 #endif // LLVM_IR_PSEUDOPROBE_H 103