#include <AutomaticIRMetadataGuard.h>

Collaboration diagram for AutomaticIRMetadataGuard:

Classes
struct	InstructionInfo

Public Member Functions
	AutomaticIRMetadataGuard (CgenState *cgen_state, const std::string &ppfile, const size_t ppline, const std::string &ppfunc)

	~AutomaticIRMetadataGuard ()

void	done () noexcept

void	rememberPreexistingInstructions () noexcept

void	rememberOurInstructions () noexcept

void	markInstructions () noexcept

Private Types
using	OurInstructions = std::unordered_map< llvm::Instruction *, InstructionInfo >

Private Member Functions
std::string	makeBaseFilename ()

std::string	makeQueryEngineFilename ()

std::string	replacePunctuation (std::string text)

Private Attributes
CgenState *	cgen_state_

const std::string	ppfile_

const size_t	ppline_

const std::string	ppfunc_

std::unordered_set < llvm::Instruction * >	preexisting_instructions_

OurInstructions *	our_instructions_

bool	done_

bool	this_is_root_

bool	enabled_

Static Private Attributes
static std::unordered_map < CgenState *, OurInstructions >	instructions_

static const std::string	detailed_footnote_prefix_ {"HEAVY.AI Debugging Info: "}

static std::mutex	instructions_mutex_

Detailed Description

Definition at line 31 of file AutomaticIRMetadataGuard.h.

Member Typedef Documentation

using AutomaticIRMetadataGuard::OurInstructions = std::unordered_map<llvm::Instruction*, InstructionInfo>

private

Definition at line 183 of file AutomaticIRMetadataGuard.h.

Constructor & Destructor Documentation

AutomaticIRMetadataGuard::AutomaticIRMetadataGuard	(	CgenState *	cgen_state,
		const std::string &	ppfile,
		const size_t	ppline,
		const std::string &	ppfunc
	)

inline

Definition at line 33 of file AutomaticIRMetadataGuard.h.

References cgen_state_, CHECK, enabled_, g_enable_automatic_ir_metadata, instructions_, instructions_mutex_, CgenState::module_, our_instructions_, rememberPreexistingInstructions(), and this_is_root_.

       : cgen_state_(cgen_state)
       , ppfile_(ppfile)
       , ppline_(ppline)
       , ppfunc_(ppfunc)
       , our_instructions_(nullptr)
       , done_(false) {
     std::lock_guard<std::mutex> lock(instructions_mutex_);
     this_is_root_ = !instructions_.count(cgen_state_);
     enabled_ = g_enable_automatic_ir_metadata;
     if (enabled_) {
       CHECK(cgen_state_);
       CHECK(cgen_state_->module_);
       our_instructions_ = &instructions_[cgen_state_];
       rememberPreexistingInstructions();
     }
   }

Here is the call graph for this function:

AutomaticIRMetadataGuard::~AutomaticIRMetadataGuard ( )

inline

Definition at line 54 of file AutomaticIRMetadataGuard.h.

References done().

54 { done(); }

AutomaticIRMetadataGuard::done

void done() noexcept

Definition: AutomaticIRMetadataGuard.h:56

Here is the call graph for this function:

Member Function Documentation

void AutomaticIRMetadataGuard::done ( )

inlinenoexcept

Definition at line 56 of file AutomaticIRMetadataGuard.h.

References cgen_state_, done_, enabled_, instructions_, instructions_mutex_, markInstructions(), rememberOurInstructions(), and this_is_root_.

