CbC/CbC_llvm: llvm/lib/IR/Module.cpp comparison

comparison llvm/lib/IR/Module.cpp @ 221:79ff65ed7e25

LLVM12 Original

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 15 Jun 2021 19:15:29 +0900
parents	0572611fdcc8
children	5f17cb93ff66

comparison

equal deleted inserted replaced

-:42394fc6a535
+:79ff65ed7e25
 #include "llvm/IR/GlobalIFunc.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
+#include "llvm/IR/ModuleSummaryIndex.h"
 #include "llvm/IR/SymbolTableListTraits.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/TypeFinder.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueSymbolTable.h"
 //===----------------------------------------------------------------------===//
 // Primitive Module methods.
 //
 Module::Module(StringRef MID, LLVMContext &C)
-: Context(C), ValSymTab(std::make_unique<ValueSymbolTable>()),
+: Context(C), ValSymTab(std::make_unique<ValueSymbolTable>(-1)),
 Materializer(), ModuleID(std::string(MID)),
 SourceFileName(std::string(MID)), DL("") {
 Context.addModule(this);
 }
 SrcStructTypes.run(*this, true);
 Ret.assign(SrcStructTypes.begin(), SrcStructTypes.end());
 return Ret;
 }
+std::string Module::getUniqueIntrinsicName(StringRef BaseName, Intrinsic::ID Id,
+const FunctionType *Proto) {
+auto Encode = [&BaseName](unsigned Suffix) {
+return (Twine(BaseName) + "." + Twine(Suffix)).str();
+};
+{
+// fast path - the prototype is already known
+auto UinItInserted = UniquedIntrinsicNames.insert({{Id, Proto}, 0});
+if (!UinItInserted.second)
+return Encode(UinItInserted.first->second);
+}
+// Not known yet. A new entry was created with index 0. Check if there already
+// exists a matching declaration, or select a new entry.
+// Start looking for names with the current known maximum count (or 0).
+auto NiidItInserted = CurrentIntrinsicIds.insert({BaseName, 0});
+unsigned Count = NiidItInserted.first->second;
+// This might be slow if a whole population of intrinsics already existed, but
+// we cache the values for later usage.
+std::string NewName;
+while (true) {
+NewName = Encode(Count);
+GlobalValue *F = getNamedValue(NewName);
+if (!F) {
+// Reserve this entry for the new proto
+UniquedIntrinsicNames[{Id, Proto}] = Count;
+break;
+}
+// A declaration with this name already exists. Remember it.
+FunctionType *FT = dyn_cast<FunctionType>(F->getType()->getElementType());
+auto UinItInserted = UniquedIntrinsicNames.insert({{Id, FT}, Count});
+if (FT == Proto) {
+// It was a declaration for our prototype. This entry was allocated in the
+// beginning. Update the count to match the existing declaration.
+UinItInserted.first->second = Count;
+break;
+}
+++Count;
+}
+NiidItInserted.first->second = Count + 1;
+return NewName;
+}
 // dropAllReferences() - This function causes all the subelements to "let go"
 // of all references that they are maintaining.  This allows one to 'delete' a
 // whole module at a time, even though there may be circular references... first
 // all references are dropped, and all use counts go to zero.  Then everything
 // is deleted for real.  Note that no operations are valid on an object that
 if (!Val)
 return 0;
 return cast<ConstantInt>(Val->getValue())->getZExtValue();
 }
+bool Module::isDwarf64() const {
+auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("DWARF64"));
+return Val && cast<ConstantInt>(Val->getValue())->isOne();
+}
 unsigned Module::getCodeViewFlag() const {
 auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("CodeView"));
 if (!Val)
 return 0;
 return cast<ConstantInt>(Val->getValue())->getZExtValue();
 }
