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