map<string, Variable*>* IRParser::parseParameters(Module* module){
map<string, Variable*>* parameters = new map<string, Variable*>();
NamedMDNode* inputsMD = module->getNamedMetadata(IRConstant::KEY_PARAMETERS);
if (inputsMD != NULL){
for (unsigned i = 0, e = inputsMD->getNumOperands(); i != e; ++i) {
//Parse a parameter
MDNode* parameterNode = cast<MDNode>(inputsMD->getOperand(i));
MDNode* details = cast<MDNode>(parameterNode->getOperand(0));
MDString* nameMD = cast<MDString>(details->getOperand(0));
Type* type = parseType(cast<MDNode>(parameterNode->getOperand(1)));
GlobalVariable* variable = cast<GlobalVariable>(parameterNode->getOperand(2));
//Parse create parameter
StateVar* parameter = new StateVar(type, nameMD->getString(), false, variable);
parameters->insert(pair<string, Variable*>(nameMD->getString(), parameter));
}
}
return parameters;
}
/// \brief Find string metadata for loop
///
/// If it has a value (e.g. {"llvm.distribute", 1} return the value as an
/// operand or null otherwise. If the string metadata is not found return
/// Optional's not-a-value.
Optional<const MDOperand *> llvm::findStringMetadataForLoop(Loop *TheLoop,
StringRef Name) {
MDNode *LoopID = TheLoop->getLoopID();
// Return none if LoopID is false.
if (!LoopID)
return None;
// First operand should refer to the loop id itself.
assert(LoopID->getNumOperands() > 0 && "requires at least one operand");
assert(LoopID->getOperand(0) == LoopID && "invalid loop id");
// Iterate over LoopID operands and look for MDString Metadata
for (unsigned i = 1, e = LoopID->getNumOperands(); i < e; ++i) {
MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
if (!MD)
continue;
MDString *S = dyn_cast<MDString>(MD->getOperand(0));
if (!S)
continue;
// Return true if MDString holds expected MetaData.
if (Name.equals(S->getString()))
switch (MD->getNumOperands()) {
case 1:
return nullptr;
case 2:
return &MD->getOperand(1);
default:
llvm_unreachable("loop metadata has 0 or 1 operand");
}
}
return None;
}
MoC* IRParser::parseMoC(Module* module){
NamedMDNode* mocKeyMD = module->getNamedMetadata(IRConstant::KEY_MOC);
if (mocKeyMD == NULL) {
return new DPNMoC(actor);
}
//Parse MoC type
MDNode* node = mocKeyMD->getOperand(0);
MDString* name = cast<MDString>(node->getOperand(0));
StringRef nameStr = name->getString();
if (nameStr == "SDF"){
return parseCSDF(cast<MDNode>(node->getOperand(1)));
}else if(nameStr == "CSDF"){
return parseCSDF(cast<MDNode>(node->getOperand(1)));
}else if(nameStr == "QuasiStatic"){
return parseQSDF(node);
}else if(nameStr == "KPN"){
return new KPNMoC(actor);
}else if(nameStr == "DPN"){
return new DPNMoC(actor);
}
cerr << "Unsupported type of MoC" << endl;
exit(1);
}
/// parseMetadata - Parse metadata from the module
void LTOModule::parseMetadata() {
raw_string_ostream OS(LinkerOpts);
// Linker Options
if (NamedMDNode *LinkerOptions =
getModule().getNamedMetadata("llvm.linker.options")) {
for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
MDNode *MDOptions = LinkerOptions->getOperand(i);
for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
OS << " " << MDOption->getString();
}
}
}
// Globals - we only need to do this for COFF.
const Triple TT(_target->getTargetTriple());
if (!TT.isOSBinFormatCOFF())
return;
Mangler M;
for (const NameAndAttributes &Sym : _symbols) {
if (!Sym.symbol)
continue;
emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M);
}
// Add other interesting metadata here.
}
std::string GCOVProfiler::mangleName(const DICompileUnit *CU,
const char *NewStem) {
if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
MDNode *N = GCov->getOperand(i);
if (N->getNumOperands() != 2) continue;
MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0));
MDNode *CompileUnit = dyn_cast<MDNode>(N->getOperand(1));
if (!GCovFile || !CompileUnit) continue;
if (CompileUnit == CU) {
SmallString<128> Filename = GCovFile->getString();
sys::path::replace_extension(Filename, NewStem);
return Filename.str();
}
}
}
SmallString<128> Filename = CU->getFilename();
sys::path::replace_extension(Filename, NewStem);
StringRef FName = sys::path::filename(Filename);
SmallString<128> CurPath;
if (sys::fs::current_path(CurPath)) return FName;
sys::path::append(CurPath, FName);
return CurPath.str();
}
Action* IRParser::getAction(llvm::MDNode* node) {
Value* idValue = node->getOperand(0);
if (idValue == NULL){
map<Function*, Action*>::iterator it;
// Action has not tag, find it by its function name
Function* function = getBodyFunction(node);
it = untaggedActions.find(function);
return it->second;
}
//Get identifiers of action tag
map<std::string, Action*>::iterator it;
ActionTag tag;
MDNode* idNode = cast<MDNode>(idValue);
for (unsigned i = 0, e = idNode->getNumOperands(); i != e; ++i){
MDString* tagMD = cast<MDString>(idNode->getOperand(i));
tag.add(tagMD->getString());
}
it = actions.find(tag.getIdentifier());
return it->second;
}
/// parseMetadata - Parse metadata from the module
void LTOModule::parseMetadata() {
// Linker Options
if (Metadata *Val = getModule().getModuleFlag("Linker Options")) {
MDNode *LinkerOptions = cast<MDNode>(Val);
for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
// FIXME: Make StringSet::insert match Self-Associative Container
// requirements, returning <iter,bool> rather than bool, and use that
// here.
StringRef Op =
_linkeropt_strings.insert(MDOption->getString()).first->first();
StringRef DepLibName = _target->getSubtargetImpl()
->getTargetLowering()
->getObjFileLowering()
.getDepLibFromLinkerOpt(Op);
if (!DepLibName.empty())
_deplibs.push_back(DepLibName.data());
else if (!Op.empty())
_linkeropts.push_back(Op.data());
}
}
}
// Add other interesting metadata here.
}
void TargetLoweringObjectFileCOFF::
emitModuleFlags(MCStreamer &Streamer,
ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
Mangler &Mang, const TargetMachine &TM) const {
MDNode *LinkerOptions = nullptr;
// Look for the "Linker Options" flag, since it's the only one we support.
for (ArrayRef<Module::ModuleFlagEntry>::iterator
i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
const Module::ModuleFlagEntry &MFE = *i;
StringRef Key = MFE.Key->getString();
Metadata *Val = MFE.Val;
if (Key == "Linker Options") {
LinkerOptions = cast<MDNode>(Val);
break;
}
}
if (!LinkerOptions)
return;
// Emit the linker options to the linker .drectve section. According to the
// spec, this section is a space-separated string containing flags for linker.
const MCSection *Sec = getDrectveSection();
Streamer.SwitchSection(Sec);
for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
// Lead with a space for consistency with our dllexport implementation.
std::string Directive(" ");
Directive.append(MDOption->getString());
Streamer.EmitBytes(Directive);
}
}
}
MDNode *llvm::findOptionMDForLoopID(MDNode *LoopID, StringRef Name) {
// No loop metadata node, no loop properties.
if (!LoopID)
return nullptr;
// First operand should refer to the metadata node itself, for legacy reasons.
assert(LoopID->getNumOperands() > 0 && "requires at least one operand");
assert(LoopID->getOperand(0) == LoopID && "invalid loop id");
// Iterate over the metdata node operands and look for MDString metadata.
for (unsigned i = 1, e = LoopID->getNumOperands(); i < e; ++i) {
MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
if (!MD || MD->getNumOperands() < 1)
continue;
MDString *S = dyn_cast<MDString>(MD->getOperand(0));
if (!S)
continue;
// Return the operand node if MDString holds expected metadata.
if (Name.equals(S->getString()))
return MD;
}
// Loop property not found.
return nullptr;
}
static inline SDBuildCHA::vtbl_name_t
sd_getStringFromMDTuple(const MDOperand& op) {
MDString* mds = dyn_cast_or_null<MDString>(op.get());
assert(mds);
return mds->getString().str();
}
/// parseMetadata - Parse metadata from the module
void LTOModule::parseMetadata() {
raw_string_ostream OS(LinkerOpts);
// Linker Options
if (Metadata *Val = getModule().getModuleFlag("Linker Options")) {
MDNode *LinkerOptions = cast<MDNode>(Val);
for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
OS << " " << MDOption->getString();
}
}
}
// Globals
Mangler Mang;
for (const NameAndAttributes &Sym : _symbols) {
if (!Sym.symbol)
continue;
_target->getObjFileLowering()->emitLinkerFlagsForGlobal(OS, Sym.symbol,
Mang);
}
// Add other interesting metadata here.
}
// Parse an MDTuple representing detailed summary.
static bool getSummaryFromMD(MDTuple *MD, SummaryEntryVector &Summary) {
if (!MD || MD->getNumOperands() != 2)
return false;
MDString *KeyMD = dyn_cast<MDString>(MD->getOperand(0));
if (!KeyMD || !KeyMD->getString().equals("DetailedSummary"))
return false;
MDTuple *EntriesMD = dyn_cast<MDTuple>(MD->getOperand(1));
if (!EntriesMD)
return false;
for (auto &&MDOp : EntriesMD->operands()) {
MDTuple *EntryMD = dyn_cast<MDTuple>(MDOp);
if (!EntryMD || EntryMD->getNumOperands() != 3)
return false;
ConstantAsMetadata *Op0 =
dyn_cast<ConstantAsMetadata>(EntryMD->getOperand(0));
ConstantAsMetadata *Op1 =
dyn_cast<ConstantAsMetadata>(EntryMD->getOperand(1));
ConstantAsMetadata *Op2 =
dyn_cast<ConstantAsMetadata>(EntryMD->getOperand(2));
if (!Op0 || !Op1 || !Op2)
return false;
Summary.emplace_back(cast<ConstantInt>(Op0->getValue())->getZExtValue(),
cast<ConstantInt>(Op1->getValue())->getZExtValue(),
cast<ConstantInt>(Op2->getValue())->getZExtValue());
}
return true;
}
/// categorizeModuleFlagNodes -
bool ModuleLinker::
categorizeModuleFlagNodes(const NamedMDNode *ModFlags,
DenseMap<MDString*, MDNode*> &ErrorNode,
DenseMap<MDString*, MDNode*> &WarningNode,
DenseMap<MDString*, MDNode*> &OverrideNode,
DenseMap<MDString*,
SmallSetVector<MDNode*, 8> > &RequireNodes,
SmallSetVector<MDString*, 16> &SeenIDs) {
bool HasErr = false;
for (unsigned I = 0, E = ModFlags->getNumOperands(); I != E; ++I) {
MDNode *Op = ModFlags->getOperand(I);
assert(Op->getNumOperands() == 3 && "Invalid module flag metadata!");
assert(isa<ConstantInt>(Op->getOperand(0)) &&
"Module flag's first operand must be an integer!");
assert(isa<MDString>(Op->getOperand(1)) &&
"Module flag's second operand must be an MDString!");
ConstantInt *Behavior = cast<ConstantInt>(Op->getOperand(0));
MDString *ID = cast<MDString>(Op->getOperand(1));
Value *Val = Op->getOperand(2);
switch (Behavior->getZExtValue()) {
default:
assert(false && "Invalid behavior in module flag metadata!");
break;
case Module::Error: {
MDNode *&ErrNode = ErrorNode[ID];
if (!ErrNode) ErrNode = Op;
if (ErrNode->getOperand(2) != Val)
HasErr = emitError("linking module flags '" + ID->getString() +
"': IDs have conflicting values");
break;
}
case Module::Warning: {
MDNode *&WarnNode = WarningNode[ID];
if (!WarnNode) WarnNode = Op;
if (WarnNode->getOperand(2) != Val)
errs() << "WARNING: linking module flags '" << ID->getString()
<< "': IDs have conflicting values";
break;
}
case Module::Require: RequireNodes[ID].insert(Op); break;
case Module::Override: {
MDNode *&OvrNode = OverrideNode[ID];
if (!OvrNode) OvrNode = Op;
if (OvrNode->getOperand(2) != Val)
HasErr = emitError("linking module flags '" + ID->getString() +
"': IDs have conflicting override values");
break;
}
}
SeenIDs.insert(ID);
}
return HasErr;
}
// Check if an MDTuple represents a (Key, Val) pair.
static bool isKeyValuePair(MDTuple *MD, const char *Key, const char *Val) {
if (!MD || MD->getNumOperands() != 2)
return false;
MDString *KeyMD = dyn_cast<MDString>(MD->getOperand(0));
MDString *ValMD = dyn_cast<MDString>(MD->getOperand(1));
if (!KeyMD || !ValMD)
return false;
if (!KeyMD->getString().equals(Key) || !ValMD->getString().equals(Val))
return false;
return true;
}
Port* IRParser::parsePort(MDNode* node){
//Get port property
Type* type = (Type*)parseType(cast<MDNode>(node->getOperand(0)));
MDString* name = cast<MDString>(node->getOperand(1));
GlobalVariable* var = cast<GlobalVariable>(node->getOperand(2));
//Create the new port
Port* newPort = new Port(name->getString(), (IntegerType*)type, actor);
newPort->setPtrVar(new Variable(type, name->getString(), true, true, var));
return newPort;
}
Procedure* IRParser::parseProc(MDNode* node){
if (node->getOperand(2) == NULL){
//procedure is unused
return NULL;
}
MDString* name = cast<MDString>(node->getOperand(0));
ConstantInt* isExtern = cast<ConstantInt>(node->getOperand(1));
Function* function = cast<Function>(node->getOperand(2));
return new Procedure(name->getString(), isExtern, function);
}
static jl_value_t *julia_type_of(Value *v)
{
MDNode *mdn;
if (dyn_cast<Instruction>(v) == NULL ||
(mdn = ((Instruction*)v)->getMetadata("julia_type")) == NULL) {
return julia_type_of_without_metadata(v, true);
}
MDString *md = (MDString*)mdn->getOperand(0);
const char *vts = md->getString().data();
int id = (vts[0]-1) + (vts[1]-1)*255;
return jl_typeid_to_type(id);
}
static std::string
ModuleMetaGet(const Module *module, StringRef MetaName) {
NamedMDNode *node = module->getNamedMetadata(MetaName);
if (node == NULL)
return "";
assert(node->getNumOperands() == 1);
MDNode *subnode = node->getOperand(0);
assert(subnode->getNumOperands() == 1);
MDString *value = dyn_cast<MDString>(subnode->getOperand(0));
assert(value != NULL);
return value->getString();
}
void
SpecializationTable::initialize(Module* m)
{
assert(this->module == NULL);
this->module = m;
#ifdef RECORD_IN_METADATA
// Parse the module metadata to populate the table
NamedMDNode* specs = m->getNamedMetadata("previrt::specializations");
if (specs == NULL)
return;
errs() << "Specialization Count: " << specs->getNumOperands() << "\n";
for (unsigned int i = 0; i < specs->getNumOperands(); ++i) {
MDNode* funNode = specs->getOperand(i);
if (funNode == NULL) {
continue;
}
assert (funNode->getNumOperands() > 2);
MDString* prinName = dyn_cast_or_null<MDString>(funNode->getOperand(0));
MDString* specName = dyn_cast_or_null<MDString>(funNode->getOperand(1));
if (prinName == NULL || specName == NULL) {
errs() << "must skip " << (prinName == NULL ? "?" : prinName->getString()) << "\n";
continue;
}
Function* prin = m->getFunction(prinName->getString());
Function* spec = m->getFunction(specName->getString());
if (prin == NULL || spec == NULL) {
errs() << "must skip " << (prin == NULL ? "?" : prin->getName()) << "\n";
continue;
}
const unsigned int arg_count = prin->getArgumentList().size();
if (funNode->getNumOperands() != 2 + arg_count) {
continue;
}
SpecScheme scheme = new Value*[arg_count];
for (unsigned int i = 0; i < arg_count; i++) {
Value* opr = funNode->getOperand(2 + i);
if (opr == NULL) {
scheme[i] = NULL;
} else {
assert (dyn_cast<Constant>(opr) != NULL);
scheme[i] = opr;
}
}
this->addSpecialization(prin, scheme, spec, false);
errs() << "recording specialization of '" << prin->getName() << "' to '" << spec->getName() << "'\n";
}
#endif /* RECORD_IN_METADATA */
}
Actor* IRParser::parseActor(string classz){
//Get file and package of the actor
string file = PackageMng::getSimpleName(classz);
string packageName = PackageMng::getPackagesName(classz);
Package* package = PackageMng::getPackage(packageName);
//Parse the bitcode
Module* module = parser->loadModule(package, file);
if (module == 0){
//Module not found
cerr << "Error when parsing bytecode";
exit(1);
}
//Empty action list
actions.clear();
untaggedActions.clear();
// Parse name
NamedMDNode* nameNMD = module->getNamedMetadata(IRConstant::KEY_NAME);
MDNode* nameMD = cast<MDNode>(nameNMD->getOperand(0));
MDString* name = cast<MDString>(nameMD->getOperand(0));
// Create the new actor
actor = new Actor(name->getString(), module, classz);
// Parse actor elements
inputs = parsePorts(IRConstant::KEY_INPUTS, module);
outputs = parsePorts(IRConstant::KEY_OUTPUTS, module);
map<string, Variable*>* parameters = parseParameters(module);
map<string, StateVar*>* stateVars = parseStateVars(module);
map<string, Procedure*>* procs = parseProcs(module);
list<Action*>* initializes = parseActions(IRConstant::KEY_INITIALIZES, module);
list<Action*>* actions = parseActions(IRConstant::KEY_ACTIONS, module);
ActionScheduler* actionScheduler = parseActionScheduler(module);
MoC* moc = parseMoC(module);
//Set parameters of the actor
actor->setInputs(inputs);
actor->setOutputs(outputs);
actor->setParameters(parameters);
actor->setActions(actions);
actor->setStateVars(stateVars);
actor->setProcs(procs);
actor->setActions(actions);
actor->setInitializes(initializes);
actor->setActionScheduler(actionScheduler);
actor->setMoC(moc);
return actor;
}
// Parse an MDTuple representing (Key, Val) pair.
static bool getVal(MDTuple *MD, const char *Key, uint64_t &Val) {
if (!MD)
return false;
if (MD->getNumOperands() != 2)
return false;
MDString *KeyMD = dyn_cast<MDString>(MD->getOperand(0));
ConstantAsMetadata *ValMD = dyn_cast<ConstantAsMetadata>(MD->getOperand(1));
if (!KeyMD || !ValMD)
return false;
if (!KeyMD->getString().equals(Key))
return false;
Val = cast<ConstantInt>(ValMD->getValue())->getZExtValue();
return true;
}
// @LOCALMOD-BEGIN
void Module::convertMetadataToLibraryList() {
LibraryList.clear();
// Get the DepLib node
NamedMDNode *Node = getNamedMetadata("DepLibs");
if (!Node)
return;
for (unsigned i = 0; i < Node->getNumOperands(); i++) {
MDString* Mds = dyn_cast_or_null<MDString>(
Node->getOperand(i)->getOperand(0));
assert(Mds && "Bad NamedMetadata operand");
LibraryList.push_back(Mds->getString());
}
// Clear the metadata so the linker won't try to merge it
Node->dropAllReferences();
}
void Instruction::swapProfMetadata() {
MDNode *ProfileData = getMetadata(LLVMContext::MD_prof);
if (!ProfileData || ProfileData->getNumOperands() != 3 ||
!isa<MDString>(ProfileData->getOperand(0)))
return;
MDString *MDName = cast<MDString>(ProfileData->getOperand(0));
if (MDName->getString() != "branch_weights")
return;
// The first operand is the name. Fetch them backwards and build a new one.
Metadata *Ops[] = {ProfileData->getOperand(0), ProfileData->getOperand(2),
ProfileData->getOperand(1)};
setMetadata(LLVMContext::MD_prof,
MDNode::get(ProfileData->getContext(), Ops));
}
void TargetLoweringObjectFileCOFF::
emitModuleFlags(MCStreamer &Streamer,
ArrayRef<Module::ModuleFlagEntry> ModuleFlags,
Mangler &Mang, const TargetMachine &TM) const {
MDNode *LinkerOptions = nullptr;
// Look for the "Linker Options" flag, since it's the only one we support.
for (ArrayRef<Module::ModuleFlagEntry>::iterator
i = ModuleFlags.begin(), e = ModuleFlags.end(); i != e; ++i) {
const Module::ModuleFlagEntry &MFE = *i;
StringRef Key = MFE.Key->getString();
Value *Val = MFE.Val;
if (Key == "Linker Options") {
LinkerOptions = cast<MDNode>(Val);
break;
}
}
if (!LinkerOptions)
return;
// Emit the linker options to the linker .drectve section. According to the
// spec, this section is a space-separated string containing flags for linker.
const MCSection *Sec = getDrectveSection();
Streamer.SwitchSection(Sec);
for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
StringRef Op = MDOption->getString();
// Lead with a space for consistency with our dllexport implementation.
std::string Escaped(" ");
if (Op.find(" ") != StringRef::npos) {
// The PE-COFF spec says args with spaces must be quoted. It doesn't say
// how to escape quotes, but it probably uses this algorithm:
// http://msdn.microsoft.com/en-us/library/17w5ykft(v=vs.85).aspx
// FIXME: Reuse escaping code from Support/Windows/Program.inc
Escaped.push_back('\"');
Escaped.append(Op);
Escaped.push_back('\"');
} else {
Escaped.append(Op);
}
Streamer.EmitBytes(Escaped);
}
}
}
/// Given an llvm.loop loop id metadata node, returns the loop hint metadata
/// node with the given name (for example, "llvm.loop.unroll.count"). If no
/// such metadata node exists, then nullptr is returned.
MDNode *llvm::GetUnrollMetadata(MDNode *LoopID, StringRef Name) {
// First operand should refer to the loop id itself.
assert(LoopID->getNumOperands() > 0 && "requires at least one operand");
assert(LoopID->getOperand(0) == LoopID && "invalid loop id");
for (unsigned i = 1, e = LoopID->getNumOperands(); i < e; ++i) {
MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
if (!MD)
continue;
MDString *S = dyn_cast<MDString>(MD->getOperand(0));
if (!S)
continue;
if (Name.equals(S->getString()))
return MD;
}
return nullptr;
}
std::string GCOVProfiler::mangleName(DICompileUnit CU, std::string NewStem) {
if (NamedMDNode *GCov = M->getNamedMetadata("llvm.gcov")) {
for (int i = 0, e = GCov->getNumOperands(); i != e; ++i) {
MDNode *N = GCov->getOperand(i);
if (N->getNumOperands() != 2) continue;
MDString *GCovFile = dyn_cast<MDString>(N->getOperand(0));
MDNode *CompileUnit = dyn_cast<MDNode>(N->getOperand(1));
if (!GCovFile || !CompileUnit) continue;
if (CompileUnit == CU) {
SmallString<128> Filename = GCovFile->getString();
sys::path::replace_extension(Filename, NewStem);
return Filename.str();
}
}
}
SmallString<128> Filename = CU.getFilename();
sys::path::replace_extension(Filename, NewStem);
return sys::path::filename(Filename.str());
}
AllocaInst* getLoopVi(Loop* L)
{
auto loop_id = loop::getLoopId(L);
for(BasicBlock& block : *loop::getParentFunction(L))
{
for(Instruction &inst : block)
{
AllocaInst *alloc = dyn_cast<AllocaInst>(&inst);
if(alloc && metadata::hasMetadataKind(alloc, "virtualIterator"))
{
MDString *mdstring = metadata::getMetadataStringOperand(alloc, "virtualIterator", 0);
//ConstantInt* loopId = cast<ConstantInt>(metadata::getMetadataOperand(alloc, "virtualIterator"));
//if(loopId->getSExtValue() == loop_id) return alloc;
if(std::stoul(mdstring->getString()) == loop_id) return alloc;
}
}
}
assert(false && "Virtual iterator not found!");
}
map<Port*, ConstantInt*>* IRParser::parserNumTokens(map<std::string, Port*>* ports, Value* value){
map<Port*, ConstantInt*>* numTokens = new map<Port*, ConstantInt*>();
if (value != NULL){
map<string, Port*>::iterator it;
MDNode* numTokensNode = cast<MDNode>(value);
for (unsigned i = 0, e = numTokensNode->getNumOperands(); i != e;) {
//Find port of the pattern
MDNode* portNode = cast<MDNode>(numTokensNode->getOperand(i));
MDString* name = cast<MDString>(portNode->getOperand(1));
it = ports->find(name->getString());
//Get number of token consummed/produced by this port
ConstantInt* nbTokens = cast<ConstantInt>(numTokensNode->getOperand(++i));
numTokens->insert(pair<Port*, ConstantInt*>(it->second, nbTokens));
i++;
}
}
return numTokens;
}
/// parseMetadata - Parse metadata from the module
void LTOModule::parseMetadata() {
// Linker Options
if (Value *Val = _module->getModuleFlag("Linker Options")) {
MDNode *LinkerOptions = cast<MDNode>(Val);
for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
MDNode *MDOptions = cast<MDNode>(LinkerOptions->getOperand(i));
for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
StringRef Op = _linkeropt_strings.
GetOrCreateValue(MDOption->getString()).getKey();
StringRef DepLibName = _target->getTargetLowering()->
getObjFileLowering().getDepLibFromLinkerOpt(Op);
if (!DepLibName.empty())
_deplibs.push_back(DepLibName.data());
else if (!Op.empty())
_linkeropts.push_back(Op.data());
}
}
}
// Add other interesting metadata here.
}
StateVar* IRParser::parseStateVar(MDNode* node){
// Parsing VarDef
MDNode* varDefMD = cast<MDNode>(node->getOperand(0));
MDString* name = cast<MDString>(varDefMD->getOperand(0));
ConstantInt* assignable = cast<ConstantInt>(varDefMD->getOperand(1));
//Parse StateVar properties
IntegerType* type = (IntegerType*)parseType(cast<MDNode>(node->getOperand(1)));
//Parse initialize
Value* MDExpr = node->getOperand(2);
Expr* init = NULL;
if (MDExpr != NULL){
init = parseExpr(cast<MDNode>(MDExpr));
}
//Link with llvm global variable
GlobalVariable* variable = cast<GlobalVariable>(node->getOperand(3));
return new StateVar(type, name->getString(), assignable->getValue().getBoolValue(), variable, init);
}
