LLVM 19.0.0git
SMEABIPass.cpp
Go to the documentation of this file.
1//===--------- SMEABI - SME ABI-------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This pass implements parts of the the SME ABI, such as:
10// * Using the lazy-save mechanism before enabling the use of ZA.
11// * Setting up the lazy-save mechanism around invokes.
12//
13//===----------------------------------------------------------------------===//
14
15#include "AArch64.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/IR/Constants.h"
20#include "llvm/IR/IRBuilder.h"
23#include "llvm/IR/IntrinsicsAArch64.h"
24#include "llvm/IR/LLVMContext.h"
25#include "llvm/IR/Module.h"
27#include "llvm/Support/Debug.h"
29
30using namespace llvm;
31
32#define DEBUG_TYPE "aarch64-sme-abi"
33
34namespace {
35struct SMEABI : public FunctionPass {
36 static char ID; // Pass identification, replacement for typeid
37 SMEABI() : FunctionPass(ID) {
39 }
40
41 bool runOnFunction(Function &F) override;
42
43private:
44 bool updateNewStateFunctions(Module *M, Function *F, IRBuilder<> &Builder,
45 SMEAttrs FnAttrs);
46};
47} // end anonymous namespace
48
49char SMEABI::ID = 0;
50static const char *name = "SME ABI Pass";
51INITIALIZE_PASS_BEGIN(SMEABI, DEBUG_TYPE, name, false, false)
53
54FunctionPass *llvm::createSMEABIPass() { return new SMEABI(); }
55
56//===----------------------------------------------------------------------===//
57// Utility functions
58//===----------------------------------------------------------------------===//
59
60// Utility function to emit a call to __arm_tpidr2_save and clear TPIDR2_EL0.
61void emitTPIDR2Save(Module *M, IRBuilder<> &Builder) {
62 auto *TPIDR2SaveTy =
63 FunctionType::get(Builder.getVoidTy(), {}, /*IsVarArgs=*/false);
64 auto Attrs = AttributeList().addFnAttribute(M->getContext(),
65 "aarch64_pstate_sm_compatible");
66 FunctionCallee Callee =
67 M->getOrInsertFunction("__arm_tpidr2_save", TPIDR2SaveTy, Attrs);
68 CallInst *Call = Builder.CreateCall(Callee);
69 Call->setCallingConv(
71
72 // A save to TPIDR2 should be followed by clearing TPIDR2_EL0.
73 Function *WriteIntr =
74 Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_set_tpidr2);
75 Builder.CreateCall(WriteIntr->getFunctionType(), WriteIntr,
76 Builder.getInt64(0));
77}
78
79/// This function generates code at the beginning and end of a function marked
80/// with either `aarch64_new_za` or `aarch64_new_zt0`.
81/// At the beginning of the function, the following code is generated:
82/// - Commit lazy-save if active [Private-ZA Interface*]
83/// - Enable PSTATE.ZA [Private-ZA Interface]
84/// - Zero ZA [Has New ZA State]
85/// - Zero ZT0 [Has New ZT0 State]
86///
87/// * A function with new ZT0 state will not change ZA, so committing the
88/// lazy-save is not strictly necessary. However, the lazy-save mechanism
89/// may be active on entry to the function, with PSTATE.ZA set to 1. If
90/// the new ZT0 function calls a function that does not share ZT0, we will
91/// need to conditionally SMSTOP ZA before the call, setting PSTATE.ZA to 0.
92/// For this reason, it's easier to always commit the lazy-save at the
93/// beginning of the function regardless of whether it has ZA state.
94///
95/// At the end of the function, PSTATE.ZA is disabled if the function has a
96/// Private-ZA Interface. A function is considered to have a Private-ZA
97/// interface if it does not share ZA or ZT0.
98///
99bool SMEABI::updateNewStateFunctions(Module *M, Function *F,
100 IRBuilder<> &Builder, SMEAttrs FnAttrs) {
101 LLVMContext &Context = F->getContext();
102 BasicBlock *OrigBB = &F->getEntryBlock();
103 Builder.SetInsertPoint(&OrigBB->front());
104
105 // Commit any active lazy-saves if this is a Private-ZA function. If the
106 // value read from TPIDR2_EL0 is not null on entry to the function then
107 // the lazy-saving scheme is active and we should call __arm_tpidr2_save
108 // to commit the lazy save.
109 if (FnAttrs.hasPrivateZAInterface()) {
110 // Create the new blocks for reading TPIDR2_EL0 & enabling ZA state.
111 auto *SaveBB = OrigBB->splitBasicBlock(OrigBB->begin(), "save.za", true);
112 auto *PreludeBB = BasicBlock::Create(Context, "prelude", F, SaveBB);
113
114 // Read TPIDR2_EL0 in PreludeBB & branch to SaveBB if not 0.
115 Builder.SetInsertPoint(PreludeBB);
116 Function *TPIDR2Intr =
117 Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_get_tpidr2);
118 auto *TPIDR2 = Builder.CreateCall(TPIDR2Intr->getFunctionType(), TPIDR2Intr,
119 {}, "tpidr2");
120 auto *Cmp = Builder.CreateCmp(ICmpInst::ICMP_NE, TPIDR2,
121 Builder.getInt64(0), "cmp");
122 Builder.CreateCondBr(Cmp, SaveBB, OrigBB);
123
124 // Create a call __arm_tpidr2_save, which commits the lazy save.
125 Builder.SetInsertPoint(&SaveBB->back());
126 emitTPIDR2Save(M, Builder);
127
128 // Enable pstate.za at the start of the function.
129 Builder.SetInsertPoint(&OrigBB->front());
130 Function *EnableZAIntr =
131 Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_za_enable);
132 Builder.CreateCall(EnableZAIntr->getFunctionType(), EnableZAIntr);
133 }
134
135 if (FnAttrs.isNewZA()) {
136 Function *ZeroIntr =
137 Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_zero);
138 Builder.CreateCall(ZeroIntr->getFunctionType(), ZeroIntr,
139 Builder.getInt32(0xff));
140 }
141
142 if (FnAttrs.isNewZT0()) {
143 Function *ClearZT0Intr =
144 Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_zero_zt);
145 Builder.CreateCall(ClearZT0Intr->getFunctionType(), ClearZT0Intr,
146 {Builder.getInt32(0)});
147 }
148
149 if (FnAttrs.hasPrivateZAInterface()) {
150 // Before returning, disable pstate.za
151 for (BasicBlock &BB : *F) {
152 Instruction *T = BB.getTerminator();
153 if (!T || !isa<ReturnInst>(T))
154 continue;
155 Builder.SetInsertPoint(T);
156 Function *DisableZAIntr =
157 Intrinsic::getDeclaration(M, Intrinsic::aarch64_sme_za_disable);
158 Builder.CreateCall(DisableZAIntr->getFunctionType(), DisableZAIntr);
159 }
160 }
161
162 F->addFnAttr("aarch64_expanded_pstate_za");
163 return true;
164}
165
166bool SMEABI::runOnFunction(Function &F) {
167 Module *M = F.getParent();
168 LLVMContext &Context = F.getContext();
169 IRBuilder<> Builder(Context);
170
171 if (F.isDeclaration() || F.hasFnAttribute("aarch64_expanded_pstate_za"))
172 return false;
173
174 bool Changed = false;
175 SMEAttrs FnAttrs(F);
176 if (FnAttrs.isNewZA() || FnAttrs.isNewZT0())
177 Changed |= updateNewStateFunctions(M, &F, Builder, FnAttrs);
178
179 return Changed;
180}
This file contains the declarations for the subclasses of Constant, which represent the different fla...
#define F(x, y, z)
Definition: MD5.cpp:55
Module.h This file contains the declarations for the Module class.
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:59
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:52
void emitTPIDR2Save(Module *M, IRBuilder<> &Builder)
Definition: SMEABIPass.cpp:61
static const char * name
Definition: SMEABIPass.cpp:50
#define DEBUG_TYPE
Definition: SMEABIPass.cpp:32
AttributeList addFnAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Add a function attribute to the list.
Definition: Attributes.h:555
LLVM Basic Block Representation.
Definition: BasicBlock.h:61
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:438
const Instruction & front() const
Definition: BasicBlock.h:461
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:202
BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="", bool Before=false)
Split the basic block into two basic blocks at the specified instruction.
Definition: BasicBlock.cpp:575
This class represents a function call, abstracting a target machine's calling convention.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:168
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
virtual bool runOnFunction(Function &F)=0
runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:207
ConstantInt * getInt64(uint64_t C)
Get a constant 64-bit value.
Definition: IRBuilder.h:488
ConstantInt * getInt32(uint32_t C)
Get a constant 32-bit value.
Definition: IRBuilder.h:483
Value * CreateCmp(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2371
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:1125
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
Definition: IRBuilder.h:177
Type * getVoidTy()
Fetch the type representing void.
Definition: IRBuilder.h:561
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2417
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2671
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
SMEAttrs is a utility class to parse the SME ACLE attributes on functions.
bool hasPrivateZAInterface() const
bool isNewZA() const
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
@ AArch64_SME_ABI_Support_Routines_PreserveMost_From_X0
Preserve X0-X13, X19-X29, SP, Z0-Z31, P0-P15.
Definition: CallingConv.h:238
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1513
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
FunctionPass * createSMEABIPass()
Definition: SMEABIPass.cpp:54
void initializeSMEABIPass(PassRegistry &)