LLVM 19.0.0git
AArch64MachineFunctionInfo.cpp
Go to the documentation of this file.
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
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
24using namespace llvm;
25
28 : HasRedZone(MFI.hasRedZone()) {}
29
32}
33
35 const yaml::AArch64FunctionInfo &YamlMFI) {
36 if (YamlMFI.HasRedZone)
37 HasRedZone = YamlMFI.HasRedZone;
38}
39
40static std::pair<bool, bool> GetSignReturnAddress(const Function &F) {
41 // The function should be signed in the following situations:
42 // - sign-return-address=all
43 // - sign-return-address=non-leaf and the functions spills the LR
44 if (!F.hasFnAttribute("sign-return-address")) {
45 const Module &M = *F.getParent();
46 if (const auto *Sign = mdconst::extract_or_null<ConstantInt>(
47 M.getModuleFlag("sign-return-address"))) {
48 if (Sign->getZExtValue()) {
49 if (const auto *All = mdconst::extract_or_null<ConstantInt>(
50 M.getModuleFlag("sign-return-address-all")))
51 return {true, All->getZExtValue()};
52 return {true, false};
53 }
54 }
55 return {false, false};
56 }
57
58 StringRef Scope = F.getFnAttribute("sign-return-address").getValueAsString();
59 if (Scope.equals("none"))
60 return {false, false};
61
62 if (Scope.equals("all"))
63 return {true, true};
64
65 assert(Scope.equals("non-leaf"));
66 return {true, false};
67}
68
69static bool ShouldSignWithBKey(const Function &F, const AArch64Subtarget &STI) {
70 if (!F.hasFnAttribute("sign-return-address-key")) {
71 if (const auto *BKey = mdconst::extract_or_null<ConstantInt>(
72 F.getParent()->getModuleFlag("sign-return-address-with-bkey")))
73 return BKey->getZExtValue();
74 if (STI.getTargetTriple().isOSWindows())
75 return true;
76 return false;
77 }
78
79 const StringRef Key =
80 F.getFnAttribute("sign-return-address-key").getValueAsString();
81 assert(Key == "a_key" || Key == "b_key");
82 return Key == "b_key";
83}
84
86 const AArch64Subtarget *STI) {
87 // If we already know that the function doesn't have a redzone, set
88 // HasRedZone here.
89 if (F.hasFnAttribute(Attribute::NoRedZone))
90 HasRedZone = false;
91 std::tie(SignReturnAddress, SignReturnAddressAll) = GetSignReturnAddress(F);
92 SignWithBKey = ShouldSignWithBKey(F, *STI);
93 // TODO: skip functions that have no instrumented allocas for optimization
94 IsMTETagged = F.hasFnAttribute(Attribute::SanitizeMemTag);
95
96 // BTI/PAuthLR may be set either on the function or the module. Set Bool from
97 // either the function attribute or module attribute, depending on what is
98 // set.
99 // Note: the module attributed is numeric (0 or 1) but the function attribute
100 // is stringy ("true" or "false").
101 auto TryFnThenModule = [&](StringRef AttrName, bool &Bool) {
102 if (F.hasFnAttribute(AttrName)) {
103 const StringRef V = F.getFnAttribute(AttrName).getValueAsString();
104 assert(V.equals_insensitive("true") || V.equals_insensitive("false"));
105 Bool = V.equals_insensitive("true");
106 } else if (const auto *ModVal = mdconst::extract_or_null<ConstantInt>(
107 F.getParent()->getModuleFlag(AttrName))) {
108 Bool = ModVal->getZExtValue();
109 }
110 };
111
112 TryFnThenModule("branch-target-enforcement", BranchTargetEnforcement);
113 TryFnThenModule("branch-protection-pauth-lr", BranchProtectionPAuthLR);
114
115 // The default stack probe size is 4096 if the function has no
116 // stack-probe-size attribute. This is a safe default because it is the
117 // smallest possible guard page size.
118 uint64_t ProbeSize = 4096;
119 if (F.hasFnAttribute("stack-probe-size"))
120 ProbeSize = F.getFnAttributeAsParsedInteger("stack-probe-size");
121 else if (const auto *PS = mdconst::extract_or_null<ConstantInt>(
122 F.getParent()->getModuleFlag("stack-probe-size")))
123 ProbeSize = PS->getZExtValue();
124 assert(int64_t(ProbeSize) > 0 && "Invalid stack probe size");
125
126 if (STI->isTargetWindows()) {
127 if (!F.hasFnAttribute("no-stack-arg-probe"))
128 StackProbeSize = ProbeSize;
129 } else {
130 // Round down to the stack alignment.
131 uint64_t StackAlign =
133 ProbeSize = std::max(StackAlign, ProbeSize & ~(StackAlign - 1U));
134 StringRef ProbeKind;
135 if (F.hasFnAttribute("probe-stack"))
136 ProbeKind = F.getFnAttribute("probe-stack").getValueAsString();
137 else if (const auto *PS = dyn_cast_or_null<MDString>(
138 F.getParent()->getModuleFlag("probe-stack")))
139 ProbeKind = PS->getString();
140 if (ProbeKind.size()) {
141 if (ProbeKind != "inline-asm")
142 report_fatal_error("Unsupported stack probing method");
143 StackProbeSize = ProbeSize;
144 }
145 }
146}
147
149 BumpPtrAllocator &Allocator, MachineFunction &DestMF,
151 const {
152 return DestMF.cloneInfo<AArch64FunctionInfo>(*this);
153}
154
156 if (!SignReturnAddress)
157 return false;
158 if (SignReturnAddressAll)
159 return true;
160 return SpillsLR;
161}
162
163static bool isLRSpilled(const MachineFunction &MF) {
164 return llvm::any_of(
165 MF.getFrameInfo().getCalleeSavedInfo(),
166 [](const auto &Info) { return Info.getReg() == AArch64::LR; });
167}
168
170 const MachineFunction &MF) const {
171 return shouldSignReturnAddress(isLRSpilled(MF));
172}
173
175 MachineFunction &MF) const {
176 if (!(isLRSpilled(MF) &&
177 MF.getFunction().hasFnAttribute(Attribute::ShadowCallStack)))
178 return false;
179
181 report_fatal_error("Must reserve x18 to use shadow call stack");
182
183 return true;
184}
185
187 const MachineFunction &MF) const {
188 if (!NeedsDwarfUnwindInfo)
189 NeedsDwarfUnwindInfo = MF.needsFrameMoves() &&
191
192 return *NeedsDwarfUnwindInfo;
193}
194
196 const MachineFunction &MF) const {
197 if (!NeedsAsyncDwarfUnwindInfo) {
198 const Function &F = MF.getFunction();
199 // The check got "minsize" is because epilogue unwind info is not emitted
200 // (yet) for homogeneous epilogues, outlined functions, and functions
201 // outlined from.
202 NeedsAsyncDwarfUnwindInfo = needsDwarfUnwindInfo(MF) &&
203 F.getUWTableKind() == UWTableKind::Async &&
204 !F.hasMinSize();
205 }
206 return *NeedsAsyncDwarfUnwindInfo;
207}
static std::pair< bool, bool > GetSignReturnAddress(const Function &F)
static bool ShouldSignWithBKey(const Function &F, const AArch64Subtarget &STI)
static bool isLRSpilled(const MachineFunction &MF)
Analysis containing CSE Info
Definition: CSEInfo.cpp:27
This file contains the declarations for the subclasses of Constant, which represent the different fla...
IO & YamlIO
Definition: ELFYAML.cpp:1290
#define F(x, y, z)
Definition: MD5.cpp:55
This file contains the declarations for metadata subclasses.
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
AArch64FunctionInfo - This class is derived from MachineFunctionInfo and contains private AArch64-spe...
bool needsShadowCallStackPrologueEpilogue(MachineFunction &MF) const
bool shouldSignReturnAddress(const MachineFunction &MF) const
bool needsDwarfUnwindInfo(const MachineFunction &MF) const
void initializeBaseYamlFields(const yaml::AArch64FunctionInfo &YamlMFI)
bool needsAsyncDwarfUnwindInfo(const MachineFunction &MF) const
MachineFunctionInfo * clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF, const DenseMap< MachineBasicBlock *, MachineBasicBlock * > &Src2DstMBB) const override
Make a functionally equivalent copy of this MachineFunctionInfo in MF.
const Triple & getTargetTriple() const
bool isXRegisterReserved(size_t i) const
const AArch64FrameLowering * getFrameLowering() const override
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:66
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:683
bool usesWindowsCFI() const
Definition: MCAsmInfo.h:799
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
bool needsFrameMoves() const
True if this function needs frame moves for debug or exceptions.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
Function & getFunction()
Return the LLVM function that this machine code represents.
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
Ty * cloneInfo(const Ty &Old)
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
Align getTransientStackAlign() const
getTransientStackAlignment - This method returns the number of bytes to which the stack pointer must ...
const MCAsmInfo * getMCAsmInfo() const
Return target specific asm information.
bool isOSWindows() const
Tests whether the OS is Windows.
Definition: Triple.h:608
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1729
@ Async
"Asynchronous" unwind tables (instr precise)
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:156
uint64_t value() const
This is a hole in the type system and should not be abused.
Definition: Alignment.h:85
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
void mappingImpl(yaml::IO &YamlIO) override