1	//===- MveEmitter.cpp - Generate arm_mve.h for use with clang -*- C++ -*-=====//
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 set of linked tablegen backends is responsible for emitting the bits
10	// and pieces that implement <arm_mve.h>, which is defined by the ACLE standard
11	// and provides a set of types and functions for (more or less) direct access
12	// to the MVE instruction set, including the scalar shifts as well as the
13	// vector instructions.
14	//
15	// MVE's standard intrinsic functions are unusual in that they have a system of
16	// polymorphism. For example, the function vaddq() can behave like vaddq_u16(),
17	// vaddq_f32(), vaddq_s8(), etc., depending on the types of the vector
18	// arguments you give it.
19	//
20	// This constrains the implementation strategies. The usual approach to making
21	// the user-facing functions polymorphic would be to either use
22	// __attribute__((overloadable)) to make a set of vaddq() functions that are
23	// all inline wrappers on the underlying clang builtins, or to define a single
24	// vaddq() macro which expands to an instance of _Generic.
25	//
26	// The inline-wrappers approach would work fine for most intrinsics, except for
27	// the ones that take an argument required to be a compile-time constant,
28	// because if you wrap an inline function around a call to a builtin, the
29	// constant nature of the argument is not passed through.
30	//
31	// The _Generic approach can be made to work with enough effort, but it takes a
32	// lot of machinery, because of the design feature of _Generic that even the
33	// untaken branches are required to pass all front-end validity checks such as
34	// type-correctness. You can work around that by nesting further _Generics all
35	// over the place to coerce things to the right type in untaken branches, but
36	// what you get out is complicated, hard to guarantee its correctness, and
37	// worst of all, gives _completely unreadable_ error messages if the user gets
38	// the types wrong for an intrinsic call.
39	//
40	// Therefore, my strategy is to introduce a new __attribute__ that allows a
41	// function to be mapped to a clang builtin even though it doesn't have the
42	// same name, and then declare all the user-facing MVE function names with that
43	// attribute, mapping each one directly to the clang builtin. And the
44	// polymorphic ones have __attribute__((overloadable)) as well. So once the
45	// compiler has resolved the overload, it knows the internal builtin ID of the
46	// selected function, and can check the immediate arguments against that; and
47	// if the user gets the types wrong in a call to a polymorphic intrinsic, they
48	// get a completely clear error message showing all the declarations of that
49	// function in the header file and explaining why each one doesn't fit their
50	// call.
51	//
52	// The downside of this is that if every clang builtin has to correspond
53	// exactly to a user-facing ACLE intrinsic, then you can't save work in the
54	// frontend by doing it in the header file: CGBuiltin.cpp has to do the entire
55	// job of converting an ACLE intrinsic call into LLVM IR. So the Tablegen
56	// description for an MVE intrinsic has to contain a full description of the
57	// sequence of IRBuilder calls that clang will need to make.
58	//
59	//===----------------------------------------------------------------------===//
60
61	#include "llvm/ADT/APInt.h"
62	#include "llvm/ADT/StringRef.h"
63	#include "llvm/ADT/StringSwitch.h"
64	#include "llvm/Support/Casting.h"
65	#include "llvm/Support/raw_ostream.h"
66	#include "llvm/TableGen/Error.h"
67	#include "llvm/TableGen/Record.h"
68	#include "llvm/TableGen/StringToOffsetTable.h"
69	#include <cassert>
70	#include <cstddef>
71	#include <cstdint>
72	#include <list>
73	#include <map>
74	#include <memory>
75	#include <set>
76	#include <string>
77	#include <vector>
78
79	using namespace llvm;
80
81	namespace {
82
83	class EmitterBase;
84	class Result;
85
86	// -----------------------------------------------------------------------------
87	// A system of classes to represent all the types we'll need to deal with in
88	// the prototypes of intrinsics.
89	//
90	// Query methods include finding out the C name of a type; the "LLVM name" in
91	// the sense of a C++ code snippet that can be used in the codegen function;
92	// the suffix that represents the type in the ACLE intrinsic naming scheme
93	// (e.g. 's32' represents int32_t in intrinsics such as vaddq_s32); whether the
94	// type is floating-point related (hence should be under #ifdef in the MVE
95	// header so that it isn't included in integer-only MVE mode); and the type's
96	// size in bits. Not all subtypes support all these queries.
97
98	class Type {
99	public:
100	enum class TypeKind {
101	// Void appears as a return type (for store intrinsics, which are pure
102	// side-effect). It's also used as the parameter type in the Tablegen
103	// when an intrinsic doesn't need to come in various suffixed forms like
104	// vfooq_s8,vfooq_u16,vfooq_f32.
105	Void,
106
107	// Scalar is used for ordinary int and float types of all sizes.
108	Scalar,
109
110	// Vector is used for anything that occupies exactly one MVE vector
111	// register, i.e. {uint,int,float}NxM_t.
112	Vector,
113
114	// MultiVector is used for the {uint,int,float}NxMxK_t types used by the
115	// interleaving load/store intrinsics v{ld,st}{2,4}q.
116	MultiVector,
117
118	// Predicate is used by all the predicated intrinsics. Its C
119	// representation is mve_pred16_t (which is just an alias for uint16_t).
120	// But we give more detail here, by indicating that a given predicate
121	// instruction is logically regarded as a vector of i1 containing the
122	// same number of lanes as the input vector type. So our Predicate type
123	// comes with a lane count, which we use to decide which kind of <n x i1>
124	// we'll invoke the pred_i2v IR intrinsic to translate it into.
125	Predicate,
126
127	// Pointer is used for pointer types (obviously), and comes with a flag
128	// indicating whether it's a pointer to a const or mutable instance of
129	// the pointee type.
130	Pointer,
131	};
132
133	private:
134	const TypeKind TKind;
135
136	protected:
137	Type(TypeKind K) : TKind(K) {}
138
139	public:
140	TypeKind typeKind() const { return TKind; }
141	virtual ~Type() = default;
142	virtual bool requiresFloat() const = 0;
143	virtual bool requiresMVE() const = 0;
144	virtual unsigned sizeInBits() const = 0;
145	virtual std::string cName() const = 0;
146	virtual std::string llvmName() const {
147	PrintFatalError(Msg: "no LLVM type name available for type " + cName());
148	}
149	virtual std::string acleSuffix(std::string) const {
150	PrintFatalError(Msg: "no ACLE suffix available for this type");
151	}
152	};
153
154	enum class ScalarTypeKind { SignedInt, UnsignedInt, Float };
155	inline std::string toLetter(ScalarTypeKind kind) {
156	switch (kind) {
157	case ScalarTypeKind::SignedInt:
158	return "s";
159	case ScalarTypeKind::UnsignedInt:
160	return "u";
161	case ScalarTypeKind::Float:
162	return "f";
163	}
164	llvm_unreachable("Unhandled ScalarTypeKind enum");
165	}
166	inline std::string toCPrefix(ScalarTypeKind kind) {
167	switch (kind) {
168	case ScalarTypeKind::SignedInt:
169	return "int";
170	case ScalarTypeKind::UnsignedInt:
171	return "uint";
172	case ScalarTypeKind::Float:
173	return "float";
174	}
175	llvm_unreachable("Unhandled ScalarTypeKind enum");
176	}
177
178	class VoidType : public Type {
179	public:
180	VoidType() : Type(TypeKind::Void) {}
181	unsigned sizeInBits() const override { return 0; }
182	bool requiresFloat() const override { return false; }
183	bool requiresMVE() const override { return false; }
184	std::string cName() const override { return "void"; }
185
186	static bool classof(const Type *T) { return T->typeKind() == TypeKind::Void; }
187	std::string acleSuffix(std::string) const override { return ""; }
188	};
189
190	class PointerType : public Type {
191	const Type *Pointee;
192	bool Const;
193
194	public:
195	PointerType(const Type *Pointee, bool Const)
196	: Type(TypeKind::Pointer), Pointee(Pointee), Const(Const) {}
197	unsigned sizeInBits() const override { return 32; }
198	bool requiresFloat() const override { return Pointee->requiresFloat(); }
199	bool requiresMVE() const override { return Pointee->requiresMVE(); }
200	std::string cName() const override {
201	std::string Name = Pointee->cName();
202
203	// The syntax for a pointer in C is different when the pointee is
204	// itself a pointer. The MVE intrinsics don't contain any double
205	// pointers, so we don't need to worry about that wrinkle.
206	assert(!isa<PointerType>(Pointee) && "Pointer to pointer not supported");
207
208	if (Const)
209	Name = "const " + Name;
210	return Name + " *";
211	}
212	std::string llvmName() const override {
213	return "llvm::PointerType::getUnqual(" + Pointee->llvmName() + ")";
214	}
215	const Type *getPointeeType() const { return Pointee; }
216
217	static bool classof(const Type *T) {
218	return T->typeKind() == TypeKind::Pointer;
219	}
220	};
221
222	// Base class for all the types that have a name of the form
223	// [prefix][numbers]_t, like int32_t, uint16x8_t, float32x4x2_t.
224	//
225	// For this sub-hierarchy we invent a cNameBase() method which returns the
226	// whole name except for the trailing "_t", so that Vector and MultiVector can
227	// append an extra "x2" or whatever to their element type's cNameBase(). Then
228	// the main cName() query method puts "_t" on the end for the final type name.
229
230	class CRegularNamedType : public Type {
231	using Type::Type;
232	virtual std::string cNameBase() const = 0;
233
234	public:
235	std::string cName() const override { return cNameBase() + "_t"; }
236	};
237
238	class ScalarType : public CRegularNamedType {
239	ScalarTypeKind Kind;
240	unsigned Bits;
241	std::string NameOverride;
242
243	public:
244	ScalarType(const Record *Record) : CRegularNamedType(TypeKind::Scalar) {
245	Kind = StringSwitch<ScalarTypeKind>(Record->getValueAsString(FieldName: "kind"))
246	.Case(S: "s", Value: ScalarTypeKind::SignedInt)
247	.Case(S: "u", Value: ScalarTypeKind::UnsignedInt)
248	.Case(S: "f", Value: ScalarTypeKind::Float);
249	Bits = Record->getValueAsInt(FieldName: "size");
250	NameOverride = std::string(Record->getValueAsString(FieldName: "nameOverride"));
251	}
252	unsigned sizeInBits() const override { return Bits; }
253	ScalarTypeKind kind() const { return Kind; }
254	std::string suffix() const { return toLetter(kind: Kind) + utostr(X: Bits); }
255	std::string cNameBase() const override {
256	return toCPrefix(kind: Kind) + utostr(X: Bits);
257	}
258	std::string cName() const override {
259	if (NameOverride.empty())
260	return CRegularNamedType::cName();
261	return NameOverride;
262	}
263	std::string llvmName() const override {
264	if (Kind == ScalarTypeKind::Float) {
265	if (Bits == 16)
266	return "HalfTy";
267	if (Bits == 32)
268	return "FloatTy";
269	if (Bits == 64)
270	return "DoubleTy";
271	PrintFatalError(Msg: "bad size for floating type");
272	}
273	return "Int" + utostr(X: Bits) + "Ty";
274	}
275	std::string acleSuffix(std::string overrideLetter) const override {
276	return "_" + (overrideLetter.size() ? overrideLetter : toLetter(kind: Kind))
277	+ utostr(X: Bits);
278	}
279	bool isInteger() const { return Kind != ScalarTypeKind::Float; }
280	bool requiresFloat() const override { return !isInteger(); }
281	bool requiresMVE() const override { return false; }
282	bool hasNonstandardName() const { return !NameOverride.empty(); }
283
284	static bool classof(const Type *T) {
285	return T->typeKind() == TypeKind::Scalar;
286	}
287	};
288
289	class VectorType : public CRegularNamedType {
290	const ScalarType *Element;
291	unsigned Lanes;
292
293	public:
294	VectorType(const ScalarType *Element, unsigned Lanes)
295	: CRegularNamedType(TypeKind::Vector), Element(Element), Lanes(Lanes) {}
296	unsigned sizeInBits() const override { return Lanes * Element->sizeInBits(); }
297	unsigned lanes() const { return Lanes; }
298	bool requiresFloat() const override { return Element->requiresFloat(); }
299	bool requiresMVE() const override { return true; }
300	std::string cNameBase() const override {
301	return Element->cNameBase() + "x" + utostr(X: Lanes);
302	}
303	std::string llvmName() const override {
304	return "llvm::FixedVectorType::get(" + Element->llvmName() + ", " +
305	utostr(X: Lanes) + ")";
306	}
307
308	static bool classof(const Type *T) {
309	return T->typeKind() == TypeKind::Vector;
310	}
311	};
312
313	class MultiVectorType : public CRegularNamedType {
314	const VectorType *Element;
315	unsigned Registers;
316
317	public:
318	MultiVectorType(unsigned Registers, const VectorType *Element)
319	: CRegularNamedType(TypeKind::MultiVector), Element(Element),
320	Registers(Registers) {}
321	unsigned sizeInBits() const override {
322	return Registers * Element->sizeInBits();
323	}
324	unsigned registers() const { return Registers; }
325	bool requiresFloat() const override { return Element->requiresFloat(); }
326	bool requiresMVE() const override { return true; }
327	std::string cNameBase() const override {
328	return Element->cNameBase() + "x" + utostr(X: Registers);
329	}
330
331	// MultiVectorType doesn't override llvmName, because we don't expect to do
332	// automatic code generation for the MVE intrinsics that use it: the {vld2,
333	// vld4, vst2, vst4} family are the only ones that use these types, so it was
334	// easier to hand-write the codegen for dealing with these structs than to
335	// build in lots of extra automatic machinery that would only be used once.
336
337	static bool classof(const Type *T) {
338	return T->typeKind() == TypeKind::MultiVector;
339	}
340	};
341
342	class PredicateType : public CRegularNamedType {
343	unsigned Lanes;
344
345	public:
346	PredicateType(unsigned Lanes)
347	: CRegularNamedType(TypeKind::Predicate), Lanes(Lanes) {}
348	unsigned sizeInBits() const override { return 16; }
349	std::string cNameBase() const override { return "mve_pred16"; }
350	bool requiresFloat() const override { return false; };
351	bool requiresMVE() const override { return true; }
352	std::string llvmName() const override {
353	return "llvm::FixedVectorType::get(Builder.getInt1Ty(), " + utostr(X: Lanes) +
354	")";
355	}
356
357	static bool classof(const Type *T) {
358	return T->typeKind() == TypeKind::Predicate;
359	}
360	};
361
362	// -----------------------------------------------------------------------------
363	// Class to facilitate merging together the code generation for many intrinsics
364	// by means of varying a few constant or type parameters.
365	//
366	// Most obviously, the intrinsics in a single parametrised family will have
367	// code generation sequences that only differ in a type or two, e.g. vaddq_s8
368	// and vaddq_u16 will look the same apart from putting a different vector type
369	// in the call to CGM.getIntrinsic(). But also, completely different intrinsics
370	// will often code-generate in the same way, with only a different choice of
371	// _which_ IR intrinsic they lower to (e.g. vaddq_m_s8 and vmulq_m_s8), but
372	// marshalling the arguments and return values of the IR intrinsic in exactly
373	// the same way. And others might differ only in some other kind of constant,
374	// such as a lane index.
375	//
376	// So, when we generate the IR-building code for all these intrinsics, we keep
377	// track of every value that could possibly be pulled out of the code and
378	// stored ahead of time in a local variable. Then we group together intrinsics
379	// by textual equivalence of the code that would result if _all_ those
380	// parameters were stored in local variables. That gives us maximal sets that
381	// can be implemented by a single piece of IR-building code by changing
382	// parameter values ahead of time.
383	//
384	// After we've done that, we do a second pass in which we only allocate _some_
385	// of the parameters into local variables, by tracking which ones have the same
386	// values as each other (so that a single variable can be reused) and which
387	// ones are the same across the whole set (so that no variable is needed at
388	// all).
389	//
390	// Hence the class below. Its allocParam method is invoked during code
391	// generation by every method of a Result subclass (see below) that wants to
392	// give it the opportunity to pull something out into a switchable parameter.
393	// It returns a variable name for the parameter, or (if it's being used in the
394	// second pass once we've decided that some parameters don't need to be stored
395	// in variables after all) it might just return the input expression unchanged.
396
397	struct CodeGenParamAllocator {
398	// Accumulated during code generation
399	std::vector<std::string> *ParamTypes = nullptr;
400	std::vector<std::string> *ParamValues = nullptr;
401
402	// Provided ahead of time in pass 2, to indicate which parameters are being
403	// assigned to what. This vector contains an entry for each call to
404	// allocParam expected during code gen (which we counted up in pass 1), and
405	// indicates the number of the parameter variable that should be returned, or
406	// -1 if this call shouldn't allocate a parameter variable at all.
407	//
408	// We rely on the recursive code generation working identically in passes 1
409	// and 2, so that the same list of calls to allocParam happen in the same
410	// order. That guarantees that the parameter numbers recorded in pass 1 will
411	// match the entries in this vector that store what EmitterBase::EmitBuiltinCG
412	// decided to do about each one in pass 2.
413	std::vector<int> *ParamNumberMap = nullptr;
414
415	// Internally track how many things we've allocated
416	unsigned nparams = 0;
417
418	std::string allocParam(StringRef Type, StringRef Value) {
419	unsigned ParamNumber;
420
421	if (!ParamNumberMap) {
422	// In pass 1, unconditionally assign a new parameter variable to every
423	// value we're asked to process.
424	ParamNumber = nparams++;
425	} else {
426	// In pass 2, consult the map provided by the caller to find out which
427	// variable we should be keeping things in.
428	int MapValue = (*ParamNumberMap)[nparams++];
429	if (MapValue < 0)
430	return std::string(Value);
431	ParamNumber = MapValue;
432	}
433
434	// If we've allocated a new parameter variable for the first time, store
435	// its type and value to be retrieved after codegen.
436	if (ParamTypes && ParamTypes->size() == ParamNumber)
437	ParamTypes->push_back(x: std::string(Type));
438	if (ParamValues && ParamValues->size() == ParamNumber)
439	ParamValues->push_back(x: std::string(Value));
440
441	// Unimaginative naming scheme for parameter variables.
442	return "Param" + utostr(X: ParamNumber);
443	}
444	};
445
446	// -----------------------------------------------------------------------------
447	// System of classes that represent all the intermediate values used during
448	// code-generation for an intrinsic.
449	//
450	// The base class 'Result' can represent a value of the LLVM type 'Value', or
451	// sometimes 'Address' (for loads/stores, including an alignment requirement).
452	//
453	// In the case where the Tablegen provides a value in the codegen dag as a
454	// plain integer literal, the Result object we construct here will be one that
455	// returns true from hasIntegerConstantValue(). This allows the generated C++
456	// code to use the constant directly in contexts which can take a literal
457	// integer, such as Builder.CreateExtractValue(thing, 1), without going to the
458	// effort of calling llvm::ConstantInt::get() and then pulling the constant
459	// back out of the resulting llvm:Value later.
460
461	class Result {
462	public:
463	// Convenient shorthand for the pointer type we'll be using everywhere.
464	using Ptr = std::shared_ptr<Result>;
465
466	private:
467	Ptr Predecessor;
468	std::string VarName;
469	bool VarNameUsed = false;
470	unsigned Visited = 0;
471
472	public:
473	virtual ~Result() = default;
474	using Scope = std::map<std::string, Ptr>;
475	virtual void genCode(raw_ostream &OS, CodeGenParamAllocator &) const = 0;
476	virtual bool hasIntegerConstantValue() const { return false; }
477	virtual uint32_t integerConstantValue() const { return 0; }
478	virtual bool hasIntegerValue() const { return false; }
479	virtual std::string getIntegerValue(const std::string &) {
480	llvm_unreachable("non-working Result::getIntegerValue called");
481	}
482	virtual std::string typeName() const { return "Value *"; }
483
484	// Mostly, when a code-generation operation has a dependency on prior
485	// operations, it's because it uses the output values of those operations as
486	// inputs. But there's one exception, which is the use of 'seq' in Tablegen
487	// to indicate that operations have to be performed in sequence regardless of
488	// whether they use each others' output values.
489	//
490	// So, the actual generation of code is done by depth-first search, using the
491	// prerequisites() method to get a list of all the other Results that have to
492	// be computed before this one. That method divides into the 'predecessor',
493	// set by setPredecessor() while processing a 'seq' dag node, and the list
494	// returned by 'morePrerequisites', which each subclass implements to return
495	// a list of the Results it uses as input to whatever its own computation is
496	// doing.
497
498	virtual void morePrerequisites(std::vector<Ptr> &output) const {}
499	std::vector<Ptr> prerequisites() const {
500	std::vector<Ptr> ToRet;
501	if (Predecessor)
502	ToRet.push_back(x: Predecessor);
503	morePrerequisites(output&: ToRet);
504	return ToRet;
505	}
506
507	void setPredecessor(Ptr p) {
508	// If the user has nested one 'seq' node inside another, and this
509	// method is called on the return value of the inner 'seq' (i.e.
510	// the final item inside it), then we can't link _this_ node to p,
511	// because it already has a predecessor. Instead, walk the chain
512	// until we find the first item in the inner seq, and link that to
513	// p, so that nesting seqs has the obvious effect of linking
514	// everything together into one long sequential chain.
515	Result *r = this;
516	while (r->Predecessor)
517	r = r->Predecessor.get();
518	r->Predecessor = p;
519	}
520
521	// Each Result will be assigned a variable name in the output code, but not
522	// all those variable names will actually be used (e.g. the return value of
523	// Builder.CreateStore has void type, so nobody will want to refer to it). To
524	// prevent annoying compiler warnings, we track whether each Result's
525	// variable name was ever actually mentioned in subsequent statements, so
526	// that it can be left out of the final generated code.
527	std::string varname() {
528	VarNameUsed = true;
529	return VarName;
530	}
531	void setVarname(const StringRef s) { VarName = std::string(s); }
532	bool varnameUsed() const { return VarNameUsed; }
533
534	// Emit code to generate this result as a Value *.
535	virtual std::string asValue() {
536	return varname();
537	}
538
539	// Code generation happens in multiple passes. This method tracks whether a
540	// Result has yet been visited in a given pass, without the need for a
541	// tedious loop in between passes that goes through and resets a 'visited'
542	// flag back to false: you just set Pass=1 the first time round, and Pass=2
543	// the second time.
544	bool needsVisiting(unsigned Pass) {
545	bool ToRet = Visited < Pass;
546	Visited = Pass;
547	return ToRet;
548	}
549	};
550
551	// Result subclass that retrieves one of the arguments to the clang builtin
552	// function. In cases where the argument has pointer type, we call
553	// EmitPointerWithAlignment and store the result in a variable of type Address,
554	// so that load and store IR nodes can know the right alignment. Otherwise, we
555	// call EmitScalarExpr.
556	//
557	// There are aggregate parameters in the MVE intrinsics API, but we don't deal
558	// with them in this Tablegen back end: they only arise in the vld2q/vld4q and
559	// vst2q/vst4q family, which is few enough that we just write the code by hand
560	// for those in CGBuiltin.cpp.
561	class BuiltinArgResult : public Result {
562	public:
563	unsigned ArgNum;
564	bool AddressType;
565	bool Immediate;
566	BuiltinArgResult(unsigned ArgNum, bool AddressType, bool Immediate)
567	: ArgNum(ArgNum), AddressType(AddressType), Immediate(Immediate) {}
568	void genCode(raw_ostream &OS, CodeGenParamAllocator &) const override {
569	OS << (AddressType ? "EmitPointerWithAlignment" : "EmitScalarExpr")
570	<< "(E->getArg(" << ArgNum << "))";
571	}
572	std::string typeName() const override {
573	return AddressType ? "Address" : Result::typeName();
574	}
575	// Emit code to generate this result as a Value *.
576	std::string asValue() override {
577	if (AddressType)
578	return "(" + varname() + ".emitRawPointer(*this))";
579	return Result::asValue();
580	}
581	bool hasIntegerValue() const override { return Immediate; }
582	std::string getIntegerValue(const std::string &IntType) override {
583	return "GetIntegerConstantValue<" + IntType + ">(E->getArg(" +
584	utostr(X: ArgNum) + "), getContext())";
585	}
586	};
587
588	// Result subclass for an integer literal appearing in Tablegen. This may need
589	// to be turned into an llvm::Result by means of llvm::ConstantInt::get(), or
590	// it may be used directly as an integer, depending on which IRBuilder method
591	// it's being passed to.
592	class IntLiteralResult : public Result {
593	public:
594	const ScalarType *IntegerType;
595	uint32_t IntegerValue;
596	IntLiteralResult(const ScalarType *IntegerType, uint32_t IntegerValue)
597	: IntegerType(IntegerType), IntegerValue(IntegerValue) {}
598	void genCode(raw_ostream &OS,
599	CodeGenParamAllocator &ParamAlloc) const override {
600	OS << "llvm::ConstantInt::get("
601	<< ParamAlloc.allocParam(Type: "llvm::Type *", Value: IntegerType->llvmName())
602	<< ", ";
603	OS << ParamAlloc.allocParam(Type: IntegerType->cName(), Value: utostr(X: IntegerValue))
604	<< ")";
605	}
606	bool hasIntegerConstantValue() const override { return true; }
607	uint32_t integerConstantValue() const override { return IntegerValue; }
608	};
609
610	// Result subclass representing a cast between different integer types. We use
611	// our own ScalarType abstraction as the representation of the target type,
612	// which gives both size and signedness.
613	class IntCastResult : public Result {
614	public:
615	const ScalarType *IntegerType;
616	Ptr V;
617	IntCastResult(const ScalarType *IntegerType, Ptr V)
618	: IntegerType(IntegerType), V(V) {}
619	void genCode(raw_ostream &OS,
620	CodeGenParamAllocator &ParamAlloc) const override {
621	OS << "Builder.CreateIntCast(" << V->varname() << ", "
622	<< ParamAlloc.allocParam(Type: "llvm::Type *", Value: IntegerType->llvmName()) << ", "
623	<< ParamAlloc.allocParam(Type: "bool",
624	Value: IntegerType->kind() == ScalarTypeKind::SignedInt
625	? "true"
626	: "false")
627	<< ")";
628	}
629	void morePrerequisites(std::vector<Ptr> &output) const override {
630	output.push_back(x: V);
631	}
632	};
633
634	// Result subclass representing a cast between different pointer types.
635	class PointerCastResult : public Result {
636	public:
637	const PointerType *PtrType;
638	Ptr V;
639	PointerCastResult(const PointerType *PtrType, Ptr V)
640	: PtrType(PtrType), V(V) {}
641	void genCode(raw_ostream &OS,
642	CodeGenParamAllocator &ParamAlloc) const override {
643	OS << "Builder.CreatePointerCast(" << V->asValue() << ", "
644	<< ParamAlloc.allocParam(Type: "llvm::Type *", Value: PtrType->llvmName()) << ")";
645	}
646	void morePrerequisites(std::vector<Ptr> &output) const override {
647	output.push_back(x: V);
648	}
649	};
650
651	// Result subclass representing a call to an IRBuilder method. Each IRBuilder
652	// method we want to use will have a Tablegen record giving the method name and
653	// describing any important details of how to call it, such as whether a
654	// particular argument should be an integer constant instead of an llvm::Value.
655	class IRBuilderResult : public Result {
656	public:
657	StringRef CallPrefix;
658	std::vector<Ptr> Args;
659	std::set<unsigned> AddressArgs;
660	std::map<unsigned, std::string> IntegerArgs;
661	IRBuilderResult(StringRef CallPrefix, const std::vector<Ptr> &Args,
662	const std::set<unsigned> &AddressArgs,
663	const std::map<unsigned, std::string> &IntegerArgs)
664	: CallPrefix(CallPrefix), Args(Args), AddressArgs(AddressArgs),
665	IntegerArgs(IntegerArgs) {}
666	void genCode(raw_ostream &OS,
667	CodeGenParamAllocator &ParamAlloc) const override {
668	OS << CallPrefix;
669	const char *Sep = "";
670	for (unsigned i = 0, e = Args.size(); i < e; ++i) {
671	Ptr Arg = Args[i];
672	auto it = IntegerArgs.find(x: i);
673
674	OS << Sep;
675	Sep = ", ";
676
677	if (it != IntegerArgs.end()) {
678	if (Arg->hasIntegerConstantValue())
679	OS << "static_cast<" << it->second << ">("
680	<< ParamAlloc.allocParam(Type: it->second,
681	Value: utostr(X: Arg->integerConstantValue()))
682	<< ")";
683	else if (Arg->hasIntegerValue())
684	OS << ParamAlloc.allocParam(Type: it->second,
685	Value: Arg->getIntegerValue(it->second));
686	} else {
687	OS << Arg->varname();
688	}
689	}
690	OS << ")";
691	}
692	void morePrerequisites(std::vector<Ptr> &output) const override {
693	for (unsigned i = 0, e = Args.size(); i < e; ++i) {
694	Ptr Arg = Args[i];
695	if (IntegerArgs.find(x: i) != IntegerArgs.end())
696	continue;
697	output.push_back(x: Arg);
698	}
699	}
700	};
701
702	// Result subclass representing making an Address out of a Value.
703	class AddressResult : public Result {
704	public:
705	Ptr Arg;
706	const Type *Ty;
707	unsigned Align;
708	AddressResult(Ptr Arg, const Type *Ty, unsigned Align)
709	: Arg(Arg), Ty(Ty), Align(Align) {}
710	void genCode(raw_ostream &OS,
711	CodeGenParamAllocator &ParamAlloc) const override {
712	OS << "Address(" << Arg->varname() << ", " << Ty->llvmName()
713	<< ", CharUnits::fromQuantity(" << Align << "))";
714	}
715	std::string typeName() const override {
716	return "Address";
717	}
718	void morePrerequisites(std::vector<Ptr> &output) const override {
719	output.push_back(x: Arg);
720	}
721	};
722
723	// Result subclass representing a call to an IR intrinsic, which we first have
724	// to look up using an Intrinsic::ID constant and an array of types.
725	class IRIntrinsicResult : public Result {
726	public:
727	std::string IntrinsicID;
728	std::vector<const Type *> ParamTypes;
729	std::vector<Ptr> Args;
730	IRIntrinsicResult(StringRef IntrinsicID,
731	const std::vector<const Type *> &ParamTypes,
732	const std::vector<Ptr> &Args)
733	: IntrinsicID(std::string(IntrinsicID)), ParamTypes(ParamTypes),
734	Args(Args) {}
735	void genCode(raw_ostream &OS,
736	CodeGenParamAllocator &ParamAlloc) const override {
737	std::string IntNo = ParamAlloc.allocParam(
738	Type: "Intrinsic::ID", Value: "Intrinsic::" + IntrinsicID);
739	OS << "Builder.CreateCall(CGM.getIntrinsic(" << IntNo;
740	if (!ParamTypes.empty()) {
741	OS << ", {";
742	const char *Sep = "";
743	for (auto T : ParamTypes) {
744	OS << Sep << ParamAlloc.allocParam(Type: "llvm::Type *", Value: T->llvmName());
745	Sep = ", ";
746	}
747	OS << "}";
748	}
749	OS << "), {";
750	const char *Sep = "";
751	for (auto Arg : Args) {
752	OS << Sep << Arg->asValue();
753	Sep = ", ";
754	}
755	OS << "})";
756	}
757	void morePrerequisites(std::vector<Ptr> &output) const override {
758	output.insert(position: output.end(), first: Args.begin(), last: Args.end());
759	}
760	};
761
762	// Result subclass that specifies a type, for use in IRBuilder operations such
763	// as CreateBitCast that take a type argument.
764	class TypeResult : public Result {
765	public:
766	const Type *T;
767	TypeResult(const Type *T) : T(T) {}
768	void genCode(raw_ostream &OS, CodeGenParamAllocator &) const override {
769	OS << T->llvmName();
770	}
771	std::string typeName() const override {
772	return "llvm::Type *";
773	}
774	};
775
776	// -----------------------------------------------------------------------------
777	// Class that describes a single ACLE intrinsic.
778	//
779	// A Tablegen record will typically describe more than one ACLE intrinsic, by
780	// means of setting the 'list<Type> Params' field to a list of multiple
781	// parameter types, so as to define vaddq_{s8,u8,...,f16,f32} all in one go.
782	// We'll end up with one instance of ACLEIntrinsic for *each* parameter type,
783	// rather than a single one for all of them. Hence, the constructor takes both
784	// a Tablegen record and the current value of the parameter type.
785
786	class ACLEIntrinsic {
787	// Structure documenting that one of the intrinsic's arguments is required to
788	// be a compile-time constant integer, and what constraints there are on its
789	// value. Used when generating Sema checking code.
790	struct ImmediateArg {
791	enum class BoundsType { ExplicitRange, UInt };
792	BoundsType boundsType;
793	int64_t i1, i2;
794	StringRef ExtraCheckType, ExtraCheckArgs;
795	const Type *ArgType;
796	};
797
798	// For polymorphic intrinsics, FullName is the explicit name that uniquely
799	// identifies this variant of the intrinsic, and ShortName is the name it
800	// shares with at least one other intrinsic.
801	std::string ShortName, FullName;
802
803	// Name of the architecture extension, used in the Clang builtin name
804	StringRef BuiltinExtension;
805
806	// A very small number of intrinsics _only_ have a polymorphic
807	// variant (vuninitializedq taking an unevaluated argument).
808	bool PolymorphicOnly;
809
810	// Another rarely-used flag indicating that the builtin doesn't
811	// evaluate its argument(s) at all.
812	bool NonEvaluating;
813
814	// True if the intrinsic needs only the C header part (no codegen, semantic
815	// checks, etc). Used for redeclaring MVE intrinsics in the arm_cde.h header.
816	bool HeaderOnly;
817
818	const Type *ReturnType;
819	std::vector<const Type *> ArgTypes;
820	std::map<unsigned, ImmediateArg> ImmediateArgs;
821	Result::Ptr Code;
822
823	std::map<std::string, std::string> CustomCodeGenArgs;
824
825	// Recursive function that does the internals of code generation.
826	void genCodeDfs(Result::Ptr V, std::list<Result::Ptr> &Used,
827	unsigned Pass) const {
828	if (!V->needsVisiting(Pass))
829	return;
830
831	for (Result::Ptr W : V->prerequisites())
832	genCodeDfs(V: W, Used, Pass);
833
834	Used.push_back(x: V);
835	}
836
837	public:
838	const std::string &shortName() const { return ShortName; }
839	const std::string &fullName() const { return FullName; }
840	StringRef builtinExtension() const { return BuiltinExtension; }
841	const Type *returnType() const { return ReturnType; }
842	const std::vector<const Type *> &argTypes() const { return ArgTypes; }
843	bool requiresFloat() const {
844	if (ReturnType->requiresFloat())
845	return true;
846	for (const Type *T : ArgTypes)
847	if (T->requiresFloat())
848	return true;
849	return false;
850	}
851	bool requiresMVE() const {
852	return ReturnType->requiresMVE() ||
853	any_of(Range: ArgTypes, P: [](const Type *T) { return T->requiresMVE(); });
854	}
855	bool polymorphic() const { return ShortName != FullName; }
856	bool polymorphicOnly() const { return PolymorphicOnly; }
857	bool nonEvaluating() const { return NonEvaluating; }
858	bool headerOnly() const { return HeaderOnly; }
859
860	// External entry point for code generation, called from EmitterBase.
861	void genCode(raw_ostream &OS, CodeGenParamAllocator &ParamAlloc,
862	unsigned Pass) const {
863	assert(!headerOnly() && "Called genCode for header-only intrinsic");
864	if (!hasCode()) {
865	for (auto kv : CustomCodeGenArgs)
866	OS << " " << kv.first << " = " << kv.second << ";\n";
867	OS << " break; // custom code gen\n";
868	return;
869	}
870	std::list<Result::Ptr> Used;
871	genCodeDfs(V: Code, Used, Pass);
872
873	unsigned varindex = 0;
874	for (Result::Ptr V : Used)
875	if (V->varnameUsed())
876	V->setVarname("Val" + utostr(X: varindex++));
877
878	for (Result::Ptr V : Used) {
879	OS << " ";
880	if (V == Used.back()) {
881	assert(!V->varnameUsed());
882	OS << "return "; // FIXME: what if the top-level thing is void?
883	} else if (V->varnameUsed()) {
884	std::string Type = V->typeName();
885	OS << V->typeName();
886	if (!StringRef(Type).ends_with(Suffix: "*"))
887	OS << " ";
888	OS << V->varname() << " = ";
889	}
890	V->genCode(OS, ParamAlloc);
891	OS << ";\n";
892	}
893	}
894	bool hasCode() const { return Code != nullptr; }
895
896	static std::string signedHexLiteral(const llvm::APInt &iOrig) {
897	llvm::APInt i = iOrig.trunc(width: 64);
898	SmallString<40> s;
899	i.toString(Str&: s, Radix: 16, Signed: true, formatAsCLiteral: true);
900	return std::string(s);
901	}
902
903	std::string genSema() const {
904	assert(!headerOnly() && "Called genSema for header-only intrinsic");
905	std::vector<std::string> SemaChecks;
906
907	for (const auto &kv : ImmediateArgs) {
908	const ImmediateArg &IA = kv.second;
909
910	llvm::APInt lo(128, 0), hi(128, 0);
911	switch (IA.boundsType) {
912	case ImmediateArg::BoundsType::ExplicitRange:
913	lo = IA.i1;
914	hi = IA.i2;
915	break;
916	case ImmediateArg::BoundsType::UInt:
917	lo = 0;
918	hi = llvm::APInt::getMaxValue(numBits: IA.i1).zext(width: 128);
919	break;
920	}
921
922	std::string Index = utostr(X: kv.first);
923
924	// Emit a range check if the legal range of values for the
925	// immediate is smaller than the _possible_ range of values for
926	// its type.
927	unsigned ArgTypeBits = IA.ArgType->sizeInBits();
928	llvm::APInt ArgTypeRange = llvm::APInt::getMaxValue(numBits: ArgTypeBits).zext(width: 128);
929	llvm::APInt ActualRange = (hi-lo).trunc(width: 64).sext(width: 128);
930	if (ActualRange.ult(RHS: ArgTypeRange))
931	SemaChecks.push_back(x: "BuiltinConstantArgRange(TheCall, " + Index +
932	", " + signedHexLiteral(iOrig: lo) + ", " +
933	signedHexLiteral(iOrig: hi) + ")");
934
935	if (!IA.ExtraCheckType.empty()) {
936	std::string Suffix;
937	if (!IA.ExtraCheckArgs.empty()) {
938	std::string tmp;
939	StringRef Arg = IA.ExtraCheckArgs;
940	if (Arg == "!lanesize") {
941	tmp = utostr(X: IA.ArgType->sizeInBits());
942	Arg = tmp;
943	}
944	Suffix = (Twine(", ") + Arg).str();
945	}
946	SemaChecks.push_back(x: (Twine("BuiltinConstantArg") + IA.ExtraCheckType +
947	"(TheCall, " + Index + Suffix + ")")
948	.str());
949	}
950
951	assert(!SemaChecks.empty());
952	}
953	if (SemaChecks.empty())
954	return "";
955	return join(Begin: std::begin(cont&: SemaChecks), End: std::end(cont&: SemaChecks),
956	Separator: " ||\n ") +
957	";\n";
958	}
959
960	ACLEIntrinsic(EmitterBase &ME, Record *R, const Type *Param);
961	};
962
963	// -----------------------------------------------------------------------------
964	// The top-level class that holds all the state from analyzing the entire
965	// Tablegen input.
966
967	class EmitterBase {
968	protected:
969	// EmitterBase holds a collection of all the types we've instantiated.
970	VoidType Void;
971	std::map<std::string, std::unique_ptr<ScalarType>> ScalarTypes;
972	std::map<std::tuple<ScalarTypeKind, unsigned, unsigned>,
973	std::unique_ptr<VectorType>>
974	VectorTypes;
975	std::map<std::pair<std::string, unsigned>, std::unique_ptr<MultiVectorType>>
976	MultiVectorTypes;
977	std::map<unsigned, std::unique_ptr<PredicateType>> PredicateTypes;
978	std::map<std::string, std::unique_ptr<PointerType>> PointerTypes;
979
980	// And all the ACLEIntrinsic instances we've created.
981	std::map<std::string, std::unique_ptr<ACLEIntrinsic>> ACLEIntrinsics;
982
983	public:
984	// Methods to create a Type object, or return the right existing one from the
985	// maps stored in this object.
986	const VoidType *getVoidType() { return &Void; }
987	const ScalarType *getScalarType(StringRef Name) {
988	return ScalarTypes[std::string(Name)].get();
989	}
990	const ScalarType *getScalarType(Record *R) {
991	return getScalarType(Name: R->getName());
992	}
993	const VectorType *getVectorType(const ScalarType *ST, unsigned Lanes) {
994	std::tuple<ScalarTypeKind, unsigned, unsigned> key(ST->kind(),
995	ST->sizeInBits(), Lanes);
996	if (VectorTypes.find(x: key) == VectorTypes.end())
997	VectorTypes[key] = std::make_unique<VectorType>(args&: ST, args&: Lanes);
998	return VectorTypes[key].get();
999	}
1000	const VectorType *getVectorType(const ScalarType *ST) {
1001	return getVectorType(ST, Lanes: 128 / ST->sizeInBits());
1002	}
1003	const MultiVectorType *getMultiVectorType(unsigned Registers,
1004	const VectorType *VT) {
1005	std::pair<std::string, unsigned> key(VT->cNameBase(), Registers);
1006	if (MultiVectorTypes.find(x: key) == MultiVectorTypes.end())
1007	MultiVectorTypes[key] = std::make_unique<MultiVectorType>(args&: Registers, args&: VT);
1008	return MultiVectorTypes[key].get();
1009	}
1010	const PredicateType *getPredicateType(unsigned Lanes) {
1011	unsigned key = Lanes;
1012	if (PredicateTypes.find(x: key) == PredicateTypes.end())
1013	PredicateTypes[key] = std::make_unique<PredicateType>(args&: Lanes);
1014	return PredicateTypes[key].get();
1015	}
1016	const PointerType *getPointerType(const Type *T, bool Const) {
1017	PointerType PT(T, Const);
1018	std::string key = PT.cName();
1019	if (PointerTypes.find(x: key) == PointerTypes.end())
1020	PointerTypes[key] = std::make_unique<PointerType>(args&: PT);
1021	return PointerTypes[key].get();
1022	}
1023
1024	// Methods to construct a type from various pieces of Tablegen. These are
1025	// always called in the context of setting up a particular ACLEIntrinsic, so
1026	// there's always an ambient parameter type (because we're iterating through
1027	// the Params list in the Tablegen record for the intrinsic), which is used
1028	// to expand Tablegen classes like 'Vector' which mean something different in
1029	// each member of a parametric family.
1030	const Type *getType(Record *R, const Type *Param);
1031	const Type *getType(DagInit *D, const Type *Param);
1032	const Type *getType(Init *I, const Type *Param);
1033
1034	// Functions that translate the Tablegen representation of an intrinsic's
1035	// code generation into a collection of Value objects (which will then be
1036	// reprocessed to read out the actual C++ code included by CGBuiltin.cpp).
1037	Result::Ptr getCodeForDag(DagInit *D, const Result::Scope &Scope,
1038	const Type *Param);
1039	Result::Ptr getCodeForDagArg(DagInit *D, unsigned ArgNum,
1040	const Result::Scope &Scope, const Type *Param);
1041	Result::Ptr getCodeForArg(unsigned ArgNum, const Type *ArgType, bool Promote,
1042	bool Immediate);
1043
1044	void GroupSemaChecks(std::map<std::string, std::set<std::string>> &Checks);
1045
1046	// Constructor and top-level functions.
1047
1048	EmitterBase(RecordKeeper &Records);
1049	virtual ~EmitterBase() = default;
1050
1051	virtual void EmitHeader(raw_ostream &OS) = 0;
1052	virtual void EmitBuiltinDef(raw_ostream &OS) = 0;
1053	virtual void EmitBuiltinSema(raw_ostream &OS) = 0;
1054	void EmitBuiltinCG(raw_ostream &OS);
1055	void EmitBuiltinAliases(raw_ostream &OS);
1056	};
1057
1058	const Type *EmitterBase::getType(Init *I, const Type *Param) {
1059	if (auto Dag = dyn_cast<DagInit>(Val: I))
1060	return getType(D: Dag, Param);
1061	if (auto Def = dyn_cast<DefInit>(Val: I))
1062	return getType(R: Def->getDef(), Param);
1063
1064	PrintFatalError(Msg: "Could not convert this value into a type");
1065	}
1066
1067	const Type *EmitterBase::getType(Record *R, const Type *Param) {
1068	// Pass to a subfield of any wrapper records. We don't expect more than one
1069	// of these: immediate operands are used as plain numbers rather than as
1070	// llvm::Value, so it's meaningless to promote their type anyway.
1071	if (R->isSubClassOf(Name: "Immediate"))
1072	R = R->getValueAsDef(FieldName: "type");
1073	else if (R->isSubClassOf(Name: "unpromoted"))
1074	R = R->getValueAsDef(FieldName: "underlying_type");
1075
1076	if (R->getName() == "Void")
1077	return getVoidType();
1078	if (R->isSubClassOf(Name: "PrimitiveType"))
1079	return getScalarType(R);
1080	if (R->isSubClassOf(Name: "ComplexType"))
1081	return getType(D: R->getValueAsDag(FieldName: "spec"), Param);
1082
1083	PrintFatalError(ErrorLoc: R->getLoc(), Msg: "Could not convert this record into a type");
1084	}
1085
1086	const Type *EmitterBase::getType(DagInit *D, const Type *Param) {
1087	// The meat of the getType system: types in the Tablegen are represented by a
1088	// dag whose operators select sub-cases of this function.
1089
1090	Record *Op = cast<DefInit>(Val: D->getOperator())->getDef();
1091	if (!Op->isSubClassOf(Name: "ComplexTypeOp"))
1092	PrintFatalError(
1093	Msg: "Expected ComplexTypeOp as dag operator in type expression");
1094
1095	if (Op->getName() == "CTO_Parameter") {
1096	if (isa<VoidType>(Val: Param))
1097	PrintFatalError(Msg: "Parametric type in unparametrised context");
1098	return Param;
1099	}
1100
1101	if (Op->getName() == "CTO_Vec") {
1102	const Type *Element = getType(I: D->getArg(Num: 0), Param);
1103	if (D->getNumArgs() == 1) {
1104	return getVectorType(ST: cast<ScalarType>(Val: Element));
1105	} else {
1106	const Type *ExistingVector = getType(I: D->getArg(Num: 1), Param);
1107	return getVectorType(ST: cast<ScalarType>(Val: Element),
1108	Lanes: cast<VectorType>(Val: ExistingVector)->lanes());
1109	}
1110	}
1111
1112	if (Op->getName() == "CTO_Pred") {
1113	const Type *Element = getType(I: D->getArg(Num: 0), Param);
1114	return getPredicateType(Lanes: 128 / Element->sizeInBits());
1115	}
1116
1117	if (Op->isSubClassOf(Name: "CTO_Tuple")) {
1118	unsigned Registers = Op->getValueAsInt(FieldName: "n");
1119	const Type *Element = getType(I: D->getArg(Num: 0), Param);
1120	return getMultiVectorType(Registers, VT: cast<VectorType>(Val: Element));
1121	}
1122
1123	if (Op->isSubClassOf(Name: "CTO_Pointer")) {
1124	const Type *Pointee = getType(I: D->getArg(Num: 0), Param);
1125	return getPointerType(T: Pointee, Const: Op->getValueAsBit(FieldName: "const"));
1126	}
1127
1128	if (Op->getName() == "CTO_CopyKind") {
1129	const ScalarType *STSize = cast<ScalarType>(Val: getType(I: D->getArg(Num: 0), Param));
1130	const ScalarType *STKind = cast<ScalarType>(Val: getType(I: D->getArg(Num: 1), Param));
1131	for (const auto &kv : ScalarTypes) {
1132	const ScalarType *RT = kv.second.get();
1133	if (RT->kind() == STKind->kind() && RT->sizeInBits() == STSize->sizeInBits())
1134	return RT;
1135	}
1136	PrintFatalError(Msg: "Cannot find a type to satisfy CopyKind");
1137	}
1138
1139	if (Op->isSubClassOf(Name: "CTO_ScaleSize")) {
1140	const ScalarType *STKind = cast<ScalarType>(Val: getType(I: D->getArg(Num: 0), Param));
1141	int Num = Op->getValueAsInt(FieldName: "num"), Denom = Op->getValueAsInt(FieldName: "denom");
1142	unsigned DesiredSize = STKind->sizeInBits() * Num / Denom;
1143	for (const auto &kv : ScalarTypes) {
1144	const ScalarType *RT = kv.second.get();
1145	if (RT->kind() == STKind->kind() && RT->sizeInBits() == DesiredSize)
1146	return RT;
1147	}
1148	PrintFatalError(Msg: "Cannot find a type to satisfy ScaleSize");
1149	}
1150
1151	PrintFatalError(Msg: "Bad operator in type dag expression");
1152	}
1153
1154	Result::Ptr EmitterBase::getCodeForDag(DagInit *D, const Result::Scope &Scope,
1155	const Type *Param) {
1156	Record *Op = cast<DefInit>(Val: D->getOperator())->getDef();
1157
1158	if (Op->getName() == "seq") {
1159	Result::Scope SubScope = Scope;
1160	Result::Ptr PrevV = nullptr;
1161	for (unsigned i = 0, e = D->getNumArgs(); i < e; ++i) {
1162	// We don't use getCodeForDagArg here, because the argument name
1163	// has different semantics in a seq
1164	Result::Ptr V =
1165	getCodeForDag(D: cast<DagInit>(Val: D->getArg(Num: i)), Scope: SubScope, Param);
1166	StringRef ArgName = D->getArgNameStr(Num: i);
1167	if (!ArgName.empty())
1168	SubScope[std::string(ArgName)] = V;
1169	if (PrevV)
1170	V->setPredecessor(PrevV);
1171	PrevV = V;
1172	}
1173	return PrevV;
1174	} else if (Op->isSubClassOf(Name: "Type")) {
1175	if (D->getNumArgs() != 1)
1176	PrintFatalError(Msg: "Type casts should have exactly one argument");
1177	const Type *CastType = getType(R: Op, Param);
1178	Result::Ptr Arg = getCodeForDagArg(D, ArgNum: 0, Scope, Param);
1179	if (const auto *ST = dyn_cast<ScalarType>(Val: CastType)) {
1180	if (!ST->requiresFloat()) {
1181	if (Arg->hasIntegerConstantValue())
1182	return std::make_shared<IntLiteralResult>(
1183	args&: ST, args: Arg->integerConstantValue());
1184	else
1185	return std::make_shared<IntCastResult>(args&: ST, args&: Arg);
1186	}
1187	} else if (const auto *PT = dyn_cast<PointerType>(Val: CastType)) {
1188	return std::make_shared<PointerCastResult>(args&: PT, args&: Arg);
1189	}
1190	PrintFatalError(Msg: "Unsupported type cast");
1191	} else if (Op->getName() == "address") {
1192	if (D->getNumArgs() != 2)
1193	PrintFatalError(Msg: "'address' should have two arguments");
1194	Result::Ptr Arg = getCodeForDagArg(D, ArgNum: 0, Scope, Param);
1195
1196	const Type *Ty = nullptr;
1197	if (auto *DI = dyn_cast<DagInit>(Val: D->getArg(Num: 0)))
1198	if (auto *PTy = dyn_cast<PointerType>(Val: getType(I: DI->getOperator(), Param)))
1199	Ty = PTy->getPointeeType();
1200	if (!Ty)
1201	PrintFatalError(Msg: "'address' pointer argument should be a pointer");
1202
1203	unsigned Alignment;
1204	if (auto *II = dyn_cast<IntInit>(Val: D->getArg(Num: 1))) {
1205	Alignment = II->getValue();
1206	} else {
1207	PrintFatalError(Msg: "'address' alignment argument should be an integer");
1208	}
1209	return std::make_shared<AddressResult>(args&: Arg, args&: Ty, args&: Alignment);
1210	} else if (Op->getName() == "unsignedflag") {
1211	if (D->getNumArgs() != 1)
1212	PrintFatalError(Msg: "unsignedflag should have exactly one argument");
1213	Record *TypeRec = cast<DefInit>(Val: D->getArg(Num: 0))->getDef();
1214	if (!TypeRec->isSubClassOf(Name: "Type"))
1215	PrintFatalError(Msg: "unsignedflag's argument should be a type");
1216	if (const auto *ST = dyn_cast<ScalarType>(Val: getType(R: TypeRec, Param))) {
1217	return std::make_shared<IntLiteralResult>(
1218	args: getScalarType(Name: "u32"), args: ST->kind() == ScalarTypeKind::UnsignedInt);
1219	} else {
1220	PrintFatalError(Msg: "unsignedflag's argument should be a scalar type");
1221	}
1222	} else if (Op->getName() == "bitsize") {
1223	if (D->getNumArgs() != 1)
1224	PrintFatalError(Msg: "bitsize should have exactly one argument");
1225	Record *TypeRec = cast<DefInit>(Val: D->getArg(Num: 0))->getDef();
1226	if (!TypeRec->isSubClassOf(Name: "Type"))
1227	PrintFatalError(Msg: "bitsize's argument should be a type");
1228	if (const auto *ST = dyn_cast<ScalarType>(Val: getType(R: TypeRec, Param))) {
1229	return std::make_shared<IntLiteralResult>(args: getScalarType(Name: "u32"),
1230	args: ST->sizeInBits());
1231	} else {
1232	PrintFatalError(Msg: "bitsize's argument should be a scalar type");
1233	}
1234	} else {
1235	std::vector<Result::Ptr> Args;
1236	for (unsigned i = 0, e = D->getNumArgs(); i < e; ++i)
1237	Args.push_back(x: getCodeForDagArg(D, ArgNum: i, Scope, Param));
1238	if (Op->isSubClassOf(Name: "IRBuilderBase")) {
1239	std::set<unsigned> AddressArgs;
1240	std::map<unsigned, std::string> IntegerArgs;
1241	for (Record *sp : Op->getValueAsListOfDefs(FieldName: "special_params")) {
1242	unsigned Index = sp->getValueAsInt(FieldName: "index");
1243	if (sp->isSubClassOf(Name: "IRBuilderAddrParam")) {
1244	AddressArgs.insert(x: Index);
1245	} else if (sp->isSubClassOf(Name: "IRBuilderIntParam")) {
1246	IntegerArgs[Index] = std::string(sp->getValueAsString(FieldName: "type"));
1247	}
1248	}
1249	return std::make_shared<IRBuilderResult>(args: Op->getValueAsString(FieldName: "prefix"),
1250	args&: Args, args&: AddressArgs, args&: IntegerArgs);
1251	} else if (Op->isSubClassOf(Name: "IRIntBase")) {
1252	std::vector<const Type *> ParamTypes;
1253	for (Record *RParam : Op->getValueAsListOfDefs(FieldName: "params"))
1254	ParamTypes.push_back(x: getType(R: RParam, Param));
1255	std::string IntName = std::string(Op->getValueAsString(FieldName: "intname"));
1256	if (Op->getValueAsBit(FieldName: "appendKind"))
1257	IntName += "_" + toLetter(kind: cast<ScalarType>(Val: Param)->kind());
1258	return std::make_shared<IRIntrinsicResult>(args&: IntName, args&: ParamTypes, args&: Args);
1259	} else {
1260	PrintFatalError(Msg: "Unsupported dag node " + Op->getName());
1261	}
1262	}
1263	}
1264
1265	Result::Ptr EmitterBase::getCodeForDagArg(DagInit *D, unsigned ArgNum,
1266	const Result::Scope &Scope,
1267	const Type *Param) {
1268	Init *Arg = D->getArg(Num: ArgNum);
1269	StringRef Name = D->getArgNameStr(Num: ArgNum);
1270
1271	if (!Name.empty()) {
1272	if (!isa<UnsetInit>(Val: Arg))
1273	PrintFatalError(
1274	Msg: "dag operator argument should not have both a value and a name");
1275	auto it = Scope.find(x: std::string(Name));
1276	if (it == Scope.end())
1277	PrintFatalError(Msg: "unrecognized variable name '" + Name + "'");
1278	return it->second;
1279	}
1280
1281	// Sometimes the Arg is a bit. Prior to multiclass template argument
1282	// checking, integers would sneak through the bit declaration,
1283	// but now they really are bits.
1284	if (auto *BI = dyn_cast<BitInit>(Val: Arg))
1285	return std::make_shared<IntLiteralResult>(args: getScalarType(Name: "u32"),
1286	args: BI->getValue());
1287
1288	if (auto *II = dyn_cast<IntInit>(Val: Arg))
1289	return std::make_shared<IntLiteralResult>(args: getScalarType(Name: "u32"),
1290	args: II->getValue());
1291
1292	if (auto *DI = dyn_cast<DagInit>(Val: Arg))
1293	return getCodeForDag(D: DI, Scope, Param);
1294
1295	if (auto *DI = dyn_cast<DefInit>(Val: Arg)) {
1296	Record *Rec = DI->getDef();
1297	if (Rec->isSubClassOf(Name: "Type")) {
1298	const Type *T = getType(R: Rec, Param);
1299	return std::make_shared<TypeResult>(args&: T);
1300	}
1301	}
1302
1303	PrintError(Msg: "bad DAG argument type for code generation");
1304	PrintNote(Msg: "DAG: " + D->getAsString());
1305	if (TypedInit *Typed = dyn_cast<TypedInit>(Val: Arg))
1306	PrintNote(Msg: "argument type: " + Typed->getType()->getAsString());
1307	PrintFatalNote(Msg: "argument number " + Twine(ArgNum) + ": " + Arg->getAsString());
1308	}
1309
1310	Result::Ptr EmitterBase::getCodeForArg(unsigned ArgNum, const Type *ArgType,
1311	bool Promote, bool Immediate) {
1312	Result::Ptr V = std::make_shared<BuiltinArgResult>(
1313	args&: ArgNum, args: isa<PointerType>(Val: ArgType), args&: Immediate);
1314
1315	if (Promote) {
1316	if (const auto *ST = dyn_cast<ScalarType>(Val: ArgType)) {
1317	if (ST->isInteger() && ST->sizeInBits() < 32)
1318	V = std::make_shared<IntCastResult>(args: getScalarType(Name: "u32"), args&: V);
1319	} else if (const auto *PT = dyn_cast<PredicateType>(Val: ArgType)) {
1320	V = std::make_shared<IntCastResult>(args: getScalarType(Name: "u32"), args&: V);
1321	V = std::make_shared<IRIntrinsicResult>(args: "arm_mve_pred_i2v",
1322	args: std::vector<const Type *>{PT},
1323	args: std::vector<Result::Ptr>{V});
1324	}
1325	}
1326
1327	return V;
1328	}
1329
1330	ACLEIntrinsic::ACLEIntrinsic(EmitterBase &ME, Record *R, const Type *Param)
1331	: ReturnType(ME.getType(R: R->getValueAsDef(FieldName: "ret"), Param)) {
1332	// Derive the intrinsic's full name, by taking the name of the
1333	// Tablegen record (or override) and appending the suffix from its
1334	// parameter type. (If the intrinsic is unparametrised, its
1335	// parameter type will be given as Void, which returns the empty
1336	// string for acleSuffix.)
1337	StringRef BaseName =
1338	(R->isSubClassOf(Name: "NameOverride") ? R->getValueAsString(FieldName: "basename")
1339	: R->getName());
1340	StringRef overrideLetter = R->getValueAsString(FieldName: "overrideKindLetter");
1341	FullName =
1342	(Twine(BaseName) + Param->acleSuffix(std::string(overrideLetter))).str();
1343
1344	// Derive the intrinsic's polymorphic name, by removing components from the
1345	// full name as specified by its 'pnt' member ('polymorphic name type'),
1346	// which indicates how many type suffixes to remove, and any other piece of
1347	// the name that should be removed.
1348	Record *PolymorphicNameType = R->getValueAsDef(FieldName: "pnt");
1349	SmallVector<StringRef, 8> NameParts;
1350	StringRef(FullName).split(A&: NameParts, Separator: '_');
1351	for (unsigned i = 0, e = PolymorphicNameType->getValueAsInt(
1352	FieldName: "NumTypeSuffixesToDiscard");
1353	i < e; ++i)
1354	NameParts.pop_back();
1355	if (!PolymorphicNameType->isValueUnset(FieldName: "ExtraSuffixToDiscard")) {
1356	StringRef ExtraSuffix =
1357	PolymorphicNameType->getValueAsString(FieldName: "ExtraSuffixToDiscard");
1358	auto it = NameParts.end();
1359	while (it != NameParts.begin()) {
1360	--it;
1361	if (*it == ExtraSuffix) {
1362	NameParts.erase(CI: it);
1363	break;
1364	}
1365	}
1366	}
1367	ShortName = join(Begin: std::begin(cont&: NameParts), End: std::end(cont&: NameParts), Separator: "_");
1368
1369	BuiltinExtension = R->getValueAsString(FieldName: "builtinExtension");
1370
1371	PolymorphicOnly = R->getValueAsBit(FieldName: "polymorphicOnly");
1372	NonEvaluating = R->getValueAsBit(FieldName: "nonEvaluating");
1373	HeaderOnly = R->getValueAsBit(FieldName: "headerOnly");
1374
1375	// Process the intrinsic's argument list.
1376	DagInit *ArgsDag = R->getValueAsDag(FieldName: "args");
1377	Result::Scope Scope;
1378	for (unsigned i = 0, e = ArgsDag->getNumArgs(); i < e; ++i) {
1379	Init *TypeInit = ArgsDag->getArg(Num: i);
1380
1381	bool Promote = true;
1382	if (auto TypeDI = dyn_cast<DefInit>(Val: TypeInit))
1383	if (TypeDI->getDef()->isSubClassOf(Name: "unpromoted"))
1384	Promote = false;
1385
1386	// Work out the type of the argument, for use in the function prototype in
1387	// the header file.
1388	const Type *ArgType = ME.getType(I: TypeInit, Param);
1389	ArgTypes.push_back(x: ArgType);
1390
1391	// If the argument is a subclass of Immediate, record the details about
1392	// what values it can take, for Sema checking.
1393	bool Immediate = false;
1394	if (auto TypeDI = dyn_cast<DefInit>(Val: TypeInit)) {
1395	Record *TypeRec = TypeDI->getDef();
1396	if (TypeRec->isSubClassOf(Name: "Immediate")) {
1397	Immediate = true;
1398
1399	Record *Bounds = TypeRec->getValueAsDef(FieldName: "bounds");
1400	ImmediateArg &IA = ImmediateArgs[i];
1401	if (Bounds->isSubClassOf(Name: "IB_ConstRange")) {
1402	IA.boundsType = ImmediateArg::BoundsType::ExplicitRange;
1403	IA.i1 = Bounds->getValueAsInt(FieldName: "lo");
1404	IA.i2 = Bounds->getValueAsInt(FieldName: "hi");
1405	} else if (Bounds->getName() == "IB_UEltValue") {
1406	IA.boundsType = ImmediateArg::BoundsType::UInt;
1407	IA.i1 = Param->sizeInBits();
1408	} else if (Bounds->getName() == "IB_LaneIndex") {
1409	IA.boundsType = ImmediateArg::BoundsType::ExplicitRange;
1410	IA.i1 = 0;
1411	IA.i2 = 128 / Param->sizeInBits() - 1;
1412	} else if (Bounds->isSubClassOf(Name: "IB_EltBit")) {
1413	IA.boundsType = ImmediateArg::BoundsType::ExplicitRange;
1414	IA.i1 = Bounds->getValueAsInt(FieldName: "base");
1415	const Type *T = ME.getType(R: Bounds->getValueAsDef(FieldName: "type"), Param);
1416	IA.i2 = IA.i1 + T->sizeInBits() - 1;
1417	} else {
1418	PrintFatalError(Msg: "unrecognised ImmediateBounds subclass");
1419	}
1420
1421	IA.ArgType = ArgType;
1422
1423	if (!TypeRec->isValueUnset(FieldName: "extra")) {
1424	IA.ExtraCheckType = TypeRec->getValueAsString(FieldName: "extra");
1425	if (!TypeRec->isValueUnset(FieldName: "extraarg"))
1426	IA.ExtraCheckArgs = TypeRec->getValueAsString(FieldName: "extraarg");
1427	}
1428	}
1429	}
1430
1431	// The argument will usually have a name in the arguments dag, which goes
1432	// into the variable-name scope that the code gen will refer to.
1433	StringRef ArgName = ArgsDag->getArgNameStr(Num: i);
1434	if (!ArgName.empty())
1435	Scope[std::string(ArgName)] =
1436	ME.getCodeForArg(ArgNum: i, ArgType, Promote, Immediate);
1437	}
1438
1439	// Finally, go through the codegen dag and translate it into a Result object
1440	// (with an arbitrary DAG of depended-on Results hanging off it).
1441	DagInit *CodeDag = R->getValueAsDag(FieldName: "codegen");
1442	Record *MainOp = cast<DefInit>(Val: CodeDag->getOperator())->getDef();
1443	if (MainOp->isSubClassOf(Name: "CustomCodegen")) {
1444	// Or, if it's the special case of CustomCodegen, just accumulate
1445	// a list of parameters we're going to assign to variables before
1446	// breaking from the loop.
1447	CustomCodeGenArgs["CustomCodeGenType"] =
1448	(Twine("CustomCodeGen::") + MainOp->getValueAsString(FieldName: "type")).str();
1449	for (unsigned i = 0, e = CodeDag->getNumArgs(); i < e; ++i) {
1450	StringRef Name = CodeDag->getArgNameStr(Num: i);
1451	if (Name.empty()) {
1452	PrintFatalError(Msg: "Operands to CustomCodegen should have names");
1453	} else if (auto *II = dyn_cast<IntInit>(Val: CodeDag->getArg(Num: i))) {
1454	CustomCodeGenArgs[std::string(Name)] = itostr(X: II->getValue());
1455	} else if (auto *SI = dyn_cast<StringInit>(Val: CodeDag->getArg(Num: i))) {
1456	CustomCodeGenArgs[std::string(Name)] = std::string(SI->getValue());
1457	} else {
1458	PrintFatalError(Msg: "Operands to CustomCodegen should be integers");
1459	}
1460	}
1461	} else {
1462	Code = ME.getCodeForDag(D: CodeDag, Scope, Param);
1463	}
1464	}
1465
1466	EmitterBase::EmitterBase(RecordKeeper &Records) {
1467	// Construct the whole EmitterBase.
1468
1469	// First, look up all the instances of PrimitiveType. This gives us the list
1470	// of vector typedefs we have to put in arm_mve.h, and also allows us to
1471	// collect all the useful ScalarType instances into a big list so that we can
1472	// use it for operations such as 'find the unsigned version of this signed
1473	// integer type'.
1474	for (Record *R : Records.getAllDerivedDefinitions(ClassName: "PrimitiveType"))
1475	ScalarTypes[std::string(R->getName())] = std::make_unique<ScalarType>(args&: R);
1476
1477	// Now go through the instances of Intrinsic, and for each one, iterate
1478	// through its list of type parameters making an ACLEIntrinsic for each one.
1479	for (Record *R : Records.getAllDerivedDefinitions(ClassName: "Intrinsic")) {
1480	for (Record *RParam : R->getValueAsListOfDefs(FieldName: "params")) {
1481	const Type *Param = getType(R: RParam, Param: getVoidType());
1482	auto Intrinsic = std::make_unique<ACLEIntrinsic>(args&: *this, args&: R, args&: Param);
1483	ACLEIntrinsics[Intrinsic->fullName()] = std::move(Intrinsic);
1484	}
1485	}
1486	}
1487
1488	/// A wrapper on raw_string_ostream that contains its own buffer rather than
1489	/// having to point it at one elsewhere. (In other words, it works just like
1490	/// std::ostringstream; also, this makes it convenient to declare a whole array
1491	/// of them at once.)
1492	///
1493	/// We have to set this up using multiple inheritance, to ensure that the
1494	/// string member has been constructed before raw_string_ostream's constructor
1495	/// is given a pointer to it.
1496	class string_holder {
1497	protected:
1498	std::string S;
1499	};
1500	class raw_self_contained_string_ostream : private string_holder,
1501	public raw_string_ostream {
1502	public:
1503	raw_self_contained_string_ostream() : raw_string_ostream(S) {}
1504	};
1505
1506	const char LLVMLicenseHeader[] =
1507	" *\n"
1508	" *\n"
1509	" * Part of the LLVM Project, under the Apache License v2.0 with LLVM"
1510	" Exceptions.\n"
1511	" * See https://llvm.org/LICENSE.txt for license information.\n"
1512	" * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\n"
1513	" *\n"
1514	" *===-----------------------------------------------------------------"
1515	"------===\n"
1516	" */\n"
1517	"\n";
1518
1519	// Machinery for the grouping of intrinsics by similar codegen.
1520	//
1521	// The general setup is that 'MergeableGroup' stores the things that a set of
1522	// similarly shaped intrinsics have in common: the text of their code
1523	// generation, and the number and type of their parameter variables.
1524	// MergeableGroup is the key in a std::map whose value is a set of
1525	// OutputIntrinsic, which stores the ways in which a particular intrinsic
1526	// specializes the MergeableGroup's generic description: the function name and
1527	// the _values_ of the parameter variables.
1528
1529	struct ComparableStringVector : std::vector<std::string> {
1530	// Infrastructure: a derived class of vector<string> which comes with an
1531	// ordering, so that it can be used as a key in maps and an element in sets.
1532	// There's no requirement on the ordering beyond being deterministic.
1533	bool operator<(const ComparableStringVector &rhs) const {
1534	if (size() != rhs.size())
1535	return size() < rhs.size();
1536	for (size_t i = 0, e = size(); i < e; ++i)
1537	if ((*this)[i] != rhs[i])
1538	return (*this)[i] < rhs[i];
1539	return false;
1540	}
1541	};
1542
1543	struct OutputIntrinsic {
1544	const ACLEIntrinsic *Int;
1545	std::string Name;
1546	ComparableStringVector ParamValues;
1547	bool operator<(const OutputIntrinsic &rhs) const {
1548	if (Name != rhs.Name)
1549	return Name < rhs.Name;
1550	return ParamValues < rhs.ParamValues;
1551	}
1552	};
1553	struct MergeableGroup {
1554	std::string Code;
1555	ComparableStringVector ParamTypes;
1556	bool operator<(const MergeableGroup &rhs) const {
1557	if (Code != rhs.Code)
1558	return Code < rhs.Code;
1559	return ParamTypes < rhs.ParamTypes;
1560	}
1561	};
1562
1563	void EmitterBase::EmitBuiltinCG(raw_ostream &OS) {
1564	// Pass 1: generate code for all the intrinsics as if every type or constant
1565	// that can possibly be abstracted out into a parameter variable will be.
1566	// This identifies the sets of intrinsics we'll group together into a single
1567	// piece of code generation.
1568
1569	std::map<MergeableGroup, std::set<OutputIntrinsic>> MergeableGroupsPrelim;
1570
1571	for (const auto &kv : ACLEIntrinsics) {
1572	const ACLEIntrinsic &Int = *kv.second;
1573	if (Int.headerOnly())
1574	continue;
1575
1576	MergeableGroup MG;
1577	OutputIntrinsic OI;
1578
1579	OI.Int = &Int;
1580	OI.Name = Int.fullName();
1581	CodeGenParamAllocator ParamAllocPrelim{.ParamTypes: &MG.ParamTypes, .ParamValues: &OI.ParamValues};
1582	raw_string_ostream OS(MG.Code);
1583	Int.genCode(OS, ParamAlloc&: ParamAllocPrelim, Pass: 1);
1584	OS.flush();
1585
1586	MergeableGroupsPrelim[MG].insert(x: OI);
1587	}
1588
1589	// Pass 2: for each of those groups, optimize the parameter variable set by
1590	// eliminating 'parameters' that are the same for all intrinsics in the
1591	// group, and merging together pairs of parameter variables that take the
1592	// same values as each other for all intrinsics in the group.
1593
1594	std::map<MergeableGroup, std::set<OutputIntrinsic>> MergeableGroups;
1595
1596	for (const auto &kv : MergeableGroupsPrelim) {
1597	const MergeableGroup &MG = kv.first;
1598	std::vector<int> ParamNumbers;
1599	std::map<ComparableStringVector, int> ParamNumberMap;
1600
1601	// Loop over the parameters for this group.
1602	for (size_t i = 0, e = MG.ParamTypes.size(); i < e; ++i) {
1603	// Is this parameter the same for all intrinsics in the group?
1604	const OutputIntrinsic &OI_first = *kv.second.begin();
1605	bool Constant = all_of(Range: kv.second, P: [&](const OutputIntrinsic &OI) {
1606	return OI.ParamValues[i] == OI_first.ParamValues[i];
1607	});
1608
1609	// If so, record it as -1, meaning 'no parameter variable needed'. Then
1610	// the corresponding call to allocParam in pass 2 will not generate a
1611	// variable at all, and just use the value inline.
1612	if (Constant) {
1613	ParamNumbers.push_back(x: -1);
1614	continue;
1615	}
1616
1617	// Otherwise, make a list of the values this parameter takes for each
1618	// intrinsic, and see if that value vector matches anything we already
1619	// have. We also record the parameter type, so that we don't accidentally
1620	// match up two parameter variables with different types. (Not that
1621	// there's much chance of them having textually equivalent values, but in
1622	// _principle_ it could happen.)
1623	ComparableStringVector key;
1624	key.push_back(x: MG.ParamTypes[i]);
1625	for (const auto &OI : kv.second)
1626	key.push_back(x: OI.ParamValues[i]);
1627
1628	auto Found = ParamNumberMap.find(x: key);
1629	if (Found != ParamNumberMap.end()) {
1630	// Yes, an existing parameter variable can be reused for this.
1631	ParamNumbers.push_back(x: Found->second);
1632	continue;
1633	}
1634
1635	// No, we need a new parameter variable.
1636	int ExistingIndex = ParamNumberMap.size();
1637	ParamNumberMap[key] = ExistingIndex;
1638	ParamNumbers.push_back(x: ExistingIndex);
1639	}
1640
1641	// Now we're ready to do the pass 2 code generation, which will emit the
1642	// reduced set of parameter variables we've just worked out.
1643
1644	for (const auto &OI_prelim : kv.second) {
1645	const ACLEIntrinsic *Int = OI_prelim.Int;
1646
1647	MergeableGroup MG;
1648	OutputIntrinsic OI;
1649
1650	OI.Int = OI_prelim.Int;
1651	OI.Name = OI_prelim.Name;
1652	CodeGenParamAllocator ParamAlloc{.ParamTypes: &MG.ParamTypes, .ParamValues: &OI.ParamValues,
1653	.ParamNumberMap: &ParamNumbers};
1654	raw_string_ostream OS(MG.Code);
1655	Int->genCode(OS, ParamAlloc, Pass: 2);
1656	OS.flush();
1657
1658	MergeableGroups[MG].insert(x: OI);
1659	}
1660	}
1661
1662	// Output the actual C++ code.
1663
1664	for (const auto &kv : MergeableGroups) {
1665	const MergeableGroup &MG = kv.first;
1666
1667	// List of case statements in the main switch on BuiltinID, and an open
1668	// brace.
1669	const char *prefix = "";
1670	for (const auto &OI : kv.second) {
1671	OS << prefix << "case ARM::BI__builtin_arm_" << OI.Int->builtinExtension()
1672	<< "_" << OI.Name << ":";
1673
1674	prefix = "\n";
1675	}
1676	OS << " {\n";
1677
1678	if (!MG.ParamTypes.empty()) {
1679	// If we've got some parameter variables, then emit their declarations...
1680	for (size_t i = 0, e = MG.ParamTypes.size(); i < e; ++i) {
1681	StringRef Type = MG.ParamTypes[i];
1682	OS << " " << Type;
1683	if (!Type.ends_with(Suffix: "*"))
1684	OS << " ";
1685	OS << " Param" << utostr(X: i) << ";\n";
1686	}
1687
1688	// ... and an inner switch on BuiltinID that will fill them in with each
1689	// individual intrinsic's values.
1690	OS << " switch (BuiltinID) {\n";
1691	for (const auto &OI : kv.second) {
1692	OS << " case ARM::BI__builtin_arm_" << OI.Int->builtinExtension()
1693	<< "_" << OI.Name << ":\n";
1694	for (size_t i = 0, e = MG.ParamTypes.size(); i < e; ++i)
1695	OS << " Param" << utostr(X: i) << " = " << OI.ParamValues[i] << ";\n";
1696	OS << " break;\n";
1697	}
1698	OS << " }\n";
1699	}
1700
1701	// And finally, output the code, and close the outer pair of braces. (The
1702	// code will always end with a 'return' statement, so we need not insert a
1703	// 'break' here.)
1704	OS << MG.Code << "}\n";
1705	}
1706	}
1707
1708	void EmitterBase::EmitBuiltinAliases(raw_ostream &OS) {
1709	// Build a sorted table of:
1710	// - intrinsic id number
1711	// - full name
1712	// - polymorphic name or -1
1713	StringToOffsetTable StringTable;
1714	OS << "static const IntrinToName MapData[] = {\n";
1715	for (const auto &kv : ACLEIntrinsics) {
1716	const ACLEIntrinsic &Int = *kv.second;
1717	if (Int.headerOnly())
1718	continue;
1719	int32_t ShortNameOffset =
1720	Int.polymorphic() ? StringTable.GetOrAddStringOffset(Str: Int.shortName())
1721	: -1;
1722	OS << " { ARM::BI__builtin_arm_" << Int.builtinExtension() << "_"
1723	<< Int.fullName() << ", "
1724	<< StringTable.GetOrAddStringOffset(Str: Int.fullName()) << ", "
1725	<< ShortNameOffset << "},\n";
1726	}
1727	OS << "};\n\n";
1728
1729	OS << "ArrayRef<IntrinToName> Map(MapData);\n\n";
1730
1731	OS << "static const char IntrinNames[] = {\n";
1732	StringTable.EmitString(O&: OS);
1733	OS << "};\n\n";
1734	}
1735
1736	void EmitterBase::GroupSemaChecks(
1737	std::map<std::string, std::set<std::string>> &Checks) {
1738	for (const auto &kv : ACLEIntrinsics) {
1739	const ACLEIntrinsic &Int = *kv.second;
1740	if (Int.headerOnly())
1741	continue;
1742	std::string Check = Int.genSema();
1743	if (!Check.empty())
1744	Checks[Check].insert(x: Int.fullName());
1745	}
1746	}
1747
1748	// -----------------------------------------------------------------------------
1749	// The class used for generating arm_mve.h and related Clang bits
1750	//
1751
1752	class MveEmitter : public EmitterBase {
1753	public:
1754	MveEmitter(RecordKeeper &Records) : EmitterBase(Records){};
1755	void EmitHeader(raw_ostream &OS) override;
1756	void EmitBuiltinDef(raw_ostream &OS) override;
1757	void EmitBuiltinSema(raw_ostream &OS) override;
1758	};
1759
1760	void MveEmitter::EmitHeader(raw_ostream &OS) {
1761	// Accumulate pieces of the header file that will be enabled under various
1762	// different combinations of #ifdef. The index into parts[] is made up of
1763	// the following bit flags.
1764	constexpr unsigned Float = 1;
1765	constexpr unsigned UseUserNamespace = 2;
1766
1767	constexpr unsigned NumParts = 4;
1768	raw_self_contained_string_ostream parts[NumParts];
1769
1770	// Write typedefs for all the required vector types, and a few scalar
1771	// types that don't already have the name we want them to have.
1772
1773	parts[0] << "typedef uint16_t mve_pred16_t;\n";
1774	parts[Float] << "typedef __fp16 float16_t;\n"
1775	"typedef float float32_t;\n";
1776	for (const auto &kv : ScalarTypes) {
1777	const ScalarType *ST = kv.second.get();
1778	if (ST->hasNonstandardName())
1779	continue;
1780	raw_ostream &OS = parts[ST->requiresFloat() ? Float : 0];
1781	const VectorType *VT = getVectorType(ST);
1782
1783	OS << "typedef __attribute__((__neon_vector_type__(" << VT->lanes()
1784	<< "), __clang_arm_mve_strict_polymorphism)) " << ST->cName() << " "
1785	<< VT->cName() << ";\n";
1786
1787	// Every vector type also comes with a pair of multi-vector types for
1788	// the VLD2 and VLD4 instructions.
1789	for (unsigned n = 2; n <= 4; n += 2) {
1790	const MultiVectorType *MT = getMultiVectorType(Registers: n, VT);
1791	OS << "typedef struct { " << VT->cName() << " val[" << n << "]; } "
1792	<< MT->cName() << ";\n";
1793	}
1794	}
1795	parts[0] << "\n";
1796	parts[Float] << "\n";
1797
1798	// Write declarations for all the intrinsics.
1799
1800	for (const auto &kv : ACLEIntrinsics) {
1801	const ACLEIntrinsic &Int = *kv.second;
1802
1803	// We generate each intrinsic twice, under its full unambiguous
1804	// name and its shorter polymorphic name (if the latter exists).
1805	for (bool Polymorphic : {false, true}) {
1806	if (Polymorphic && !Int.polymorphic())
1807	continue;
1808	if (!Polymorphic && Int.polymorphicOnly())
1809	continue;
1810
1811	// We also generate each intrinsic under a name like __arm_vfooq
1812	// (which is in C language implementation namespace, so it's
1813	// safe to define in any conforming user program) and a shorter
1814	// one like vfooq (which is in user namespace, so a user might
1815	// reasonably have used it for something already). If so, they
1816	// can #define __ARM_MVE_PRESERVE_USER_NAMESPACE before
1817	// including the header, which will suppress the shorter names
1818	// and leave only the implementation-namespace ones. Then they
1819	// have to write __arm_vfooq everywhere, of course.
1820
1821	for (bool UserNamespace : {false, true}) {
1822	raw_ostream &OS = parts[(Int.requiresFloat() ? Float : 0) |
1823	(UserNamespace ? UseUserNamespace : 0)];
1824
1825	// Make the name of the function in this declaration.
1826
1827	std::string FunctionName =
1828	Polymorphic ? Int.shortName() : Int.fullName();
1829	if (!UserNamespace)
1830	FunctionName = "__arm_" + FunctionName;
1831
1832	// Make strings for the types involved in the function's
1833	// prototype.
1834
1835	std::string RetTypeName = Int.returnType()->cName();
1836	if (!StringRef(RetTypeName).ends_with(Suffix: "*"))
1837	RetTypeName += " ";
1838
1839	std::vector<std::string> ArgTypeNames;
1840	for (const Type *ArgTypePtr : Int.argTypes())
1841	ArgTypeNames.push_back(x: ArgTypePtr->cName());
1842	std::string ArgTypesString =
1843	join(Begin: std::begin(cont&: ArgTypeNames), End: std::end(cont&: ArgTypeNames), Separator: ", ");
1844
1845	// Emit the actual declaration. All these functions are
1846	// declared 'static inline' without a body, which is fine
1847	// provided clang recognizes them as builtins, and has the
1848	// effect that this type signature is used in place of the one
1849	// that Builtins.td didn't provide. That's how we can get
1850	// structure types that weren't defined until this header was
1851	// included to be part of the type signature of a builtin that
1852	// was known to clang already.
1853	//
1854	// The declarations use __attribute__(__clang_arm_builtin_alias),
1855	// so that each function declared will be recognized as the
1856	// appropriate MVE builtin in spite of its user-facing name.
1857	//
1858	// (That's better than making them all wrapper functions,
1859	// partly because it avoids any compiler error message citing
1860	// the wrapper function definition instead of the user's code,
1861	// and mostly because some MVE intrinsics have arguments
1862	// required to be compile-time constants, and that property
1863	// can't be propagated through a wrapper function. It can be
1864	// propagated through a macro, but macros can't be overloaded
1865	// on argument types very easily - you have to use _Generic,
1866	// which makes error messages very confusing when the user
1867	// gets it wrong.)
1868	//
1869	// Finally, the polymorphic versions of the intrinsics are
1870	// also defined with __attribute__(overloadable), so that when
1871	// the same name is defined with several type signatures, the
1872	// right thing happens. Each one of the overloaded
1873	// declarations is given a different builtin id, which
1874	// has exactly the effect we want: first clang resolves the
1875	// overload to the right function, then it knows which builtin
1876	// it's referring to, and then the Sema checking for that
1877	// builtin can check further things like the constant
1878	// arguments.
1879	//
1880	// One more subtlety is the newline just before the return
1881	// type name. That's a cosmetic tweak to make the error
1882	// messages legible if the user gets the types wrong in a call
1883	// to a polymorphic function: this way, clang will print just
1884	// the _final_ line of each declaration in the header, to show
1885	// the type signatures that would have been legal. So all the
1886	// confusing machinery with __attribute__ is left out of the
1887	// error message, and the user sees something that's more or
1888	// less self-documenting: "here's a list of actually readable
1889	// type signatures for vfooq(), and here's why each one didn't
1890	// match your call".
1891
1892	OS << "static __inline__ __attribute__(("
1893	<< (Polymorphic ? "__overloadable__, " : "")
1894	<< "__clang_arm_builtin_alias(__builtin_arm_mve_" << Int.fullName()
1895	<< ")))\n"
1896	<< RetTypeName << FunctionName << "(" << ArgTypesString << ");\n";
1897	}
1898	}
1899	}
1900	for (auto &part : parts)
1901	part << "\n";
1902
1903	// Now we've finished accumulating bits and pieces into the parts[] array.
1904	// Put it all together to write the final output file.
1905
1906	OS << "/*===---- arm_mve.h - ARM MVE intrinsics "
1907	"-----------------------------------===\n"
1908	<< LLVMLicenseHeader
1909	<< "#ifndef __ARM_MVE_H\n"
1910	"#define __ARM_MVE_H\n"
1911	"\n"
1912	"#if !__ARM_FEATURE_MVE\n"
1913	"#error \"MVE support not enabled\"\n"
1914	"#endif\n"
1915	"\n"
1916	"#include <stdint.h>\n"
1917	"\n"
1918	"#ifdef __cplusplus\n"
1919	"extern \"C\" {\n"
1920	"#endif\n"
1921	"\n";
1922
1923	for (size_t i = 0; i < NumParts; ++i) {
1924	std::vector<std::string> conditions;
1925	if (i & Float)
1926	conditions.push_back(x: "(__ARM_FEATURE_MVE & 2)");
1927	if (i & UseUserNamespace)
1928	conditions.push_back(x: "(!defined __ARM_MVE_PRESERVE_USER_NAMESPACE)");
1929
1930	std::string condition =
1931	join(Begin: std::begin(cont&: conditions), End: std::end(cont&: conditions), Separator: " && ");
1932	if (!condition.empty())
1933	OS << "#if " << condition << "\n\n";
1934	OS << parts[i].str();
1935	if (!condition.empty())
1936	OS << "#endif /* " << condition << " */\n\n";
1937	}
1938
1939	OS << "#ifdef __cplusplus\n"
1940	"} /* extern \"C\" */\n"
1941	"#endif\n"
1942	"\n"
1943	"#endif /* __ARM_MVE_H */\n";
1944	}
1945
1946	void MveEmitter::EmitBuiltinDef(raw_ostream &OS) {
1947	for (const auto &kv : ACLEIntrinsics) {
1948	const ACLEIntrinsic &Int = *kv.second;
1949	OS << "BUILTIN(__builtin_arm_mve_" << Int.fullName()
1950	<< ", \"\", \"n\")\n";
1951	}
1952
1953	std::set<std::string> ShortNamesSeen;
1954
1955	for (const auto &kv : ACLEIntrinsics) {
1956	const ACLEIntrinsic &Int = *kv.second;
1957	if (Int.polymorphic()) {
1958	StringRef Name = Int.shortName();
1959	if (ShortNamesSeen.find(x: std::string(Name)) == ShortNamesSeen.end()) {
1960	OS << "BUILTIN(__builtin_arm_mve_" << Name << ", \"vi.\", \"nt";
1961	if (Int.nonEvaluating())
1962	OS << "u"; // indicate that this builtin doesn't evaluate its args
1963	OS << "\")\n";
1964	ShortNamesSeen.insert(x: std::string(Name));
1965	}
1966	}
1967	}
1968	}
1969
1970	void MveEmitter::EmitBuiltinSema(raw_ostream &OS) {
1971	std::map<std::string, std::set<std::string>> Checks;
1972	GroupSemaChecks(Checks);
1973
1974	for (const auto &kv : Checks) {
1975	for (StringRef Name : kv.second)
1976	OS << "case ARM::BI__builtin_arm_mve_" << Name << ":\n";
1977	OS << " return " << kv.first;
1978	}
1979	}
1980
1981	// -----------------------------------------------------------------------------
1982	// Class that describes an ACLE intrinsic implemented as a macro.
1983	//
1984	// This class is used when the intrinsic is polymorphic in 2 or 3 types, but we
1985	// want to avoid a combinatorial explosion by reinterpreting the arguments to
1986	// fixed types.
1987
1988	class FunctionMacro {
1989	std::vector<StringRef> Params;
1990	StringRef Definition;
1991
1992	public:
1993	FunctionMacro(const Record &R);
1994
1995	const std::vector<StringRef> &getParams() const { return Params; }
1996	StringRef getDefinition() const { return Definition; }
1997	};
1998
1999	FunctionMacro::FunctionMacro(const Record &R) {
2000	Params = R.getValueAsListOfStrings(FieldName: "params");
2001	Definition = R.getValueAsString(FieldName: "definition");
2002	}
2003
2004	// -----------------------------------------------------------------------------
2005	// The class used for generating arm_cde.h and related Clang bits
2006	//
2007
2008	class CdeEmitter : public EmitterBase {
2009	std::map<StringRef, FunctionMacro> FunctionMacros;
2010
2011	public:
2012	CdeEmitter(RecordKeeper &Records);
2013	void EmitHeader(raw_ostream &OS) override;
2014	void EmitBuiltinDef(raw_ostream &OS) override;
2015	void EmitBuiltinSema(raw_ostream &OS) override;
2016	};
2017
2018	CdeEmitter::CdeEmitter(RecordKeeper &Records) : EmitterBase(Records) {
2019	for (Record *R : Records.getAllDerivedDefinitions(ClassName: "FunctionMacro"))
2020	FunctionMacros.emplace(args: R->getName(), args: FunctionMacro(*R));
2021	}
2022
2023	void CdeEmitter::EmitHeader(raw_ostream &OS) {
2024	// Accumulate pieces of the header file that will be enabled under various
2025	// different combinations of #ifdef. The index into parts[] is one of the
2026	// following:
2027	constexpr unsigned None = 0;
2028	constexpr unsigned MVE = 1;
2029	constexpr unsigned MVEFloat = 2;
2030
2031	constexpr unsigned NumParts = 3;
2032	raw_self_contained_string_ostream parts[NumParts];
2033
2034	// Write typedefs for all the required vector types, and a few scalar
2035	// types that don't already have the name we want them to have.
2036
2037	parts[MVE] << "typedef uint16_t mve_pred16_t;\n";
2038	parts[MVEFloat] << "typedef __fp16 float16_t;\n"
2039	"typedef float float32_t;\n";
2040	for (const auto &kv : ScalarTypes) {
2041	const ScalarType *ST = kv.second.get();
2042	if (ST->hasNonstandardName())
2043	continue;
2044	// We don't have float64x2_t
2045	if (ST->kind() == ScalarTypeKind::Float && ST->sizeInBits() == 64)
2046	continue;
2047	raw_ostream &OS = parts[ST->requiresFloat() ? MVEFloat : MVE];
2048	const VectorType *VT = getVectorType(ST);
2049
2050	OS << "typedef __attribute__((__neon_vector_type__(" << VT->lanes()
2051	<< "), __clang_arm_mve_strict_polymorphism)) " << ST->cName() << " "
2052	<< VT->cName() << ";\n";
2053	}
2054	parts[MVE] << "\n";
2055	parts[MVEFloat] << "\n";
2056
2057	// Write declarations for all the intrinsics.
2058
2059	for (const auto &kv : ACLEIntrinsics) {
2060	const ACLEIntrinsic &Int = *kv.second;
2061
2062	// We generate each intrinsic twice, under its full unambiguous
2063	// name and its shorter polymorphic name (if the latter exists).
2064	for (bool Polymorphic : {false, true}) {
2065	if (Polymorphic && !Int.polymorphic())
2066	continue;
2067	if (!Polymorphic && Int.polymorphicOnly())
2068	continue;
2069
2070	raw_ostream &OS =
2071	parts[Int.requiresFloat() ? MVEFloat
2072	: Int.requiresMVE() ? MVE : None];
2073
2074	// Make the name of the function in this declaration.
2075	std::string FunctionName =
2076	"__arm_" + (Polymorphic ? Int.shortName() : Int.fullName());
2077
2078	// Make strings for the types involved in the function's
2079	// prototype.
2080	std::string RetTypeName = Int.returnType()->cName();
2081	if (!StringRef(RetTypeName).ends_with(Suffix: "*"))
2082	RetTypeName += " ";
2083
2084	std::vector<std::string> ArgTypeNames;
2085	for (const Type *ArgTypePtr : Int.argTypes())
2086	ArgTypeNames.push_back(x: ArgTypePtr->cName());
2087	std::string ArgTypesString =
2088	join(Begin: std::begin(cont&: ArgTypeNames), End: std::end(cont&: ArgTypeNames), Separator: ", ");
2089
2090	// Emit the actual declaration. See MveEmitter::EmitHeader for detailed
2091	// comments
2092	OS << "static __inline__ __attribute__(("
2093	<< (Polymorphic ? "__overloadable__, " : "")
2094	<< "__clang_arm_builtin_alias(__builtin_arm_" << Int.builtinExtension()
2095	<< "_" << Int.fullName() << ")))\n"
2096	<< RetTypeName << FunctionName << "(" << ArgTypesString << ");\n";
2097	}
2098	}
2099
2100	for (const auto &kv : FunctionMacros) {
2101	StringRef Name = kv.first;
2102	const FunctionMacro &FM = kv.second;
2103
2104	raw_ostream &OS = parts[MVE];
2105	OS << "#define "
2106	<< "__arm_" << Name << "(" << join(R: FM.getParams(), Separator: ", ") << ") "
2107	<< FM.getDefinition() << "\n";
2108	}
2109
2110	for (auto &part : parts)
2111	part << "\n";
2112
2113	// Now we've finished accumulating bits and pieces into the parts[] array.
2114	// Put it all together to write the final output file.
2115
2116	OS << "/*===---- arm_cde.h - ARM CDE intrinsics "
2117	"-----------------------------------===\n"
2118	<< LLVMLicenseHeader
2119	<< "#ifndef __ARM_CDE_H\n"
2120	"#define __ARM_CDE_H\n"
2121	"\n"
2122	"#if !__ARM_FEATURE_CDE\n"
2123	"#error \"CDE support not enabled\"\n"
2124	"#endif\n"
2125	"\n"
2126	"#include <stdint.h>\n"
2127	"\n"
2128	"#ifdef __cplusplus\n"
2129	"extern \"C\" {\n"
2130	"#endif\n"
2131	"\n";
2132
2133	for (size_t i = 0; i < NumParts; ++i) {
2134	std::string condition;
2135	if (i == MVEFloat)
2136	condition = "__ARM_FEATURE_MVE & 2";
2137	else if (i == MVE)
2138	condition = "__ARM_FEATURE_MVE";
2139
2140	if (!condition.empty())
2141	OS << "#if " << condition << "\n\n";
2142	OS << parts[i].str();
2143	if (!condition.empty())
2144	OS << "#endif /* " << condition << " */\n\n";
2145	}
2146
2147	OS << "#ifdef __cplusplus\n"
2148	"} /* extern \"C\" */\n"
2149	"#endif\n"
2150	"\n"
2151	"#endif /* __ARM_CDE_H */\n";
2152	}
2153
2154	void CdeEmitter::EmitBuiltinDef(raw_ostream &OS) {
2155	for (const auto &kv : ACLEIntrinsics) {
2156	if (kv.second->headerOnly())
2157	continue;
2158	const ACLEIntrinsic &Int = *kv.second;
2159	OS << "BUILTIN(__builtin_arm_cde_" << Int.fullName()
2160	<< ", \"\", \"ncU\")\n";
2161	}
2162	}
2163
2164	void CdeEmitter::EmitBuiltinSema(raw_ostream &OS) {
2165	std::map<std::string, std::set<std::string>> Checks;
2166	GroupSemaChecks(Checks);
2167
2168	for (const auto &kv : Checks) {
2169	for (StringRef Name : kv.second)
2170	OS << "case ARM::BI__builtin_arm_cde_" << Name << ":\n";
2171	OS << " Err = " << kv.first << " break;\n";
2172	}
2173	}
2174
2175	} // namespace
2176
2177	namespace clang {
2178
2179	// MVE
2180
2181	void EmitMveHeader(RecordKeeper &Records, raw_ostream &OS) {
2182	MveEmitter(Records).EmitHeader(OS);
2183	}
2184
2185	void EmitMveBuiltinDef(RecordKeeper &Records, raw_ostream &OS) {
2186	MveEmitter(Records).EmitBuiltinDef(OS);
2187	}
2188
2189	void EmitMveBuiltinSema(RecordKeeper &Records, raw_ostream &OS) {
2190	MveEmitter(Records).EmitBuiltinSema(OS);
2191	}
2192
2193	void EmitMveBuiltinCG(RecordKeeper &Records, raw_ostream &OS) {
2194	MveEmitter(Records).EmitBuiltinCG(OS);
2195	}
2196
2197	void EmitMveBuiltinAliases(RecordKeeper &Records, raw_ostream &OS) {
2198	MveEmitter(Records).EmitBuiltinAliases(OS);
2199	}
2200
2201	// CDE
2202
2203	void EmitCdeHeader(RecordKeeper &Records, raw_ostream &OS) {
2204	CdeEmitter(Records).EmitHeader(OS);
2205	}
2206
2207	void EmitCdeBuiltinDef(RecordKeeper &Records, raw_ostream &OS) {
2208	CdeEmitter(Records).EmitBuiltinDef(OS);
2209	}
2210
2211	void EmitCdeBuiltinSema(RecordKeeper &Records, raw_ostream &OS) {
2212	CdeEmitter(Records).EmitBuiltinSema(OS);
2213	}
2214
2215	void EmitCdeBuiltinCG(RecordKeeper &Records, raw_ostream &OS) {
2216	CdeEmitter(Records).EmitBuiltinCG(OS);
2217	}
2218
2219	void EmitCdeBuiltinAliases(RecordKeeper &Records, raw_ostream &OS) {
2220	CdeEmitter(Records).EmitBuiltinAliases(OS);
2221	}
2222
2223	} // end namespace clang
2224