tesla::FieldInstrumentation Class Reference

Detailed Description

Instrumentation for a struct field assignment.

Definition at line 61 of file FieldReference.cpp.

Public Member Functions
void	AppendInstrumentation (const Automaton &, const TEquivalenceClass &)
std::string	CompleteFieldName () const
Function *	getTarget () const
	FieldInstrumentation (Function *InstrFn, Module &M, const StructType *T, const StringRef FieldName, size_t FieldIndex)

Constructor & Destructor Documentation

tesla::FieldInstrumentation::FieldInstrumentation ( Function *  InstrFn, Module &  M, const StructType *  T, const StringRef  FieldName, size_t  FieldIndex  )

inline

Definition at line 71 of file FieldReference.cpp.

    : InstrFn(InstrFn), Exit(FindBlock("exit", *InstrFn)), M(M),
      StructTy(T), FieldName(FieldName)
  {
  }

Member Function Documentation

void tesla::FieldInstrumentation::AppendInstrumentation	(	const Automaton &	A,
		const TEquivalenceClass &	Trans
	)

Definition at line 292 of file FieldReference.cpp.

References tesla::ConstructKey(), tesla::ConstructTransitions(), tesla::AutomatonDescription::context, tesla::debug, tesla::FindStateUpdateFn(), tesla::Automaton::getAssertion(), tesla::Automaton::ID(), tesla::Automaton::Name(), tesla::panic(), tesla::Automaton::String(), and tesla::TeslaContext().

                                                        {

  debug << "AppendInstrumentation\n";

  LLVMContext& Ctx = InstrFn->getContext();
  auto *Head = dyn_cast<FieldAssignTransition>(*Trans.begin());
  assert(Head);
  auto& Protobuf = Head->Assignment();

  // The instrumentation function should be passed three parameters:
  // the struct, the new value and a pointer to the field.
  auto& Params = InstrFn->getArgumentList();
  assert(Params.size() == 3);

  auto i = Params.begin();
  llvm::Argument *Struct = &*i++;
  llvm::Argument *NewValue = &*i++;
  llvm::Argument *FieldPtr = &*i++;

  // We will definitely pass the structure's address to tesla_update_state().
  // We may also pass the new value, if it's e.g. a pointer: see below.
  SmallVector<Value*,2> KeyValues;
  KeyValues.push_back(Struct);

  // Insert new instrumention before the current "end" block for the automaton.
  auto *End = NextInstrBlock(&A);
  auto *Instr = BasicBlock::Create(Ctx, Head->ShortLabel(), InstrFn, End);
  End->replaceAllUsesWith(Instr);
  IRBuilder<> Builder(Instr);

  // Are we assigning a constant value (in which case we should try to match
  // it against a protobuf-supplied pattern) or a variable (in which case we
  // should add it to the struct tesla_key)?
  auto& ExpectedAssignment = Protobuf.value();

  switch (ExpectedAssignment.type()) {
  case Argument::Constant: {
    // Match the new value against the expected value or else ignore it.
    IntegerType *ValueType = dyn_cast<IntegerType>(NewValue->getType());
    if (!ValueType)
      panic("NewValue not an integer type");

    auto *Match = BasicBlock::Create(Ctx, "match: " + Head->ShortLabel(),
                                     InstrFn, Instr);
    Instr->replaceAllUsesWith(Match);
    IRBuilder<> Matcher(Match);

    auto *Const = ConstantInt::getSigned(ValueType, ExpectedAssignment.value());
    Value *Expected;

    switch (Protobuf.operation()) {
    case FieldAssignment::SimpleAssign:
      Expected = Const;
      break;

    case FieldAssignment::PlusEqual:
      Expected = Matcher.CreateAdd(Matcher.CreateLoad(FieldPtr), Const);
      break;

    case FieldAssignment::MinusEqual:
      Expected = Matcher.CreateSub(Matcher.CreateLoad(FieldPtr), Const);
      break;
    }

    Matcher.CreateCondBr(Matcher.CreateICmpNE(NewValue, Expected), End, Instr);
    break;
  }

  case Argument::Variable:
    KeyValues.push_back(NewValue);
    break;

  case Argument::Any:
    panic("'ANY' value should never be passed to struct field instrumentation");

  case Argument::Indirect:
    panic("struct field instrumentation should not be passed indirect value");

  case Argument::Field:
    panic("struct field instrumentation should not be passed struct field");
  }

  Type* IntType = Type::getInt32Ty(Ctx);

  std::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, KeyValues));
  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:

std::string tesla::FieldInstrumentation::CompleteFieldName ( ) const

inline

Definition at line 65 of file FieldReference.cpp.

                                      {
    return (StructTy->getName() + "." + FieldName).str();
  }

Function* tesla::FieldInstrumentation::getTarget ( ) const

inline

Definition at line 69 of file FieldReference.cpp.

{ return InstrFn; }

---

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

• tesla/instrumenter/FieldReference.cpp