34#define DEBUG_TYPE "ir2vec"
37 "Number of lookups to entities not present in the vocabulary");
54 std::vector<double> TempOut;
66 assert(this->
size() == RHS.
size() &&
"Vectors must have the same dimension");
67 std::transform(this->
begin(), this->
end(), RHS.
begin(), this->begin(),
79 assert(this->
size() == RHS.
size() &&
"Vectors must have the same dimension");
80 std::transform(this->
begin(), this->
end(), RHS.
begin(), this->begin(),
81 std::minus<double>());
93 [Factor](
double Elem) {
return Elem * Factor; });
104 assert(this->
size() == Src.
size() &&
"Vectors must have the same dimension");
105 for (
size_t Itr = 0; Itr < this->
size(); ++Itr)
106 (*
this)[Itr] += Src[Itr] * Factor;
111 double Tolerance)
const {
112 assert(this->
size() == RHS.
size() &&
"Vectors must have the same dimension");
113 for (
size_t Itr = 0; Itr < this->
size(); ++Itr)
114 if (std::abs((*
this)[Itr] - RHS[Itr]) > Tolerance) {
115 LLVM_DEBUG(
errs() <<
"Embedding mismatch at index " << Itr <<
": "
116 << (*
this)[Itr] <<
" vs " << RHS[Itr]
117 <<
"; Tolerance: " << Tolerance <<
"\n");
125 for (
const auto &Elem : Data)
126 OS <<
" " <<
format(
"%.2f", Elem) <<
" ";
138 return std::make_unique<SymbolicEmbedder>(
F,
Vocab);
140 return std::make_unique<FlowAwareEmbedder>(
F,
Vocab);
148 if (
F.isDeclaration())
161 for (
const auto &
I : BB)
171 for (
const auto &
Op :
I.operands())
174 Vocab[
I.getOpcode()] +
Vocab[
I.getType()->getTypeID()] + ArgEmb;
176 InstVector +=
Vocab[IC->getPredicate()];
182 auto It = InstVecMap.
find(&
I);
183 if (It != InstVecMap.
end())
189 for (
const auto &
Op :
I.operands()) {
192 auto DefIt = InstVecMap.
find(DefInst);
204 if (DefIt != InstVecMap.
end())
205 ArgEmb += DefIt->second;
212 LLVM_DEBUG(
errs() <<
"Using embedding from vocabulary for operand: "
220 Vocab[
I.getOpcode()] +
Vocab[
I.getType()->getTypeID()] + ArgEmb;
222 InstVector +=
Vocab[IC->getPredicate()];
223 InstVecMap[&
I] = InstVector;
232 : Sections(
std::
move(SectionData)), TotalSize([&] {
233 assert(!Sections.empty() &&
"Vocabulary has no sections");
236 for (
const auto &Section : Sections) {
237 assert(!Section.empty() &&
"Vocabulary section is empty");
238 Size += Section.size();
245 assert(!Sections.empty() &&
"Vocabulary has no sections");
246 assert(!Sections[0].empty() &&
"First section of vocabulary is empty");
247 unsigned ExpectedDim =
static_cast<unsigned>(Sections[0][0].size());
251 [[maybe_unused]]
auto allSameDim =
252 [ExpectedDim](
const std::vector<Embedding> &Section) {
253 return std::all_of(Section.begin(), Section.end(),
255 return Emb.size() == ExpectedDim;
258 assert(std::all_of(Sections.begin(), Sections.end(), allSameDim) &&
259 "All embeddings must have the same dimension");
265 assert(SectionId < Storage->Sections.size() &&
"Invalid section ID");
266 assert(LocalIndex < Storage->Sections[SectionId].
size() &&
267 "Local index out of range");
268 return Storage->Sections[SectionId][LocalIndex];
275 LocalIndex >= Storage->Sections[SectionId].size()) {
276 assert(LocalIndex == Storage->Sections[SectionId].size() &&
277 "Local index should be at the end of the current section");
286 return Storage ==
Other.Storage && SectionId ==
Other.SectionId &&
287 LocalIndex ==
Other.LocalIndex;
292 return !(*
this ==
Other);
297 VocabMap &TargetVocab,
unsigned &Dim) {
302 "JSON root is not an object");
307 "Missing '" + std::string(
Key) +
308 "' section in vocabulary file");
311 "Unable to parse '" + std::string(
Key) +
312 "' section from vocabulary");
314 Dim = TargetVocab.begin()->second.size();
317 "Dimension of '" + std::string(
Key) +
318 "' section of the vocabulary is zero");
320 if (!std::all_of(TargetVocab.begin(), TargetVocab.end(),
321 [Dim](
const std::pair<StringRef, Embedding> &Entry) {
322 return Entry.second.size() == Dim;
326 "All vectors in the '" + std::string(
Key) +
327 "' section of the vocabulary are not of the same dimension");
337 assert(Opcode >= 1 && Opcode <= MaxOpcodes &&
"Invalid opcode");
338#define HANDLE_INST(NUM, OPCODE, CLASS) \
339 if (Opcode == NUM) { \
342#include "llvm/IR/Instruction.def"
344 return "UnknownOpcode";
371 if (LocalIndex < fcmpRange)
376 LocalIndex - fcmpRange);
382 PredNameBuffer =
"FCMP_";
384 PredNameBuffer =
"ICMP_";
386 return PredNameBuffer;
390 assert(Pos < NumCanonicalEntries &&
"Position out of bounds in vocabulary");
392 if (Pos < MaxOpcodes)
395 if (Pos < OperandBaseOffset)
396 return getVocabKeyForCanonicalTypeID(
399 if (Pos < PredicateBaseOffset)
401 static_cast<OperandKind>(Pos - OperandBaseOffset));
408 ModuleAnalysisManager::Invalidator &Inv)
const {
410 return !(PAC.preservedWhenStateless());
414 float DummyVal = 0.1f;
418 std::vector<std::vector<Embedding>> Sections;
419 Sections.reserve(
static_cast<unsigned>(Section::MaxSections));
422 std::vector<Embedding> OpcodeSec;
423 OpcodeSec.reserve(MaxOpcodes);
424 for (
unsigned I = 0;
I < MaxOpcodes; ++
I) {
425 OpcodeSec.emplace_back(Dim, DummyVal);
428 Sections.push_back(std::move(OpcodeSec));
431 std::vector<Embedding> TypeSec;
434 TypeSec.emplace_back(Dim, DummyVal);
437 Sections.push_back(std::move(TypeSec));
440 std::vector<Embedding> OperandSec;
443 OperandSec.emplace_back(Dim, DummyVal);
446 Sections.push_back(std::move(OperandSec));
449 std::vector<Embedding> PredicateSec;
452 PredicateSec.emplace_back(Dim, DummyVal);
455 Sections.push_back(std::move(PredicateSec));
461using VocabMap = std::map<std::string, Embedding>;
471 auto Content = BufOrError.get()->getBuffer();
474 if (!ParsedVocabValue)
477 unsigned OpcodeDim = 0, TypeDim = 0, ArgDim = 0;
479 OpcVocab, OpcodeDim))
490 if (!(OpcodeDim == TypeDim && TypeDim == ArgDim))
492 "Vocabulary sections have different dimensions");
506 auto handleMissingEntity = [](
const std::string &Val) {
508 <<
" is not in vocabulary, using zero vector; This "
509 "would result in an error in future.\n");
513 unsigned Dim = OpcVocab.
begin()->second.size();
514 assert(Dim > 0 &&
"Vocabulary dimension must be greater than zero");
517 std::vector<Embedding> NumericOpcodeEmbeddings(Vocabulary::MaxOpcodes,
519 for (
unsigned Opcode :
seq(0u, Vocabulary::MaxOpcodes)) {
521 auto It = OpcVocab.find(VocabKey.
str());
522 if (It != OpcVocab.end())
523 NumericOpcodeEmbeddings[Opcode] = It->second;
525 handleMissingEntity(VocabKey.
str());
532 StringRef VocabKey = Vocabulary::getVocabKeyForCanonicalTypeID(
534 if (
auto It = TypeVocab.find(VocabKey.
str()); It != TypeVocab.end()) {
535 NumericTypeEmbeddings[CTypeID] = It->second;
538 handleMissingEntity(VocabKey.
str());
547 auto It = ArgVocab.find(VocabKey.
str());
548 if (It != ArgVocab.end()) {
549 NumericArgEmbeddings[OpKind] = It->second;
552 handleMissingEntity(VocabKey.
str());
562 auto It = ArgVocab.find(VocabKey.
str());
563 if (It != ArgVocab.end()) {
564 NumericPredEmbeddings[PK] = It->second;
567 handleMissingEntity(VocabKey.
str());
572 std::vector<std::vector<Embedding>> Sections(
573 static_cast<unsigned>(Section::MaxSections));
574 Sections[
static_cast<unsigned>(Section::Opcodes)] =
575 std::move(NumericOpcodeEmbeddings);
576 Sections[
static_cast<unsigned>(Section::CanonicalTypes)] =
577 std::move(NumericTypeEmbeddings);
578 Sections[
static_cast<unsigned>(Section::Operands)] =
579 std::move(NumericArgEmbeddings);
580 Sections[
static_cast<unsigned>(Section::Predicates)] =
581 std::move(NumericPredEmbeddings);
592 float OpcWeight,
float TypeWeight,
594 VocabMap OpcVocab, TypeVocab, ArgVocab;
596 readVocabularyFromFile(VocabFilePath, OpcVocab, TypeVocab, ArgVocab))
597 return std::move(Err);
600 auto scaleVocabSection = [](VocabMap &Vocab,
float Weight) {
601 for (
auto &Entry : Vocab)
602 Entry.second *= Weight;
604 scaleVocabSection(OpcVocab, OpcWeight);
605 scaleVocabSection(TypeVocab, TypeWeight);
606 scaleVocabSection(ArgVocab, ArgWeight);
609 return Vocabulary(buildVocabStorage(OpcVocab, TypeVocab, ArgVocab));
616void IR2VecVocabAnalysis::emitError(
Error Err) {
625 if (Vocab.has_value())
630 if (Opts.ir2vec_vocab_path.empty())
633 "IR2Vec vocabulary file path not specified; You may need to "
634 "set it using --ir2vec-vocab-path");
639 Opts.ir2vec_type_weight, Opts.ir2vec_arg_weight);
641 emitError(VocabOrErr.takeError());
643 return std::move(*VocabOrErr);
659 OS <<
"Error creating IR2Vec embeddings \n";
663 OS <<
"IR2Vec embeddings for function " <<
F.getName() <<
":\n";
664 OS <<
"Function vector: ";
665 Emb->getFunctionVector().print(OS);
667 OS <<
"Basic block vectors:\n";
669 OS <<
"Basic block: " << BB.getName() <<
":\n";
670 Emb->getBBVector(BB).print(OS);
673 OS <<
"Instruction vectors:\n";
676 OS <<
"Instruction: ";
678 Emb->getInstVector(
I).print(OS);
688 assert(IR2VecVocabulary.isValid() &&
"IR2Vec Vocabulary is invalid");
692 for (
const auto &Entry : IR2VecVocabulary) {
693 OS <<
"Key: " << IR2VecVocabulary.getStringKey(Pos++) <<
": ";
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
This file builds on the ADT/GraphTraits.h file to build generic depth first graph iterator.
This file defines the IR2Vec vocabulary analysis(IR2VecVocabAnalysis), the core ir2vec::Embedder inte...
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
Module.h This file contains the declarations for the Module class.
This header defines various interfaces for pass management in LLVM.
std::map< std::string, Embedding > VocabMap
ModuleAnalysisManager MAM
Provides some synthesis utilities to produce sequences of values.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
LLVM Basic Block Representation.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
static LLVM_ABI StringRef getPredicateName(Predicate P)
iterator find(const_arg_type_t< KeyT > Val)
Base class for error info classes.
virtual std::string message() const
Return the error message as a string.
Lightweight error class with error context and mandatory checking.
static ErrorSuccess success()
Create a success value.
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
This analysis provides the vocabulary for IR2Vec.
ir2vec::Vocabulary Result
LLVM_ABI Result run(Module &M, ModuleAnalysisManager &MAM)
static LLVM_ABI AnalysisKey Key
LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
This is an important class for using LLVM in a threaded context.
static ErrorOr< std::unique_ptr< MemoryBuffer > > getFileOrSTDIN(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, std::optional< Align > Alignment=std::nullopt)
Open the specified file as a MemoryBuffer, or open stdin if the Filename is "-".
A Module instance is used to store all the information related to an LLVM module.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Represent a constant reference to a string, i.e.
std::string str() const
Get the contents as an std::string.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
LLVM Value Representation.
static LLVM_ABI std::unique_ptr< Embedder > create(IR2VecKind Mode, const Function &F, const Vocabulary &Vocab)
Factory method to create an Embedder object.
const unsigned Dimension
Dimension of the vector representation; captured from the input vocabulary.
LLVM_ABI Embedding computeEmbeddings() const
Function to compute embeddings.
Iterator support for section-based access.
const_iterator(const VocabStorage *Storage, unsigned SectionId, size_t LocalIndex)
LLVM_ABI bool operator!=(const const_iterator &Other) const
LLVM_ABI const_iterator & operator++()
LLVM_ABI const Embedding & operator*() const
LLVM_ABI bool operator==(const const_iterator &Other) const
Generic storage class for section-based vocabularies.
static LLVM_ABI Error parseVocabSection(StringRef Key, const json::Value &ParsedVocabValue, VocabMap &TargetVocab, unsigned &Dim)
Parse a vocabulary section from JSON and populate the target vocabulary map.
unsigned getNumSections() const
Get number of sections.
size_t size() const
Get total number of entries across all sections.
VocabStorage()=default
Default constructor creates empty storage (invalid state)
const_iterator begin() const
std::map< std::string, Embedding > VocabMap
Class for storing and accessing the IR2Vec vocabulary.
LLVM_ABI bool invalidate(Module &M, const PreservedAnalyses &PA, ModuleAnalysisManager::Invalidator &Inv) const
static LLVM_ABI Expected< Vocabulary > fromFile(StringRef VocabFilePath, float OpcWeight=1.0, float TypeWeight=0.5, float ArgWeight=0.2)
Create a Vocabulary by loading embeddings from a JSON file.
static LLVM_ABI OperandKind getOperandKind(const Value *Op)
Function to classify an operand into OperandKind.
static StringRef getVocabKeyForOperandKind(OperandKind Kind)
Function to get vocabulary key for a given OperandKind.
friend class llvm::IR2VecVocabAnalysis
static LLVM_ABI StringRef getStringKey(unsigned Pos)
Returns the string key for a given index position in the vocabulary.
static constexpr unsigned MaxCanonicalTypeIDs
static constexpr unsigned MaxOperandKinds
OperandKind
Operand kinds supported by IR2Vec Vocabulary.
static LLVM_ABI StringRef getVocabKeyForPredicate(CmpInst::Predicate P)
Function to get vocabulary key for a given predicate.
static LLVM_ABI StringRef getVocabKeyForOpcode(unsigned Opcode)
Function to get vocabulary key for a given Opcode.
static LLVM_ABI VocabStorage createDummyVocabForTest(unsigned Dim=1)
Create a dummy vocabulary for testing purposes.
static constexpr unsigned MaxPredicateKinds
CanonicalTypeID
Canonical type IDs supported by IR2Vec Vocabulary.
An Object is a JSON object, which maps strings to heterogenous JSON values.
LLVM_ABI Value * get(StringRef K)
The root is the trivial Path to the root value.
A "cursor" marking a position within a Value.
A Value is an JSON value of unknown type.
const json::Object * getAsObject() const
This class implements an extremely fast bulk output stream that can only output to a stream.
LLVM_ABI IR2VecKind getEmbeddingKind(const LLVMContext &C)
Return -ir2vec-kind.
LLVM_ABI StringRef getVocabFile(const LLVMContext &C)
Return -ir2vec-vocab-path.
LLVM_ABI llvm::Expected< Value > parse(llvm::StringRef JSON)
Parses the provided JSON source, or returns a ParseError.
bool fromJSON(const Value &E, std::string &Out, Path P)
ir2vec::Embedding Embedding
This is an optimization pass for GlobalISel generic memory operations.
Error createFileError(const Twine &F, Error E)
Concatenate a source file path and/or name with an Error.
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
const AnalysisOptions & getAnalysisOptions(const LLVMContext &C)
IR2VecKind
IR2Vec computes two kinds of embeddings: Symbolic and Flow-aware.
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
DWARFExpression::Operation Op
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
constexpr auto seq(T Begin, T End)
Iterate over an integral type from Begin up to - but not including - End.
iterator_range< df_iterator< T > > depth_first(const T &G)
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Implement std::hash so that hash_code can be used in STL containers.
A special type used by analysis passes to provide an address that identifies that particular analysis...
Embedding is a datatype that wraps std::vector<double>.
LLVM_ABI bool approximatelyEquals(const Embedding &RHS, double Tolerance=1e-4) const
Returns true if the embedding is approximately equal to the RHS embedding within the specified tolera...
LLVM_ABI Embedding & operator+=(const Embedding &RHS)
Arithmetic operators.
LLVM_ABI Embedding operator-(const Embedding &RHS) const
LLVM_ABI Embedding & operator-=(const Embedding &RHS)
LLVM_ABI Embedding operator*(double Factor) const
LLVM_ABI Embedding & operator*=(double Factor)
LLVM_ABI Embedding operator+(const Embedding &RHS) const
LLVM_ABI Embedding & scaleAndAdd(const Embedding &Src, float Factor)
Adds Src Embedding scaled by Factor with the called Embedding.
LLVM_ABI void print(raw_ostream &OS) const