tesla::CalleeInstr Class Reference

Detailed Description

Function instrumentation (callee context).

Definition at line 80 of file Callee.h.

#include "Callee.h"

Inheritance diagram for tesla::CalleeInstr:

Collaboration diagram for tesla::CalleeInstr:

Static Public Member Functions
static CalleeInstr *	Build (llvm::Module &, llvm::Function *Target, FunctionEvent::Direction, bool SuppressDebugInstr)
	Construct an object that can instrument a given function. More...

Additional Inherited Members
Public Member Functions inherited from tesla::FnInstrumentation
void	AppendInstrumentation (const Automaton &, const FunctionEvent &, TEquivalenceClass &)
Protected Member Functions inherited from tesla::FnInstrumentation
	FnInstrumentation (llvm::Module &M, const llvm::Function *TargetFn, llvm::Function *InstrFn, FunctionEvent::Direction Dir)
Protected Attributes inherited from tesla::FnInstrumentation
llvm::Module &	M
	The current module. More...
const llvm::Function *	TargetFn
	The function being instrumented. More...
llvm::Function *	InstrFn
	The instrumentation function. More...
FunctionEvent::Direction	Dir
	Which way we instrument (in or out). More...

Member Function Documentation

CalleeInstr * tesla::CalleeInstr::Build ( llvm::Module &  , llvm::Function *  Target, FunctionEvent::Direction  , bool  SuppressDebugInstr  )

static

Construct an object that can instrument a given function.

Definition at line 111 of file Callee.cpp.

References tesla::FunctionInstrumentation().

                                                         {

  // Find (or create) the instrumentation function.
  // Note: it doesn't yet contain the code to translate events and
  //       dispatch them to tesla_update_state().
  Function *InstrFn = FunctionInstrumentation(M, *Target, Dir,
                                              FunctionEvent::Callee,
                                              SuppressDebugInstr);

  // Record the arguments passed to the instrumented function.
  //
  // LLVM's SSA magic will keep these around for us until we need them, even if
  // C code overwrites its parameters.
  ArgVector Args;
  for (auto &Arg : Target->getArgumentList())
    Args.push_back(&Arg);

  // Instrument either the entry or return points of the target function.
  switch (Dir) {
  case FunctionEvent::Entry: {
    // Instrumenting function entry is easy: just add a new call to
    // instrumentation at the beginning of the function's entry block.
    BasicBlock& Entry = Target->getEntryBlock();
    CallInst::Create(InstrFn, Args)->insertBefore(Entry.getFirstNonPHI());
    break;
  }

  case FunctionEvent::Exit: {
    SmallPtrSet<ReturnInst*, 16> Returns;
    for (auto i = inst_begin(Target), End = inst_end(Target); i != End; i++)
      if (auto *Return = dyn_cast<ReturnInst>(&*i))
        Returns.insert(Return);

    for (ReturnInst *Return : Returns) {
      ArgVector InstrArgs(Args);

      if (Dir == FunctionEvent::Exit && !Target->getReturnType()->isVoidTy())
        InstrArgs.push_back(Return->getReturnValue());

      CallInst::Create(InstrFn, InstrArgs)->insertBefore(Return);
    }
    break;
  }
  }

  return new CalleeInstr(M, Target, InstrFn, Dir);
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• tesla/instrumenter/Callee.h
• tesla/instrumenter/Callee.cpp