tesla::FnInstrumentation Class Reference

Detailed Description

Instrumentation for a function event.

Definition at line 64 of file Instrumentation.h.

#include "Instrumentation.h"

Inheritance diagram for tesla::FnInstrumentation:

Collaboration diagram for tesla::FnInstrumentation:

Public Member Functions
void	AppendInstrumentation (const Automaton &, const FunctionEvent &, TEquivalenceClass &)

Protected Member Functions
	FnInstrumentation (llvm::Module &M, const llvm::Function *TargetFn, llvm::Function *InstrFn, FunctionEvent::Direction Dir)

Protected Attributes
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...

Constructor & Destructor Documentation

tesla::FnInstrumentation::FnInstrumentation ( llvm::Module &  M, const llvm::Function *  TargetFn, llvm::Function *  InstrFn, FunctionEvent::Direction  Dir  )

inlineprotected

Definition at line 70 of file Instrumentation.h.

    : M(M), TargetFn(TargetFn), InstrFn(InstrFn), Dir(Dir)
  {
  }

Member Function Documentation

void tesla::FnInstrumentation::AppendInstrumentation	(	const Automaton &	A,
		const FunctionEvent &	Ev,
		TEquivalenceClass &	Trans
	)

Definition at line 74 of file Instrumentation.cpp.

References tesla::FunctionEvent::argument, tesla::ConstructKey(), tesla::ConstructTransitions(), tesla::AutomatonDescription::context, tesla::FunctionEvent::direction, tesla::FindBlock(), tesla::FindStateUpdateFn(), tesla::FunctionEvent::function, tesla::Automaton::getAssertion(), tesla::Automaton::ID(), tesla::MatchPattern(), tesla::Automaton::Name(), tesla::Automaton::String(), and tesla::TeslaContext().

                                                                           {

  LLVMContext& Ctx = TargetFn->getContext();

  auto Fn = Ev.function();
  assert(Fn.name() == TargetFn->getName());
  assert(Ev.direction() == Dir);

  // An instrumentation function should be a linear chain of event pattern
  // matchers and instrumentation blocks. Find the current end of this chain
  // and insert the new instrumentation before it.
  auto *Exit = FindBlock("exit", *InstrFn);
  auto *Instr = BasicBlock::Create(Ctx, A.Name() + ":instr", InstrFn, Exit);
  Exit->replaceAllUsesWith(Instr);

  // We may need to check constant values (e.g. return values).
  size_t i = 0;
  for (auto& InstrArg : InstrFn->getArgumentList()) {
    const Argument& Arg = Ev.argument(i);
    MatchPattern(Ctx, (A.Name() + ":match:arg" + Twine(i)).str(), InstrFn,
                 Instr, Exit, &InstrArg, Arg);

    // Ignore the return value, which passed as an argument to InstrFn.
    if (++i == Ev.argument_size())
      break;
  }

  if (Dir == FunctionEvent::Exit && Ev.has_expectedreturnvalue()) {
    const Argument &Arg = Ev.expectedreturnvalue();
    Value *ReturnValue = --(InstrFn->arg_end());
    MatchPattern(Ctx, A.Name() + ":match:retval", InstrFn,
                 Instr, Exit, ReturnValue, Arg);
  }

  IRBuilder<> Builder(Instr);
  Type* IntType = Type::getInt32Ty(Ctx);

  vector<Value*> Args;
  Args.push_back(TeslaContext(A.getAssertion().context(), Ctx));
  Args.push_back(ConstantInt::get(IntType, A.ID()));
  Args.push_back(ConstructKey(Builder, M, InstrFn->getArgumentList(), Ev));
  Args.push_back(Builder.CreateGlobalStringPtr(A.Name()));
  Args.push_back(Builder.CreateGlobalStringPtr(A.String()));
  Args.push_back(ConstructTransitions(Builder, M, Trans));

  Function *UpdateStateFn = FindStateUpdateFn(M, IntType);
  assert(Args.size() == UpdateStateFn->arg_size());
  Builder.CreateCall(UpdateStateFn, Args);
  Builder.CreateBr(Exit);
}

Here is the call graph for this function:

Member Data Documentation

FunctionEvent::Direction tesla::FnInstrumentation::Dir

protected

Which way we instrument (in or out).

Definition at line 79 of file Instrumentation.h.

llvm::Function* tesla::FnInstrumentation::InstrFn

protected

The instrumentation function.

Definition at line 78 of file Instrumentation.h.

llvm::Module& tesla::FnInstrumentation::M

protected

The current module.

Definition at line 76 of file Instrumentation.h.

const llvm::Function* tesla::FnInstrumentation::TargetFn

protected

The function being instrumented.

Definition at line 77 of file Instrumentation.h.

---

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

• tesla/instrumenter/Instrumentation.h
• tesla/instrumenter/Instrumentation.cpp