1//===- CallingConvEmitter.cpp - Generate calling conventions --------------===//
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 tablegen backend is responsible for emitting descriptions of the calling
10// conventions supported by this target.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Common/CodeGenRegisters.h"
15#include "Common/CodeGenTarget.h"
16#include "llvm/Support/FormatVariadic.h"
17#include "llvm/Support/InterleavedRange.h"
18#include "llvm/TableGen/CodeGenHelpers.h"
19#include "llvm/TableGen/Error.h"
20#include "llvm/TableGen/Record.h"
21#include "llvm/TableGen/TGTimer.h"
22#include "llvm/TableGen/TableGenBackend.h"
23#include <deque>
24#include <set>
25
26using namespace llvm;
27
28namespace {
29class CallingConvEmitter {
30 const RecordKeeper &Records;
31 const CodeGenTarget Target;
32 unsigned Counter = 0u;
33 std::string CurrentAction;
34 bool SwiftAction = false;
35
36 std::map<std::string, std::set<std::string>> AssignedRegsMap;
37 std::map<std::string, std::set<std::string>> AssignedSwiftRegsMap;
38 std::map<std::string, std::set<std::string>> DelegateToMap;
39
40public:
41 explicit CallingConvEmitter(const RecordKeeper &R) : Records(R), Target(R) {}
42
43 void run(raw_ostream &O);
44
45private:
46 void emitCallingConv(const Record *CC, raw_ostream &O);
47 void emitAction(const Record *Action, indent Indent, raw_ostream &O);
48 void emitArgRegisterLists(raw_ostream &O);
49
50 StringMap<const CodeGenRegister *> RegistersByDefName;
51 std::string getQualifiedRegisterName(const Init *I);
52};
53} // End anonymous namespace
54
55static void emitCCHeader(raw_ostream &O, const Record *CC, StringRef Suffix) {
56 unsigned Pad = CC->getName().size();
57 if (CC->getValueAsBit(FieldName: "Entry")) {
58 O << "bool llvm::";
59 Pad += 12;
60 } else {
61 O << "static bool ";
62 Pad += 13;
63 }
64 O << CC->getName() << "(unsigned ValNo, MVT ValVT,\n"
65 << indent(Pad) << "MVT LocVT, CCValAssign::LocInfo LocInfo,\n"
66 << indent(Pad) << "ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State)"
67 << Suffix;
68}
69
70void CallingConvEmitter::run(raw_ostream &O) {
71 emitSourceFileHeader(Desc: "Calling Convention Implementation Fragment", OS&: O);
72
73 ArrayRef<const Record *> CCs =
74 Records.getAllDerivedDefinitions(ClassName: "CallingConv");
75
76 // Emit prototypes for all of the non-custom CC's so that they can forward ref
77 // each other.
78 Records.getTimer().startTimer(Name: "Emit prototypes");
79 {
80 IfDefEmitter IfGuard(O, "GET_CALLING_CONV_IMPL");
81 for (const Record *CC : CCs) {
82 if (!CC->getValueAsBit(FieldName: "Custom"))
83 emitCCHeader(O, CC, Suffix: ";\n");
84 }
85
86 // Emit each non-custom calling convention description in full.
87 Records.getTimer().startTimer(Name: "Emit full descriptions");
88 for (const Record *CC : CCs) {
89 if (!CC->getValueAsBit(FieldName: "Custom"))
90 emitCallingConv(CC, O);
91 }
92 }
93
94 emitArgRegisterLists(O);
95}
96
97void CallingConvEmitter::emitCallingConv(const Record *CC, raw_ostream &O) {
98 const ListInit *CCActions = CC->getValueAsListInit(FieldName: "Actions");
99 Counter = 0;
100
101 CurrentAction = CC->getName().str();
102 // Call upon the creation of a map entry from the void!
103 // We want an entry in AssignedRegsMap for every action, even if that
104 // entry is empty.
105 AssignedRegsMap[CurrentAction] = {};
106
107 O << "\n\n";
108 emitCCHeader(O, CC, Suffix: " {\n");
109 // Emit all of the actions, in order.
110 for (unsigned I = 0, E = CCActions->size(); I != E; ++I) {
111 const Record *Action = CCActions->getElementAsRecord(Idx: I);
112 SwiftAction =
113 llvm::any_of(Range: Action->getSuperClasses(), P: [](const Record *Class) {
114 std::string Name = Class->getNameInitAsString();
115 return StringRef(Name).starts_with(Prefix: "CCIfSwift");
116 });
117
118 O << "\n";
119 emitAction(Action, Indent: indent(2), O);
120 }
121
122 O << "\n return true; // CC didn't match.\n";
123 O << "}\n";
124}
125
126// Return the name of the specified Init (DefInit or StringInit), with a
127// namespace qualifier if the corresponding record contains one.
128std::string CallingConvEmitter::getQualifiedRegisterName(const Init *I) {
129 if (const auto *DI = dyn_cast<DefInit>(Val: I))
130 return getQualifiedName(R: DI->getDef());
131
132 // Registers named by strings may be synthesized by the register bank, so
133 // build it, but only when needed.
134 if (RegistersByDefName.empty()) {
135 for (const CodeGenRegister &Reg : Target.getRegBank().getRegisters())
136 RegistersByDefName.try_emplace(Key: Reg.getName(), Args: &Reg);
137 }
138
139 const auto *SI = cast<StringInit>(Val: I);
140 if (const CodeGenRegister *CGR = RegistersByDefName.lookup(Key: SI->getValue()))
141 return getQualifiedName(R: CGR->TheDef);
142
143 PrintFatalError(Msg: "register not defined: " + SI->getAsString());
144 return "";
145}
146
147void CallingConvEmitter::emitAction(const Record *Action, indent Indent,
148 raw_ostream &O) {
149
150 auto EmitRegList = [&](const ListInit *RL, const StringRef RLName) {
151 O << Indent << "static const MCPhysReg " << RLName << "[] = {\n";
152 O << Indent << " ";
153 ListSeparator LS;
154 for (const Init *V : RL->getElements())
155 O << LS << getQualifiedRegisterName(I: V);
156 O << "\n" << Indent << "};\n";
157 };
158
159 auto EmitAllocateReg = [&](ArrayRef<const ListInit *> RegLists,
160 ArrayRef<std::string> RLNames) {
161 SmallVector<std::string> Parms;
162 if (RegLists[0]->size() == 1) {
163 for (const ListInit *LI : RegLists)
164 Parms.push_back(Elt: getQualifiedRegisterName(I: LI->getElement(Idx: 0)));
165 } else {
166 for (const std::string &S : RLNames)
167 Parms.push_back(Elt: S + utostr(X: ++Counter));
168 for (const auto [Idx, LI] : enumerate(First&: RegLists))
169 EmitRegList(LI, Parms[Idx]);
170 }
171 O << formatv(Fmt: "{0}if (MCRegister Reg = State.AllocateReg({1})) {{\n", Vals&: Indent,
172 Vals: make_range(x: Parms.begin(), y: Parms.end()));
173 O << Indent << " State.addLoc(CCValAssign::getReg(ValNo, ValVT, "
174 << "Reg, LocVT, LocInfo));\n";
175 };
176
177 auto EmitAllocateStack = [&](bool EmitOffset = false) {
178 int Size = Action->getValueAsInt(FieldName: "Size");
179 int Align = Action->getValueAsInt(FieldName: "Align");
180 if (EmitOffset)
181 O << Indent << "int64_t Offset" << ++Counter << " = ";
182 else
183 O << Indent << " (void)";
184 O << "State.AllocateStack(";
185
186 const char *Fmt = " State.getMachineFunction().getDataLayout()."
187 "{0}(EVT(LocVT).getTypeForEVT(State.getContext()))";
188 if (Size)
189 O << Size << ", ";
190 else
191 O << "\n" << Indent << formatv(Fmt, Vals: "getTypeAllocSize") << ", ";
192 if (Align)
193 O << "Align(" << Align << ")";
194 else
195 O << "\n" << Indent << formatv(Fmt, Vals: "getABITypeAlign");
196 O << ");\n";
197 };
198
199 if (Action->isSubClassOf(Name: "CCPredicateAction")) {
200 O << Indent << "if (";
201
202 if (Action->isSubClassOf(Name: "CCIfType")) {
203 const ListInit *VTs = Action->getValueAsListInit(FieldName: "VTs");
204 for (unsigned I = 0, E = VTs->size(); I != E; ++I) {
205 const Record *VT = VTs->getElementAsRecord(Idx: I);
206 if (I != 0)
207 O << " ||\n " << Indent;
208 O << "LocVT == " << getEnumName(T: getValueType(Rec: VT));
209 }
210
211 } else if (Action->isSubClassOf(Name: "CCIf")) {
212 O << Action->getValueAsString(FieldName: "Predicate");
213 } else {
214 errs() << *Action;
215 PrintFatalError(ErrorLoc: Action->getLoc(), Msg: "Unknown CCPredicateAction!");
216 }
217
218 O << ") {\n";
219 emitAction(Action: Action->getValueAsDef(FieldName: "SubAction"), Indent: Indent + 2, O);
220 O << Indent << "}\n";
221 return;
222 }
223
224 if (Action->isSubClassOf(Name: "CCDelegateTo")) {
225 const Record *CC = Action->getValueAsDef(FieldName: "CC");
226 O << Indent << "if (!" << CC->getName()
227 << "(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))\n"
228 << Indent + 2 << "return false;\n";
229 DelegateToMap[CurrentAction].insert(x: CC->getName().str());
230 } else if (Action->isSubClassOf(Name: "CCAssignToReg") ||
231 Action->isSubClassOf(Name: "CCAssignToRegTuple") ||
232 Action->isSubClassOf(Name: "CCAssignToRegAndStack")) {
233 const ListInit *RegList = Action->getValueAsListInit(FieldName: "RegList");
234 for (unsigned I = 0, E = RegList->size(); I != E; ++I) {
235 std::string Name = getQualifiedRegisterName(I: RegList->getElement(Idx: I));
236 if (SwiftAction)
237 AssignedSwiftRegsMap[CurrentAction].insert(x: std::move(Name));
238 else
239 AssignedRegsMap[CurrentAction].insert(x: std::move(Name));
240 }
241 EmitAllocateReg({RegList}, {"RegList"});
242
243 if (Action->isSubClassOf(Name: "CCAssignToRegAndStack"))
244 EmitAllocateStack();
245
246 O << Indent << " return false;\n";
247 O << Indent << "}\n";
248 } else if (Action->isSubClassOf(Name: "CCAssignToRegWithShadow")) {
249 const ListInit *RegList = Action->getValueAsListInit(FieldName: "RegList");
250 const ListInit *ShadowRegList = Action->getValueAsListInit(FieldName: "ShadowRegList");
251 if (!ShadowRegList->empty() && ShadowRegList->size() != RegList->size())
252 PrintFatalError(ErrorLoc: Action->getLoc(),
253 Msg: "Invalid length of list of shadowed registers");
254
255 EmitAllocateReg({RegList, ShadowRegList}, {"RegList", "RegList"});
256
257 O << Indent << " return false;\n";
258 O << Indent << "}\n";
259 } else if (Action->isSubClassOf(Name: "CCAssignToStack")) {
260 EmitAllocateStack(/*EmitOffset=*/true);
261 O << Indent << "State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset"
262 << Counter << ", LocVT, LocInfo));\n";
263 O << Indent << "return false;\n";
264 } else if (Action->isSubClassOf(Name: "CCAssignToStackWithShadow")) {
265 int Size = Action->getValueAsInt(FieldName: "Size");
266 int Align = Action->getValueAsInt(FieldName: "Align");
267 const ListInit *ShadowRegList = Action->getValueAsListInit(FieldName: "ShadowRegList");
268
269 unsigned ShadowRegListNumber = ++Counter;
270 EmitRegList(ShadowRegList, "ShadowRegList" + utostr(X: ShadowRegListNumber));
271
272 O << Indent << "int64_t Offset" << ++Counter << " = State.AllocateStack("
273 << Size << ", Align(" << Align << "), "
274 << "ShadowRegList" << ShadowRegListNumber << ");\n";
275 O << Indent << "State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset"
276 << Counter << ", LocVT, LocInfo));\n";
277 O << Indent << "return false;\n";
278 } else if (Action->isSubClassOf(Name: "CCPromoteToType")) {
279 const Record *DestTy = Action->getValueAsDef(FieldName: "DestTy");
280 MVT DestVT = getValueType(Rec: DestTy);
281 O << Indent << "LocVT = " << getEnumName(T: DestVT) << ";\n";
282 if (DestVT.isFloatingPoint()) {
283 O << Indent << "LocInfo = CCValAssign::FPExt;\n";
284 } else {
285 O << Indent << "if (ArgFlags.isSExt())\n"
286 << Indent << " LocInfo = CCValAssign::SExt;\n"
287 << Indent << "else if (ArgFlags.isZExt())\n"
288 << Indent << " LocInfo = CCValAssign::ZExt;\n"
289 << Indent << "else\n"
290 << Indent << " LocInfo = CCValAssign::AExt;\n";
291 }
292 } else if (Action->isSubClassOf(Name: "CCPromoteToUpperBitsInType")) {
293 const Record *DestTy = Action->getValueAsDef(FieldName: "DestTy");
294 MVT DestVT = getValueType(Rec: DestTy);
295 O << Indent << "LocVT = " << getEnumName(T: DestVT) << ";\n";
296 if (DestVT.isFloatingPoint()) {
297 PrintFatalError(ErrorLoc: Action->getLoc(),
298 Msg: "CCPromoteToUpperBitsInType does not handle floating "
299 "point");
300 } else {
301 O << Indent << "if (ArgFlags.isSExt())\n"
302 << Indent << " LocInfo = CCValAssign::SExtUpper;\n"
303 << Indent << "else if (ArgFlags.isZExt())\n"
304 << Indent << " LocInfo = CCValAssign::ZExtUpper;\n"
305 << Indent << "else\n"
306 << Indent << " LocInfo = CCValAssign::AExtUpper;\n";
307 }
308 } else if (Action->isSubClassOf(Name: "CCBitConvertToType")) {
309 const Record *DestTy = Action->getValueAsDef(FieldName: "DestTy");
310 O << Indent << "LocVT = " << getEnumName(T: getValueType(Rec: DestTy)) << ";\n";
311 O << Indent << "LocInfo = CCValAssign::BCvt;\n";
312 } else if (Action->isSubClassOf(Name: "CCTruncToType")) {
313 const Record *DestTy = Action->getValueAsDef(FieldName: "DestTy");
314 O << Indent << "LocVT = " << getEnumName(T: getValueType(Rec: DestTy)) << ";\n";
315 O << Indent << "LocInfo = CCValAssign::Trunc;\n";
316 } else if (Action->isSubClassOf(Name: "CCPassIndirect")) {
317 const Record *DestTy = Action->getValueAsDef(FieldName: "DestTy");
318 O << Indent << "LocVT = " << getEnumName(T: getValueType(Rec: DestTy)) << ";\n";
319 O << Indent << "LocInfo = CCValAssign::Indirect;\n";
320 } else if (Action->isSubClassOf(Name: "CCPassByVal")) {
321 int Size = Action->getValueAsInt(FieldName: "Size");
322 int Align = Action->getValueAsInt(FieldName: "Align");
323 O << Indent << "State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, " << Size
324 << ", Align(" << Align << "), ArgFlags);\n";
325 O << Indent << "return false;\n";
326 } else if (Action->isSubClassOf(Name: "CCCustom")) {
327 O << Indent << "if (" << Action->getValueAsString(FieldName: "FuncName")
328 << "(ValNo, ValVT, "
329 << "LocVT, LocInfo, ArgFlags, State))\n";
330 O << Indent << " return false;\n";
331 } else {
332 errs() << *Action;
333 PrintFatalError(ErrorLoc: Action->getLoc(), Msg: "Unknown CCAction!");
334 }
335}
336
337void CallingConvEmitter::emitArgRegisterLists(raw_ostream &O) {
338 // Transitively merge all delegated CCs into AssignedRegsMap.
339 using EntryTy = std::pair<std::string, std::set<std::string>>;
340 bool Redo;
341 do {
342 Redo = false;
343 std::deque<EntryTy> Worklist(DelegateToMap.begin(), DelegateToMap.end());
344
345 while (!Worklist.empty()) {
346 EntryTy Entry = Worklist.front();
347 Worklist.pop_front();
348
349 const std::string &CCName = Entry.first;
350 std::set<std::string> &Registers = Entry.second;
351 if (!Registers.empty())
352 continue;
353
354 for (auto &InnerEntry : Worklist) {
355 const std::string &InnerCCName = InnerEntry.first;
356 std::set<std::string> &InnerRegisters = InnerEntry.second;
357
358 auto It = InnerRegisters.find(x: CCName);
359 if (It != InnerRegisters.end()) {
360 const auto &Src = AssignedRegsMap[CCName];
361 AssignedRegsMap[InnerCCName].insert(first: Src.begin(), last: Src.end());
362 InnerRegisters.erase(position: It);
363 }
364 }
365
366 DelegateToMap.erase(x: CCName);
367 Redo = true;
368 }
369 } while (Redo);
370
371 if (AssignedRegsMap.empty())
372 return;
373
374 IfDefEmitter IfGuard(O, "GET_CC_REGISTER_LISTS");
375
376 for (const auto &[RegName, Registers] : AssignedRegsMap) {
377 if (RegName.empty())
378 continue;
379
380 O << "const MCRegister " << RegName << "_ArgRegs[] = { ";
381
382 if (Registers.empty())
383 O << "0";
384 else
385 O << llvm::interleaved(R: Registers);
386
387 O << " };\n";
388 }
389
390 if (AssignedSwiftRegsMap.empty())
391 return;
392
393 O << "\n// Registers used by Swift.\n";
394 for (const auto &[RegName, Registers] : AssignedSwiftRegsMap)
395 O << "const MCRegister " << RegName << "_Swift_ArgRegs[] = { "
396 << llvm::interleaved(R: Registers) << " };\n";
397}
398
399static TableGen::Emitter::OptClass<CallingConvEmitter>
400 X("gen-callingconv", "Generate calling convention descriptions");
401