1 //=- AArch64MachineFunctionInfo.cpp - AArch64 Machine Function Info ---------=// 2 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 /// 10 /// \file 11 /// This file implements AArch64-specific per-machine-function 12 /// information. 13 /// 14 //===----------------------------------------------------------------------===// 15 16 #include "AArch64MachineFunctionInfo.h" 17 #include "AArch64InstrInfo.h" 18 #include "AArch64Subtarget.h" 19 #include "llvm/IR/Constants.h" 20 #include "llvm/IR/Metadata.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/MC/MCAsmInfo.h" 23 24 using namespace llvm; 25 26 yaml::AArch64FunctionInfo::AArch64FunctionInfo( 27 const llvm::AArch64FunctionInfo &MFI) 28 : HasRedZone(MFI.hasRedZone()) {} 29 30 void yaml::AArch64FunctionInfo::mappingImpl(yaml::IO &YamlIO) { 31 MappingTraits<AArch64FunctionInfo>::mapping(YamlIO, *this); 32 } 33 34 void AArch64FunctionInfo::initializeBaseYamlFields( 35 const yaml::AArch64FunctionInfo &YamlMFI) { 36 if (YamlMFI.HasRedZone) 37 HasRedZone = YamlMFI.HasRedZone; 38 } 39 40 static std::pair<bool, bool> GetSignReturnAddress(const Function &F) { 41 if (F.hasFnAttribute("ptrauth-returns")) 42 return {true, false}; // non-leaf 43 // The function should be signed in the following situations: 44 // - sign-return-address=all 45 // - sign-return-address=non-leaf and the functions spills the LR 46 if (!F.hasFnAttribute("sign-return-address")) 47 return {false, false}; 48 49 StringRef Scope = F.getFnAttribute("sign-return-address").getValueAsString(); 50 if (Scope == "none") 51 return {false, false}; 52 53 if (Scope == "all") 54 return {true, true}; 55 56 assert(Scope == "non-leaf"); 57 return {true, false}; 58 } 59 60 static bool ShouldSignWithBKey(const Function &F, const AArch64Subtarget &STI) { 61 if (F.hasFnAttribute("ptrauth-returns")) 62 return true; 63 if (!F.hasFnAttribute("sign-return-address-key")) { 64 if (STI.getTargetTriple().isOSWindows()) 65 return true; 66 return false; 67 } 68 69 const StringRef Key = 70 F.getFnAttribute("sign-return-address-key").getValueAsString(); 71 assert(Key == "a_key" || Key == "b_key"); 72 return Key == "b_key"; 73 } 74 75 static bool hasELFSignedGOTHelper(const Function &F, 76 const AArch64Subtarget *STI) { 77 if (!Triple(STI->getTargetTriple()).isOSBinFormatELF()) 78 return false; 79 const Module *M = F.getParent(); 80 const auto *Flag = mdconst::extract_or_null<ConstantInt>( 81 M->getModuleFlag("ptrauth-elf-got")); 82 if (Flag && Flag->getZExtValue() == 1) 83 return true; 84 return false; 85 } 86 87 AArch64FunctionInfo::AArch64FunctionInfo(const Function &F, 88 const AArch64Subtarget *STI) { 89 // If we already know that the function doesn't have a redzone, set 90 // HasRedZone here. 91 if (F.hasFnAttribute(Attribute::NoRedZone)) 92 HasRedZone = false; 93 std::tie(SignReturnAddress, SignReturnAddressAll) = GetSignReturnAddress(F); 94 SignWithBKey = ShouldSignWithBKey(F, *STI); 95 HasELFSignedGOT = hasELFSignedGOTHelper(F, STI); 96 // TODO: skip functions that have no instrumented allocas for optimization 97 IsMTETagged = F.hasFnAttribute(Attribute::SanitizeMemTag); 98 99 // BTI/PAuthLR are set on the function attribute. 100 BranchTargetEnforcement = F.hasFnAttribute("branch-target-enforcement"); 101 BranchProtectionPAuthLR = F.hasFnAttribute("branch-protection-pauth-lr"); 102 103 // The default stack probe size is 4096 if the function has no 104 // stack-probe-size attribute. This is a safe default because it is the 105 // smallest possible guard page size. 106 uint64_t ProbeSize = 4096; 107 if (F.hasFnAttribute("stack-probe-size")) 108 ProbeSize = F.getFnAttributeAsParsedInteger("stack-probe-size"); 109 else if (const auto *PS = mdconst::extract_or_null<ConstantInt>( 110 F.getParent()->getModuleFlag("stack-probe-size"))) 111 ProbeSize = PS->getZExtValue(); 112 assert(int64_t(ProbeSize) > 0 && "Invalid stack probe size"); 113 114 if (STI->isTargetWindows()) { 115 if (!F.hasFnAttribute("no-stack-arg-probe")) 116 StackProbeSize = ProbeSize; 117 } else { 118 // Round down to the stack alignment. 119 uint64_t StackAlign = 120 STI->getFrameLowering()->getTransientStackAlign().value(); 121 ProbeSize = std::max(StackAlign, ProbeSize & ~(StackAlign - 1U)); 122 StringRef ProbeKind; 123 if (F.hasFnAttribute("probe-stack")) 124 ProbeKind = F.getFnAttribute("probe-stack").getValueAsString(); 125 else if (const auto *PS = dyn_cast_or_null<MDString>( 126 F.getParent()->getModuleFlag("probe-stack"))) 127 ProbeKind = PS->getString(); 128 if (ProbeKind.size()) { 129 if (ProbeKind != "inline-asm") 130 report_fatal_error("Unsupported stack probing method"); 131 StackProbeSize = ProbeSize; 132 } 133 } 134 } 135 136 MachineFunctionInfo *AArch64FunctionInfo::clone( 137 BumpPtrAllocator &Allocator, MachineFunction &DestMF, 138 const DenseMap<MachineBasicBlock *, MachineBasicBlock *> &Src2DstMBB) 139 const { 140 return DestMF.cloneInfo<AArch64FunctionInfo>(*this); 141 } 142 143 bool AArch64FunctionInfo::shouldSignReturnAddress(bool SpillsLR) const { 144 if (!SignReturnAddress) 145 return false; 146 if (SignReturnAddressAll) 147 return true; 148 return SpillsLR; 149 } 150 151 static bool isLRSpilled(const MachineFunction &MF) { 152 return llvm::any_of( 153 MF.getFrameInfo().getCalleeSavedInfo(), 154 [](const auto &Info) { return Info.getReg() == AArch64::LR; }); 155 } 156 157 bool AArch64FunctionInfo::shouldSignReturnAddress( 158 const MachineFunction &MF) const { 159 return shouldSignReturnAddress(isLRSpilled(MF)); 160 } 161 162 bool AArch64FunctionInfo::needsShadowCallStackPrologueEpilogue( 163 MachineFunction &MF) const { 164 if (!(isLRSpilled(MF) && 165 MF.getFunction().hasFnAttribute(Attribute::ShadowCallStack))) 166 return false; 167 168 if (!MF.getSubtarget<AArch64Subtarget>().isXRegisterReserved(18)) 169 report_fatal_error("Must reserve x18 to use shadow call stack"); 170 171 return true; 172 } 173 174 bool AArch64FunctionInfo::needsDwarfUnwindInfo( 175 const MachineFunction &MF) const { 176 if (!NeedsDwarfUnwindInfo) 177 NeedsDwarfUnwindInfo = MF.needsFrameMoves() && 178 !MF.getTarget().getMCAsmInfo()->usesWindowsCFI(); 179 180 return *NeedsDwarfUnwindInfo; 181 } 182 183 bool AArch64FunctionInfo::needsAsyncDwarfUnwindInfo( 184 const MachineFunction &MF) const { 185 if (!NeedsAsyncDwarfUnwindInfo) { 186 const Function &F = MF.getFunction(); 187 const AArch64FunctionInfo *AFI = MF.getInfo<AArch64FunctionInfo>(); 188 // The check got "minsize" is because epilogue unwind info is not emitted 189 // (yet) for homogeneous epilogues, outlined functions, and functions 190 // outlined from. 191 NeedsAsyncDwarfUnwindInfo = 192 needsDwarfUnwindInfo(MF) && 193 ((F.getUWTableKind() == UWTableKind::Async && !F.hasMinSize()) || 194 AFI->hasStreamingModeChanges()); 195 } 196 return *NeedsAsyncDwarfUnwindInfo; 197 } 198