Coverage Report

Created: 2020-09-19 12:23

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