tesla::FieldReferenceInstrumenter Class Reference

Detailed Description

Converts calls to TESLA pseudo-assertions into instrumentation sites.

Definition at line 52 of file FieldReference.h.

#include "FieldReference.h"

Inheritance diagram for tesla::FieldReferenceInstrumenter:

Collaboration diagram for tesla::FieldReferenceInstrumenter:

Public Member Functions
	FieldReferenceInstrumenter (const Manifest &M, bool SuppressDI)
const char *	getPassName () const
	~FieldReferenceInstrumenter ()
virtual bool	runOnModule (llvm::Module &M)
Public Member Functions inherited from tesla::Instrumenter
	Instrumenter (const Manifest &M, bool SuppressDI)
virtual	~Instrumenter ()

Static Public Attributes
static char	ID = 0

Additional Inherited Members
Protected Attributes inherited from tesla::Instrumenter
const Manifest &	M
	TESLA manifest that describes automata. More...
const bool	SuppressDebugInstr
	Don't produce debug instrumentation (e.g., printf() statements). More...

Constructor & Destructor Documentation

tesla::FieldReferenceInstrumenter::FieldReferenceInstrumenter ( const Manifest &  M, bool  SuppressDI  )

inline

Definition at line 56 of file FieldReference.h.

    : Instrumenter(M, SuppressDI), ModulePass(ID) {}

tesla::FieldReferenceInstrumenter::~FieldReferenceInstrumenter

(

)

Definition at line 91 of file FieldReference.cpp.

                                                        {
  for (auto& i : Instrumentation)
    delete i.second;
}

Member Function Documentation

const char* tesla::FieldReferenceInstrumenter::getPassName ( ) const

inline

Definition at line 58 of file FieldReference.h.

{ return "field reference instrumenter"; }

bool tesla::FieldReferenceInstrumenter::runOnModule ( llvm::Module &  M )

virtual

Definition at line 97 of file FieldReference.cpp.

References tesla::Cast(), tesla::FieldAnnotation::completeFieldName(), tesla::debug, tesla::LLVM_PTR_ANNOTATION, and tesla::panic().

                                                        {
  debug
    << "===================================================================\n"
    << __PRETTY_FUNCTION__ << "\n"
    << "-------------------------------------------------------------------\n"
    << "module:                    " << Mod.getModuleIdentifier() << "\n";

  this->Mod = &Mod;

  //
  // First, find all struct fields that we want to instrument.
  //
  for (auto *Root : M.RootAutomata())
    BuildInstrumentation(*M.FindAutomaton(Root->identifier()));

  debug << "instrumentation:\n";
  for (auto& i : Instrumentation) {
    debug << "  " << i.getKey() << " -> ";
    i.getValue()->getTarget()->getType()->print(debug);
    debug << "\n";
  }

  debug
    << "-------------------------------------------------------------------\n"
    << "looking for field references...\n"
    ;

  //
  // Then, iterate through all uses of the LLVM pointer annotation and look
  // for structure accesses.
  //
  std::map<LoadInst*,FieldInstrumentation*> Loads;
  std::map<StoreInst*,FieldInstrumentation*> Stores;

  //
  // Look through all of the functions that start with llvm.ptr.annotation.
  //
  for (Function& Fn : Mod.getFunctionList()) {
    if (!Fn.getName().startswith(LLVM_PTR_ANNOTATION))
      continue;

    for (auto i = Fn.use_begin(); i != Fn.use_end(); i++) {
      // We should be able to do some parsing of all annotations.
      OwningPtr<PtrAnnotation> A(PtrAnnotation::Interpret(*i));
      assert(A);

      // We only care about struct field annotations; ignore everything else.
      auto *Annotation = dyn_cast<FieldAnnotation>(A.get());
      if (!Annotation)
        continue;

      // Not every struct field will have instrumentation defined for it.
      auto Name = Annotation->completeFieldName();
      auto *Instr = Instrumentation[Name];
      if (Instr == NULL)
        continue;

      for (User *U : *Annotation) {
        auto *Cast = dyn_cast<CastInst>(U);
        if (!Cast) {
          U->dump();
          panic("annotation user not a bitcast", false);
        }

        for (auto k = Cast->use_begin(); k != Cast->use_end(); k++) {
          if (auto *Load = dyn_cast<LoadInst>(*k))
            Loads.insert(std::make_pair(Load, Instr));

          else if (auto *Store = dyn_cast<StoreInst>(*k))
            Stores.insert(std::make_pair(Store, Instr));

          else {
            k->dump();
            panic("expected load or store with annotated value", false);
          }
        }
      }
    }
  }

  for (auto i : Loads)
    InstrumentLoad(i.first, i.second);

  for (auto i : Stores)
    InstrumentStore(i.first, i.second);

  return true;
}

Here is the call graph for this function:

Member Data Documentation

char tesla::FieldReferenceInstrumenter::ID = 0

static

Definition at line 55 of file FieldReference.h.

---

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

• tesla/instrumenter/FieldReference.h
• tesla/instrumenter/FieldReference.cpp