include/llvm/Transforms/Instrumentation.h

   1 //===- Transforms/Instrumentation.h - Instrumentation passes ----*- 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 // This file defines constructor functions for instrumentation passes.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_H
  14 #define LLVM_TRANSFORMS_INSTRUMENTATION_H
  15
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/IR/BasicBlock.h"
  18 #include <cassert>
  19 #include <cstdint>
  20 #include <limits>
  21 #include <string>
  22 #include <vector>
  23
  24 namespace llvm {
  25
  26 class Triple;
  27 class FunctionPass;
  28 class ModulePass;
  29 class OptimizationRemarkEmitter;
  30 class Comdat;
  31
  32 /// Instrumentation passes often insert conditional checks into entry blocks.
  33 /// Call this function before splitting the entry block to move instructions
  34 /// that must remain in the entry block up before the split point. Static
  35 /// allocas and llvm.localescape calls, for example, must remain in the entry
  36 /// block.
  37 BasicBlock::iterator PrepareToSplitEntryBlock(BasicBlock &BB,
  38                                               BasicBlock::iterator IP);
  39
  40 // Create a constant for Str so that we can pass it to the run-time lib.
  41 GlobalVariable *createPrivateGlobalForString(Module &M, StringRef Str,
  42                                              bool AllowMerging,
  43                                              const char *NamePrefix = "");
  44
  45 // Returns F.getComdat() if it exists.
  46 // Otherwise creates a new comdat, sets F's comdat, and returns it.
  47 // Returns nullptr on failure.
  48 Comdat *GetOrCreateFunctionComdat(Function &F, Triple &T,
  49                                   const std::string &ModuleId);
  50
  51 // Insert GCOV profiling instrumentation
  52 struct GCOVOptions {
  53   static GCOVOptions getDefault();
  54
  55   // Specify whether to emit .gcno files.
  56   bool EmitNotes;
  57
  58   // Specify whether to modify the program to emit .gcda files when run.
  59   bool EmitData;
  60
  61   // A four-byte version string. The meaning of a version string is described in
  62   // gcc's gcov-io.h
  63   char Version[4];
  64
  65   // Emit a "cfg checksum" that follows the "line number checksum" of a
  66   // function. This affects both .gcno and .gcda files.
  67   bool UseCfgChecksum;
  68
  69   // Add the 'noredzone' attribute to added runtime library calls.
  70   bool NoRedZone;
  71
  72   // Emit the name of the function in the .gcda files. This is redundant, as
  73   // the function identifier can be used to find the name from the .gcno file.
  74   bool FunctionNamesInData;
  75
  76   // Emit the exit block immediately after the start block, rather than after
  77   // all of the function body's blocks.
  78   bool ExitBlockBeforeBody;
  79
  80   // Regexes separated by a semi-colon to filter the files to instrument.
  81   std::string Filter;
  82
  83   // Regexes separated by a semi-colon to filter the files to not instrument.
  84   std::string Exclude;
  85 };
  86
  87 ModulePass *createGCOVProfilerPass(const GCOVOptions &Options =
  88                                    GCOVOptions::getDefault());
  89
  90 // PGO Instrumention. Parameter IsCS indicates if this is the context senstive
  91 // instrumentation.
  92 ModulePass *createPGOInstrumentationGenLegacyPass(bool IsCS = false);
  93 ModulePass *
  94 createPGOInstrumentationUseLegacyPass(StringRef Filename = StringRef(""),
  95                                       bool IsCS = false);
  96 ModulePass *createPGOInstrumentationGenCreateVarLegacyPass(
  97     StringRef CSInstrName = StringRef(""));
  98 ModulePass *createPGOIndirectCallPromotionLegacyPass(bool InLTO = false,
  99                                                      bool SamplePGO = false);
 100 FunctionPass *createPGOMemOPSizeOptLegacyPass();
 101
 102 // The pgo-specific indirect call promotion function declared below is used by
 103 // the pgo-driven indirect call promotion and sample profile passes. It's a
 104 // wrapper around llvm::promoteCall, et al. that additionally computes !prof
 105 // metadata. We place it in a pgo namespace so it's not confused with the
 106 // generic utilities.
 107 namespace pgo {
 108
 109 // Helper function that transforms Inst (either an indirect-call instruction, or
 110 // an invoke instruction , to a conditional call to F. This is like:
 111 //     if (Inst.CalledValue == F)
 112 //        F(...);
 113 //     else
 114 //        Inst(...);
 115 //     end
 116 // TotalCount is the profile count value that the instruction executes.
 117 // Count is the profile count value that F is the target function.
 118 // These two values are used to update the branch weight.
 119 // If \p AttachProfToDirectCall is true, a prof metadata is attached to the
 120 // new direct call to contain \p Count.
 121 // Returns the promoted direct call instruction.
 122 Instruction *promoteIndirectCall(Instruction *Inst, Function *F, uint64_t Count,
 123                                  uint64_t TotalCount,
 124                                  bool AttachProfToDirectCall,
 125                                  OptimizationRemarkEmitter *ORE);
 126 } // namespace pgo
 127
 128 /// Options for the frontend instrumentation based profiling pass.
 129 struct InstrProfOptions {
 130   // Add the 'noredzone' attribute to added runtime library calls.
 131   bool NoRedZone = false;
 132
 133   // Do counter register promotion
 134   bool DoCounterPromotion = false;
 135
 136   // Use atomic profile counter increments.
 137   bool Atomic = false;
 138
 139   // Use BFI to guide register promotion
 140   bool UseBFIInPromotion = false;
 141
 142   // Name of the profile file to use as output
 143   std::string InstrProfileOutput;
 144
 145   InstrProfOptions() = default;
 146 };
 147
 148 /// Insert frontend instrumentation based profiling. Parameter IsCS indicates if
 149 // this is the context senstive instrumentation.
 150 ModulePass *createInstrProfilingLegacyPass(
 151     const InstrProfOptions &Options = InstrProfOptions(), bool IsCS = false);
 152
 153 ModulePass *createInstrOrderFilePass();
 154
 155 // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation
 156 ModulePass *createDataFlowSanitizerPass(
 157     const std::vector<std::string> &ABIListFiles = std::vector<std::string>(),
 158     void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr);
 159
 160 // Options for sanitizer coverage instrumentation.
 161 struct SanitizerCoverageOptions {
 162   enum Type {
 163     SCK_None = 0,
 164     SCK_Function,
 165     SCK_BB,
 166     SCK_Edge
 167   } CoverageType = SCK_None;
 168   bool IndirectCalls = false;
 169   bool TraceBB = false;
 170   bool TraceCmp = false;
 171   bool TraceDiv = false;
 172   bool TraceGep = false;
 173   bool Use8bitCounters = false;
 174   bool TracePC = false;
 175   bool TracePCGuard = false;
 176   bool Inline8bitCounters = false;
 177   bool PCTable = false;
 178   bool NoPrune = false;
 179   bool StackDepth = false;
 180
 181   SanitizerCoverageOptions() = default;
 182 };
 183
 184 /// Calculate what to divide by to scale counts.
 185 ///
 186 /// Given the maximum count, calculate a divisor that will scale all the
 187 /// weights to strictly less than std::numeric_limits<uint32_t>::max().
 188 static inline uint64_t calculateCountScale(uint64_t MaxCount) {
 189   return MaxCount < std::numeric_limits<uint32_t>::max()
 190              ? 1
 191              : MaxCount / std::numeric_limits<uint32_t>::max() + 1;
 192 }
 193
 194 /// Scale an individual branch count.
 195 ///
 196 /// Scale a 64-bit weight down to 32-bits using \c Scale.
 197 ///
 198 static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) {
 199   uint64_t Scaled = Count / Scale;
 200   assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits");
 201   return Scaled;
 202 }
 203 } // end namespace llvm
 204
 205 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_H