-unsigned Module::getInstructionCount() {
+unsigned Module::getInstructionCount() const {
 unsigned NumInstrs = 0;
-for (Function &F : FunctionList)
+for (const Function &F : FunctionList)
 NumInstrs += F.getInstructionCount();
 return NumInstrs;
 }
 Comdat *Module::getOrInsertComdat(StringRef Name) {
 setModuleFlag(ModFlagBehavior::Error, "CSProfileSummary", M);
 else
 setModuleFlag(ModFlagBehavior::Error, "ProfileSummary", M);
 }
-Metadata *Module::getProfileSummary(bool IsCS) {
+Metadata *Module::getProfileSummary(bool IsCS) const {
 return (IsCS ? getModuleFlag("CSProfileSummary")
 : getModuleFlag("ProfileSummary"));
 }
 bool Module::getSemanticInterposition() const {
 return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
 }
 void Module::setRtLibUseGOT() {
 addModuleFlag(ModFlagBehavior::Max, "RtLibUseGOT", 1);
+}
+bool Module::getUwtable() const {
+auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("uwtable"));
+return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
+}
+void Module::setUwtable() { addModuleFlag(ModFlagBehavior::Max, "uwtable", 1); }
+FramePointerKind Module::getFramePointer() const {
+auto *Val = cast_or_null<ConstantAsMetadata>(getModuleFlag("frame-pointer"));
+return static_cast<FramePointerKind>(
+Val ? cast<ConstantInt>(Val->getValue())->getZExtValue() : 0);
+}
+void Module::setFramePointer(FramePointerKind Kind) {
+addModuleFlag(ModFlagBehavior::Max, "frame-pointer", static_cast<int>(Kind));
+}
+StringRef Module::getStackProtectorGuard() const {
+Metadata *MD = getModuleFlag("stack-protector-guard");
+if (auto *MDS = dyn_cast_or_null<MDString>(MD))
+return MDS->getString();
+return {};
+}
+void Module::setStackProtectorGuard(StringRef Kind) {
+MDString *ID = MDString::get(getContext(), Kind);
+addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard", ID);
+}
+StringRef Module::getStackProtectorGuardReg() const {
+Metadata *MD = getModuleFlag("stack-protector-guard-reg");
+if (auto *MDS = dyn_cast_or_null<MDString>(MD))
+return MDS->getString();
+return {};
+}
+void Module::setStackProtectorGuardReg(StringRef Reg) {
+MDString *ID = MDString::get(getContext(), Reg);
+addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-reg", ID);
+}
+int Module::getStackProtectorGuardOffset() const {
+Metadata *MD = getModuleFlag("stack-protector-guard-offset");
+if (auto *CI = mdconst::dyn_extract_or_null<ConstantInt>(MD))
+return CI->getSExtValue();
+return INT_MAX;
+}
+void Module::setStackProtectorGuardOffset(int Offset) {
+addModuleFlag(ModFlagBehavior::Error, "stack-protector-guard-offset", Offset);
 }
 void Module::setSDKVersion(const VersionTuple &V) {
 SmallVector<unsigned, 3> Entries;
 Entries.push_back(V.getMajor());
 }
 return Result;
 }
 GlobalVariable *llvm::collectUsedGlobalVariables(
-const Module &M, SmallPtrSetImpl<GlobalValue *> &Set, bool CompilerUsed) {
+const Module &M, SmallVectorImpl<GlobalValue *> &Vec, bool CompilerUsed) {
 const char *Name = CompilerUsed ? "llvm.compiler.used" : "llvm.used";
 GlobalVariable *GV = M.getGlobalVariable(Name);
 if (!GV || !GV->hasInitializer())
 return GV;
 const ConstantArray *Init = cast<ConstantArray>(GV->getInitializer());
 for (Value *Op : Init->operands()) {
 GlobalValue *G = cast<GlobalValue>(Op->stripPointerCasts());
-Set.insert(G);
+Vec.push_back(G);
 }
 return GV;
 }
+void Module::setPartialSampleProfileRatio(const ModuleSummaryIndex &Index) {
+if (auto *SummaryMD = getProfileSummary(/*IsCS*/ false)) {
+std::unique_ptr<ProfileSummary> ProfileSummary(
+ProfileSummary::getFromMD(SummaryMD));
+if (ProfileSummary) {
+if (ProfileSummary->getKind() != ProfileSummary::PSK_Sample ||
+!ProfileSummary->isPartialProfile())
+return;
+uint64_t BlockCount = Index.getBlockCount();
+uint32_t NumCounts = ProfileSummary->getNumCounts();
+if (!NumCounts)
+return;
+double Ratio = (double)BlockCount / NumCounts;
+ProfileSummary->setPartialProfileRatio(Ratio);
+setProfileSummary(ProfileSummary->getMD(getContext()),
+ProfileSummary::PSK_Sample);
+}
+}
+}

Mercurial > hg > CbC > CbC_llvm

comparison llvm/lib/IR/Module.cpp @ 221:79ff65ed7e25