aboutsummaryrefslogtreecommitdiff
path: root/llvm/lib/IR
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/IR')
-rw-r--r--llvm/lib/IR/AutoUpgrade.cpp144
-rw-r--r--llvm/lib/IR/ModuleSummaryIndex.cpp8
-rw-r--r--llvm/lib/IR/Verifier.cpp15
3 files changed, 152 insertions, 15 deletions
diff --git a/llvm/lib/IR/AutoUpgrade.cpp b/llvm/lib/IR/AutoUpgrade.cpp
index 10f915d..b838e36 100644
--- a/llvm/lib/IR/AutoUpgrade.cpp
+++ b/llvm/lib/IR/AutoUpgrade.cpp
@@ -5262,33 +5262,47 @@ void llvm::UpgradeIntrinsicCall(CallBase *CI, Function *NewFn) {
return;
}
+ auto GetMaybeAlign = [](Value *Op) {
+ if (auto *CI = dyn_cast<ConstantInt>(Op)) {
+ uint64_t Val = CI->getZExtValue();
+ if (Val == 0)
+ return MaybeAlign();
+ if (isPowerOf2_64(Val))
+ return MaybeAlign(Val);
+ }
+ reportFatalUsageError("Invalid alignment argument");
+ };
+ auto GetAlign = [&](Value *Op) {
+ MaybeAlign Align = GetMaybeAlign(Op);
+ if (Align)
+ return *Align;
+ reportFatalUsageError("Invalid zero alignment argument");
+ };
+
const DataLayout &DL = CI->getDataLayout();
switch (NewFn->getIntrinsicID()) {
case Intrinsic::masked_load:
NewCall = Builder.CreateMaskedLoad(
- CI->getType(), CI->getArgOperand(0),
- cast<ConstantInt>(CI->getArgOperand(1))->getAlignValue(),
+ CI->getType(), CI->getArgOperand(0), GetAlign(CI->getArgOperand(1)),
CI->getArgOperand(2), CI->getArgOperand(3));
break;
case Intrinsic::masked_gather:
NewCall = Builder.CreateMaskedGather(
CI->getType(), CI->getArgOperand(0),
- DL.getValueOrABITypeAlignment(
- cast<ConstantInt>(CI->getArgOperand(1))->getMaybeAlignValue(),
- CI->getType()->getScalarType()),
+ DL.getValueOrABITypeAlignment(GetMaybeAlign(CI->getArgOperand(1)),
+ CI->getType()->getScalarType()),
CI->getArgOperand(2), CI->getArgOperand(3));
break;
case Intrinsic::masked_store:
NewCall = Builder.CreateMaskedStore(
CI->getArgOperand(0), CI->getArgOperand(1),
- cast<ConstantInt>(CI->getArgOperand(2))->getAlignValue(),
- CI->getArgOperand(3));
+ GetAlign(CI->getArgOperand(2)), CI->getArgOperand(3));
break;
case Intrinsic::masked_scatter:
NewCall = Builder.CreateMaskedScatter(
CI->getArgOperand(0), CI->getArgOperand(1),
DL.getValueOrABITypeAlignment(
- cast<ConstantInt>(CI->getArgOperand(2))->getMaybeAlignValue(),
+ GetMaybeAlign(CI->getArgOperand(2)),
CI->getArgOperand(0)->getType()->getScalarType()),
CI->getArgOperand(3));
break;
@@ -6045,6 +6059,120 @@ void llvm::UpgradeFunctionAttributes(Function &F) {
}
}
+// Check if the function attribute is not present and set it.
+static void setFunctionAttrIfNotSet(Function &F, StringRef FnAttrName,
+ StringRef Value) {
+ if (!F.hasFnAttribute(FnAttrName))
+ F.addFnAttr(FnAttrName, Value);
+}
+
+// Check if the function attribute is not present and set it if needed.
+// If the attribute is "false" then removes it.
+// If the attribute is "true" resets it to a valueless attribute.
+static void ConvertFunctionAttr(Function &F, bool Set, StringRef FnAttrName) {
+ if (!F.hasFnAttribute(FnAttrName)) {
+ if (Set)
+ F.addFnAttr(FnAttrName);
+ } else {
+ auto A = F.getFnAttribute(FnAttrName);
+ if ("false" == A.getValueAsString())
+ F.removeFnAttr(FnAttrName);
+ else if ("true" == A.getValueAsString()) {
+ F.removeFnAttr(FnAttrName);
+ F.addFnAttr(FnAttrName);
+ }
+ }
+}
+
+void llvm::copyModuleAttrToFunctions(Module &M) {
+ Triple T(M.getTargetTriple());
+ if (!T.isThumb() && !T.isARM() && !T.isAArch64())
+ return;
+
+ uint64_t BTEValue = 0;
+ uint64_t BPPLRValue = 0;
+ uint64_t GCSValue = 0;
+ uint64_t SRAValue = 0;
+ uint64_t SRAALLValue = 0;
+ uint64_t SRABKeyValue = 0;
+
+ NamedMDNode *ModFlags = M.getModuleFlagsMetadata();
+ if (ModFlags) {
+ for (unsigned I = 0, E = ModFlags->getNumOperands(); I != E; ++I) {
+ MDNode *Op = ModFlags->getOperand(I);
+ if (Op->getNumOperands() != 3)
+ continue;
+
+ MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1));
+ auto *CI = mdconst::dyn_extract<ConstantInt>(Op->getOperand(2));
+ if (!ID || !CI)
+ continue;
+
+ StringRef IDStr = ID->getString();
+ uint64_t *ValPtr = IDStr == "branch-target-enforcement" ? &BTEValue
+ : IDStr == "branch-protection-pauth-lr" ? &BPPLRValue
+ : IDStr == "guarded-control-stack" ? &GCSValue
+ : IDStr == "sign-return-address" ? &SRAValue
+ : IDStr == "sign-return-address-all" ? &SRAALLValue
+ : IDStr == "sign-return-address-with-bkey"
+ ? &SRABKeyValue
+ : nullptr;
+ if (!ValPtr)
+ continue;
+
+ *ValPtr = CI->getZExtValue();
+ if (*ValPtr == 2)
+ return;
+ }
+ }
+
+ bool BTE = BTEValue == 1;
+ bool BPPLR = BPPLRValue == 1;
+ bool GCS = GCSValue == 1;
+ bool SRA = SRAValue == 1;
+
+ StringRef SignTypeValue = "non-leaf";
+ if (SRA && SRAALLValue == 1)
+ SignTypeValue = "all";
+
+ StringRef SignKeyValue = "a_key";
+ if (SRA && SRABKeyValue == 1)
+ SignKeyValue = "b_key";
+
+ for (Function &F : M.getFunctionList()) {
+ if (F.isDeclaration())
+ continue;
+
+ if (SRA) {
+ setFunctionAttrIfNotSet(F, "sign-return-address", SignTypeValue);
+ setFunctionAttrIfNotSet(F, "sign-return-address-key", SignKeyValue);
+ } else {
+ if (auto A = F.getFnAttribute("sign-return-address");
+ A.isValid() && "none" == A.getValueAsString()) {
+ F.removeFnAttr("sign-return-address");
+ F.removeFnAttr("sign-return-address-key");
+ }
+ }
+ ConvertFunctionAttr(F, BTE, "branch-target-enforcement");
+ ConvertFunctionAttr(F, BPPLR, "branch-protection-pauth-lr");
+ ConvertFunctionAttr(F, GCS, "guarded-control-stack");
+ }
+
+ if (BTE)
+ M.setModuleFlag(llvm::Module::Min, "branch-target-enforcement", 2);
+ if (BPPLR)
+ M.setModuleFlag(llvm::Module::Min, "branch-protection-pauth-lr", 2);
+ if (GCS)
+ M.setModuleFlag(llvm::Module::Min, "guarded-control-stack", 2);
+ if (SRA) {
+ M.setModuleFlag(llvm::Module::Min, "sign-return-address", 2);
+ if (SRAALLValue == 1)
+ M.setModuleFlag(llvm::Module::Min, "sign-return-address-all", 2);
+ if (SRABKeyValue == 1)
+ M.setModuleFlag(llvm::Module::Min, "sign-return-address-with-bkey", 2);
+ }
+}
+
static bool isOldLoopArgument(Metadata *MD) {
auto *T = dyn_cast_or_null<MDTuple>(MD);
if (!T)
diff --git a/llvm/lib/IR/ModuleSummaryIndex.cpp b/llvm/lib/IR/ModuleSummaryIndex.cpp
index a6353664..62fd62c 100644
--- a/llvm/lib/IR/ModuleSummaryIndex.cpp
+++ b/llvm/lib/IR/ModuleSummaryIndex.cpp
@@ -111,11 +111,13 @@ uint64_t ModuleSummaryIndex::getFlags() const {
Flags |= 0x100;
if (hasUnifiedLTO())
Flags |= 0x200;
+ if (withInternalizeAndPromote())
+ Flags |= 0x400;
return Flags;
}
void ModuleSummaryIndex::setFlags(uint64_t Flags) {
- assert(Flags <= 0x2ff && "Unexpected bits in flag");
+ assert(Flags <= 0x7ff && "Unexpected bits in flag");
// 1 bit: WithGlobalValueDeadStripping flag.
// Set on combined index only.
if (Flags & 0x1)
@@ -154,6 +156,10 @@ void ModuleSummaryIndex::setFlags(uint64_t Flags) {
// Set on combined index only.
if (Flags & 0x200)
setUnifiedLTO();
+ // 1 bit: WithInternalizeAndPromote flag.
+ // Set on combined index only.
+ if (Flags & 0x400)
+ setWithInternalizeAndPromote();
}
// Collect for the given module the list of function it defines
diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp
index 03da154..7917712 100644
--- a/llvm/lib/IR/Verifier.cpp
+++ b/llvm/lib/IR/Verifier.cpp
@@ -4446,10 +4446,12 @@ void Verifier::visitLoadInst(LoadInst &LI) {
Check(LI.getOrdering() != AtomicOrdering::Release &&
LI.getOrdering() != AtomicOrdering::AcquireRelease,
"Load cannot have Release ordering", &LI);
- Check(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
- "atomic load operand must have integer, pointer, or floating point "
- "type!",
+ Check(ElTy->getScalarType()->isIntOrPtrTy() ||
+ ElTy->getScalarType()->isFloatingPointTy(),
+ "atomic load operand must have integer, pointer, floating point, "
+ "or vector type!",
ElTy, &LI);
+
checkAtomicMemAccessSize(ElTy, &LI);
} else {
Check(LI.getSyncScopeID() == SyncScope::System,
@@ -4472,9 +4474,10 @@ void Verifier::visitStoreInst(StoreInst &SI) {
Check(SI.getOrdering() != AtomicOrdering::Acquire &&
SI.getOrdering() != AtomicOrdering::AcquireRelease,
"Store cannot have Acquire ordering", &SI);
- Check(ElTy->isIntOrPtrTy() || ElTy->isFloatingPointTy(),
- "atomic store operand must have integer, pointer, or floating point "
- "type!",
+ Check(ElTy->getScalarType()->isIntOrPtrTy() ||
+ ElTy->getScalarType()->isFloatingPointTy(),
+ "atomic store operand must have integer, pointer, floating point, "
+ "or vector type!",
ElTy, &SI);
checkAtomicMemAccessSize(ElTy, &SI);
} else {
generated by cgit v1.1 at 2025-10-23 21:23:06 +0000