Referenced by ~AutomaticIRMetadataGuard().

                        {
     if (enabled_ && !done_) {
       std::lock_guard<std::mutex> lock(instructions_mutex_);
       rememberOurInstructions();
       if (this_is_root_) {
         markInstructions();
         instructions_.erase(cgen_state_);
       }
       done_ = true;
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string AutomaticIRMetadataGuard::makeBaseFilename ( )

inlineprivate

Definition at line 137 of file AutomaticIRMetadataGuard.h.

References ppfile_, and split().

Referenced by rememberOurInstructions().

                                {
     std::vector<std::string> fnames = split(ppfile_, "/");
     if (!fnames.empty()) {
       return fnames.back();
     }
     return ppfile_;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string AutomaticIRMetadataGuard::makeQueryEngineFilename ( )

inlineprivate

Definition at line 145 of file AutomaticIRMetadataGuard.h.

References f(), anonymous_namespace{Utm.h}::n, ppfile_, and split().

Referenced by rememberOurInstructions().

                                       {
     std::vector<std::string> fnames = split(ppfile_, "/");
     bool copying{false};
     std::string f;
     for (auto n : fnames) {
       if (copying && !n.empty()) {
         if (!f.empty()) {
           f += "/";
         }
         f += n;
       }
       if (n == "QueryEngine") {
         copying = true;
       }
     }
     if (f.empty() && fnames.size() > 0) {
       f = fnames.back();
     } else if (f.empty()) {
       f = ppfile_;
     }
     return f;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutomaticIRMetadataGuard::markInstructions ( )

inlinenoexcept

Definition at line 112 of file AutomaticIRMetadataGuard.h.

References cgen_state_, CgenState::context_, detailed_footnote_prefix_, CgenState::module_, and our_instructions_.

Referenced by done().

                                    {
     // iterate over all LLVM instructions in the module
     for (auto func_it = cgen_state_->module_->begin();
          func_it != cgen_state_->module_->end();
          ++func_it) {
       for (auto bb_it = func_it->begin(); bb_it != func_it->end(); ++bb_it) {
         for (auto instr_it = bb_it->begin(); instr_it != bb_it->end(); ++instr_it) {
           auto our_it = our_instructions_->find(&*instr_it);
           if (our_it == our_instructions_->end()) {
             continue;
           }
           unsigned kind_id =
               cgen_state_->context_.getMDKindID(our_it->second.main_filename_);
           auto value = llvm::MDNode::get(
               cgen_state_->context_,
               llvm::MDString::get(
                   cgen_state_->context_,
                   detailed_footnote_prefix_ + our_it->second.detailed_footnote_));
           our_it->first->setMetadata(kind_id, value);
         }
       }
     }
   }

Here is the caller graph for this function:

void AutomaticIRMetadataGuard::rememberOurInstructions ( )

inlinenoexcept

Definition at line 84 of file AutomaticIRMetadataGuard.h.

References cgen_state_, makeBaseFilename(), makeQueryEngineFilename(), CgenState::module_, our_instructions_, ppfunc_, ppline_, preexisting_instructions_, replacePunctuation(), and to_string().

Referenced by done().

                                           {
     // iterate over all LLVM instructions in the module
     for (auto func_it = cgen_state_->module_->begin();
          func_it != cgen_state_->module_->end();
          ++func_it) {
       for (auto bb_it = func_it->begin(); bb_it != func_it->end(); ++bb_it) {
         for (auto instr_it = bb_it->begin(); instr_it != bb_it->end(); ++instr_it) {
           // remember any new instructions as ours, skipping
           // instructions already remembered as preexisting
           llvm::Instruction* i = &*instr_it;
           if (!preexisting_instructions_.count(i)) {
             std::string qefile = makeQueryEngineFilename();
             std::string footnote =
                 ppfunc_ + " after " + qefile + " line #" + std::to_string(ppline_);
             auto it = our_instructions_->find(i);
             if (it == our_instructions_->end()) {
               std::string bfile = replacePunctuation(makeBaseFilename());
               our_instructions_->emplace(i, InstructionInfo{bfile, footnote});
             } else {
               it->second.detailed_footnote_ =
                   footnote + ", " + it->second.detailed_footnote_;
             }
           }
         }
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void AutomaticIRMetadataGuard::rememberPreexistingInstructions ( )

inlinenoexcept

Definition at line 68 of file AutomaticIRMetadataGuard.h.

References cgen_state_, CHECK_EQ, CgenState::module_, and preexisting_instructions_.

Referenced by AutomaticIRMetadataGuard().

                                                   {
     // iterate over all LLVM instructions in the module
     for (auto func_it = cgen_state_->module_->begin();
          func_it != cgen_state_->module_->end();
          ++func_it) {
       for (auto bb_it = func_it->begin(); bb_it != func_it->end(); ++bb_it) {
         for (auto instr_it = bb_it->begin(); instr_it != bb_it->end(); ++instr_it) {
           // remember all the instructions that already existed
           // before this guard object was constructed
           CHECK_EQ(preexisting_instructions_.count(&*instr_it), 0U);
           preexisting_instructions_.insert(&*instr_it);
         }
       }
     }
   }

Here is the caller graph for this function:

std::string AutomaticIRMetadataGuard::replacePunctuation ( std::string text )

inlineprivate

Definition at line 168 of file AutomaticIRMetadataGuard.h.

Referenced by rememberOurInstructions().

                                                {
     static const std::unordered_set<std::string::value_type> allowed_punct{'_', '.'};
     for (auto& ch : text) {
       if (std::ispunct(ch) && !allowed_punct.count(ch)) {
         ch = '_';
       }
     }
     return text;
   }