/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/utils/TableGen/MveEmitter.cpp

Bug Summary

File:	build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/utils/TableGen/MveEmitter.cpp
Warning:	line 1411, column 23 Division by zero

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name MveEmitter.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -resource-dir /usr/lib/llvm-15/lib/clang/15.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/clang/utils/TableGen -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/utils/TableGen -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/include -I tools/clang/include -I include -I /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-15/lib/clang/15.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fmacro-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fcoverage-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -O3 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/build-llvm=build-llvm -fdebug-prefix-map=/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-04-20-140412-16051-1 -x c++ /build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/utils/TableGen/MveEmitter.cpp

/build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/clang/utils/TableGen/MveEmitter.cpp

→

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//===----------------------------------------------------------------------===//

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>

79using namespace llvm;

81namespace {

83class EmitterBase;
84class Result;

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.

98class Type {
99public:
enum class TypeKind {
  // Void appears as a return type (for store intrinsics, which are pure
  // side-effect). It's also used as the parameter type in the Tablegen
  // when an intrinsic doesn't need to come in various suffixed forms like
  // vfooq_s8,vfooq_u16,vfooq_f32.
  Void,

  // Scalar is used for ordinary int and float types of all sizes.
  Scalar,

  // Vector is used for anything that occupies exactly one MVE vector
  // register, i.e. {uint,int,float}NxM_t.
  Vector,

  // MultiVector is used for the {uint,int,float}NxMxK_t types used by the
  // interleaving load/store intrinsics v{ld,st}{2,4}q.
  MultiVector,

  // Predicate is used by all the predicated intrinsics. Its C
  // representation is mve_pred16_t (which is just an alias for uint16_t).
  // But we give more detail here, by indicating that a given predicate
  // instruction is logically regarded as a vector of i1 containing the
  // same number of lanes as the input vector type. So our Predicate type
  // comes with a lane count, which we use to decide which kind of <n x i1>
  // we'll invoke the pred_i2v IR intrinsic to translate it into.
  Predicate,

  // Pointer is used for pointer types (obviously), and comes with a flag
  // indicating whether it's a pointer to a const or mutable instance of
  // the pointee type.
  Pointer,
};

133private:
const TypeKind TKind;

136protected:
Type(TypeKind K) : TKind(K) {}

139public:
TypeKind typeKind() const { return TKind; }
virtual ~Type() = default;
virtual bool requiresFloat() const = 0;
virtual bool requiresMVE() const = 0;
virtual unsigned sizeInBits() const = 0;
virtual std::string cName() const = 0;
virtual std::string llvmName() const {
  PrintFatalError("no LLVM type name available for type " + cName());
}
virtual std::string acleSuffix(std::string) const {
  PrintFatalError("no ACLE suffix available for this type");
}
152};

154enum class ScalarTypeKind { SignedInt, UnsignedInt, Float };
155inline std::string toLetter(ScalarTypeKind kind) {
switch (kind) {
case ScalarTypeKind::SignedInt:
  return "s";
case ScalarTypeKind::UnsignedInt:
  return "u";
case ScalarTypeKind::Float:
  return "f";
}
llvm_unreachable("Unhandled ScalarTypeKind enum")::llvm::llvm_unreachable_internal("Unhandled ScalarTypeKind enum"
, "clang/utils/TableGen/MveEmitter.cpp", 164);
165}
166inline std::string toCPrefix(ScalarTypeKind kind) {
switch (kind) {
case ScalarTypeKind::SignedInt:
  return "int";
case ScalarTypeKind::UnsignedInt:
  return "uint";
case ScalarTypeKind::Float:
  return "float";
}
llvm_unreachable("Unhandled ScalarTypeKind enum")::llvm::llvm_unreachable_internal("Unhandled ScalarTypeKind enum"
, "clang/utils/TableGen/MveEmitter.cpp", 175);
176}

178class VoidType : public Type {
179public:
VoidType() : Type(TypeKind::Void) {}
unsigned sizeInBits() const override { return 0; }
25
←
Returning zero→
bool requiresFloat() const override { return false; }
bool requiresMVE() const override { return false; }
std::string cName() const override { return "void"; }

static bool classof(const Type *T) { return T->typeKind() == TypeKind::Void; }
std::string acleSuffix(std::string) const override { return ""; }
188};

190class PointerType : public Type {
const Type *Pointee;
bool Const;

194public:
PointerType(const Type *Pointee, bool Const)
    : Type(TypeKind::Pointer), Pointee(Pointee), Const(Const) {}
unsigned sizeInBits() const override { return 32; }
bool requiresFloat() const override { return Pointee->requiresFloat(); }
bool requiresMVE() const override { return Pointee->requiresMVE(); }
std::string cName() const override {
  std::string Name = Pointee->cName();

  // The syntax for a pointer in C is different when the pointee is
  // itself a pointer. The MVE intrinsics don't contain any double
  // pointers, so we don't need to worry about that wrinkle.
  assert(!isa<PointerType>(Pointee) && "Pointer to pointer not supported")(static_cast <bool> (!isa<PointerType>(Pointee) &&
 "Pointer to pointer not supported") ? void (0) : __assert_fail
 ("!isa<PointerType>(Pointee) && \"Pointer to pointer not supported\""
, "clang/utils/TableGen/MveEmitter.cpp", 206, __extension__ __PRETTY_FUNCTION__
));

  if (Const)
    Name = "const " + Name;
  return Name + " *";
}
std::string llvmName() const override {
  return "llvm::PointerType::getUnqual(" + Pointee->llvmName() + ")";
}
const Type *getPointeeType() const { return Pointee; }

static bool classof(const Type *T) {
  return T->typeKind() == TypeKind::Pointer;
}
220};

222// Base class for all the types that have a name of the form
223// [prefix][numbers]_t, like int32_t, uint16x8_t, float32x4x2_t.
224//
225// For this sub-hierarchy we invent a cNameBase() method which returns the
226// whole name except for the trailing "_t", so that Vector and MultiVector can
227// append an extra "x2" or whatever to their element type's cNameBase(). Then
228// the main cName() query method puts "_t" on the end for the final type name.

230class CRegularNamedType : public Type {
using Type::Type;
virtual std::string cNameBase() const = 0;

234public:
std::string cName() const override { return cNameBase() + "_t"; }
236};

238class ScalarType : public CRegularNamedType {
ScalarTypeKind Kind;
unsigned Bits;
std::string NameOverride;

243public:
ScalarType(const Record *Record) : CRegularNamedType(TypeKind::Scalar) {
  Kind = StringSwitch<ScalarTypeKind>(Record->getValueAsString("kind"))
             .Case("s", ScalarTypeKind::SignedInt)
             .Case("u", ScalarTypeKind::UnsignedInt)
             .Case("f", ScalarTypeKind::Float);
  Bits = Record->getValueAsInt("size");
  NameOverride = std::string(Record->getValueAsString("nameOverride"));
}
unsigned sizeInBits() const override { return Bits; }
ScalarTypeKind kind() const { return Kind; }
std::string suffix() const { return toLetter(Kind) + utostr(Bits); }
std::string cNameBase() const override {
  return toCPrefix(Kind) + utostr(Bits);
}
std::string cName() const override {
  if (NameOverride.empty())
    return CRegularNamedType::cName();
  return NameOverride;
}
std::string llvmName() const override {
  if (Kind == ScalarTypeKind::Float) {
    if (Bits == 16)
      return "HalfTy";
    if (Bits == 32)
      return "FloatTy";
    if (Bits == 64)
      return "DoubleTy";
    PrintFatalError("bad size for floating type");
  }
  return "Int" + utostr(Bits) + "Ty";
}
std::string acleSuffix(std::string overrideLetter) const override {
  return "_" + (overrideLetter.size() ? overrideLetter : toLetter(Kind))
             + utostr(Bits);
}
bool isInteger() const { return Kind != ScalarTypeKind::Float; }
bool requiresFloat() const override { return !isInteger(); }
bool requiresMVE() const override { return false; }
bool hasNonstandardName() const { return !NameOverride.empty(); }

static bool classof(const Type *T) {
  return T->typeKind() == TypeKind::Scalar;
}
287};

289class VectorType : public CRegularNamedType {
const ScalarType *Element;
unsigned Lanes;

293public:
VectorType(const ScalarType *Element, unsigned Lanes)
    : CRegularNamedType(TypeKind::Vector), Element(Element), Lanes(Lanes) {}
unsigned sizeInBits() const override { return Lanes * Element->sizeInBits(); }
unsigned lanes() const { return Lanes; }
bool requiresFloat() const override { return Element->requiresFloat(); }
bool requiresMVE() const override { return true; }
std::string cNameBase() const override {
  return Element->cNameBase() + "x" + utostr(Lanes);
}
std::string llvmName() const override {
  return "llvm::FixedVectorType::get(" + Element->llvmName() + ", " +
         utostr(Lanes) + ")";
}

static bool classof(const Type *T) {
  return T->typeKind() == TypeKind::Vector;
}
311};

313class MultiVectorType : public CRegularNamedType {
const VectorType *Element;
unsigned Registers;

317public:
MultiVectorType(unsigned Registers, const VectorType *Element)
    : CRegularNamedType(TypeKind::MultiVector), Element(Element),
      Registers(Registers) {}
unsigned sizeInBits() const override {
  return Registers * Element->sizeInBits();
}
unsigned registers() const { return Registers; }
bool requiresFloat() const override { return Element->requiresFloat(); }
bool requiresMVE() const override { return true; }
std::string cNameBase() const override {
  return Element->cNameBase() + "x" + utostr(Registers);
}

// MultiVectorType doesn't override llvmName, because we don't expect to do
// automatic code generation for the MVE intrinsics that use it: the {vld2,
// vld4, vst2, vst4} family are the only ones that use these types, so it was
// easier to hand-write the codegen for dealing with these structs than to
// build in lots of extra automatic machinery that would only be used once.

static bool classof(const Type *T) {
  return T->typeKind() == TypeKind::MultiVector;
}
340};

342class PredicateType : public CRegularNamedType {
unsigned Lanes;

345public:
PredicateType(unsigned Lanes)
    : CRegularNamedType(TypeKind::Predicate), Lanes(Lanes) {}
unsigned sizeInBits() const override { return 16; }
std::string cNameBase() const override { return "mve_pred16"; }
bool requiresFloat() const override { return false; };
bool requiresMVE() const override { return true; }
std::string llvmName() const override {
  return "llvm::FixedVectorType::get(Builder.getInt1Ty(), " + utostr(Lanes) +
         ")";
}

static bool classof(const Type *T) {
  return T->typeKind() == TypeKind::Predicate;
}
360};

362// -----------------------------------------------------------------------------
363// Class to facilitate merging together the code generation for many intrinsics
364// by means of varying a few constant or type parameters.
365//
366// Most obviously, the intrinsics in a single parametrised family will have
367// code generation sequences that only differ in a type or two, e.g. vaddq_s8
368// and vaddq_u16 will look the same apart from putting a different vector type
369// in the call to CGM.getIntrinsic(). But also, completely different intrinsics
370// will often code-generate in the same way, with only a different choice of
371// _which_ IR intrinsic they lower to (e.g. vaddq_m_s8 and vmulq_m_s8), but
372// marshalling the arguments and return values of the IR intrinsic in exactly
373// the same way. And others might differ only in some other kind of constant,
374// such as a lane index.
375//
376// So, when we generate the IR-building code for all these intrinsics, we keep
377// track of every value that could possibly be pulled out of the code and
378// stored ahead of time in a local variable. Then we group together intrinsics
379// by textual equivalence of the code that would result if _all_ those
380// parameters were stored in local variables. That gives us maximal sets that
381// can be implemented by a single piece of IR-building code by changing
382// parameter values ahead of time.
383//
384// After we've done that, we do a second pass in which we only allocate _some_
385// of the parameters into local variables, by tracking which ones have the same
386// values as each other (so that a single variable can be reused) and which
387// ones are the same across the whole set (so that no variable is needed at
388// all).
389//
390// Hence the class below. Its allocParam method is invoked during code
391// generation by every method of a Result subclass (see below) that wants to
392// give it the opportunity to pull something out into a switchable parameter.
393// It returns a variable name for the parameter, or (if it's being used in the
394// second pass once we've decided that some parameters don't need to be stored
395// in variables after all) it might just return the input expression unchanged.

397struct CodeGenParamAllocator {
// Accumulated during code generation
std::vector<std::string> *ParamTypes = nullptr;
std::vector<std::string> *ParamValues = nullptr;

// Provided ahead of time in pass 2, to indicate which parameters are being
// assigned to what. This vector contains an entry for each call to
// allocParam expected during code gen (which we counted up in pass 1), and
// indicates the number of the parameter variable that should be returned, or
// -1 if this call shouldn't allocate a parameter variable at all.
//
// We rely on the recursive code generation working identically in passes 1
// and 2, so that the same list of calls to allocParam happen in the same
// order. That guarantees that the parameter numbers recorded in pass 1 will
// match the entries in this vector that store what EmitterBase::EmitBuiltinCG
// decided to do about each one in pass 2.
std::vector<int> *ParamNumberMap = nullptr;

// Internally track how many things we've allocated
unsigned nparams = 0;

std::string allocParam(StringRef Type, StringRef Value) {
  unsigned ParamNumber;

  if (!ParamNumberMap) {
    // In pass 1, unconditionally assign a new parameter variable to every
    // value we're asked to process.
    ParamNumber = nparams++;
  } else {
    // In pass 2, consult the map provided by the caller to find out which
    // variable we should be keeping things in.
    int MapValue = (*ParamNumberMap)[nparams++];
    if (MapValue < 0)
      return std::string(Value);
    ParamNumber = MapValue;
  }

  // If we've allocated a new parameter variable for the first time, store
  // its type and value to be retrieved after codegen.
  if (ParamTypes && ParamTypes->size() == ParamNumber)
    ParamTypes->push_back(std::string(Type));
  if (ParamValues && ParamValues->size() == ParamNumber)
    ParamValues->push_back(std::string(Value));

  // Unimaginative naming scheme for parameter variables.
  return "Param" + utostr(ParamNumber);
}
444};

446// -----------------------------------------------------------------------------
447// System of classes that represent all the intermediate values used during
448// code-generation for an intrinsic.
449//
450// The base class 'Result' can represent a value of the LLVM type 'Value', or
451// sometimes 'Address' (for loads/stores, including an alignment requirement).
452//
453// In the case where the Tablegen provides a value in the codegen dag as a
454// plain integer literal, the Result object we construct here will be one that
455// returns true from hasIntegerConstantValue(). This allows the generated C++
456// code to use the constant directly in contexts which can take a literal
457// integer, such as Builder.CreateExtractValue(thing, 1), without going to the
458// effort of calling llvm::ConstantInt::get() and then pulling the constant
459// back out of the resulting llvm:Value later.

461class Result {
462public:
// Convenient shorthand for the pointer type we'll be using everywhere.
using Ptr = std::shared_ptr<Result>;

466private:
Ptr Predecessor;
std::string VarName;
bool VarNameUsed = false;
unsigned Visited = 0;

472public:
virtual ~Result() = default;
using Scope = std::map<std::string, Ptr>;
virtual void genCode(raw_ostream &OS, CodeGenParamAllocator &) const = 0;
virtual bool hasIntegerConstantValue() const { return false; }
virtual uint32_t integerConstantValue() const { return 0; }
virtual bool hasIntegerValue() const { return false; }
virtual std::string getIntegerValue(const std::string &) {
  llvm_unreachable("non-working Result::getIntegerValue called")::llvm::llvm_unreachable_internal("non-working Result::getIntegerValue called"
, "clang/utils/TableGen/MveEmitter.cpp", 480);
}
virtual std::string typeName() const { return "Value *"; }

// Mostly, when a code-generation operation has a dependency on prior
// operations, it's because it uses the output values of those operations as
// inputs. But there's one exception, which is the use of 'seq' in Tablegen
// to indicate that operations have to be performed in sequence regardless of
// whether they use each others' output values.
//
// So, the actual generation of code is done by depth-first search, using the
// prerequisites() method to get a list of all the other Results that have to
// be computed before this one. That method divides into the 'predecessor',
// set by setPredecessor() while processing a 'seq' dag node, and the list
// returned by 'morePrerequisites', which each subclass implements to return
// a list of the Results it uses as input to whatever its own computation is
// doing.

virtual void morePrerequisites(std::vector<Ptr> &output) const {}
std::vector<Ptr> prerequisites() const {
  std::vector<Ptr> ToRet;
  if (Predecessor)
    ToRet.push_back(Predecessor);
  morePrerequisites(ToRet);
  return ToRet;
}

void setPredecessor(Ptr p) {
  // If the user has nested one 'seq' node inside another, and this
  // method is called on the return value of the inner 'seq' (i.e.
  // the final item inside it), then we can't link _this_ node to p,
  // because it already has a predecessor. Instead, walk the chain
  // until we find the first item in the inner seq, and link that to
  // p, so that nesting seqs has the obvious effect of linking
  // everything together into one long sequential chain.
  Result *r = this;
  while (r->Predecessor)
    r = r->Predecessor.get();
  r->Predecessor = p;
}

// Each Result will be assigned a variable name in the output code, but not
// all those variable names will actually be used (e.g. the return value of
// Builder.CreateStore has void type, so nobody will want to refer to it). To
// prevent annoying compiler warnings, we track whether each Result's
// variable name was ever actually mentioned in subsequent statements, so
// that it can be left out of the final generated code.
std::string varname() {
  VarNameUsed = true;
  return VarName;
}
void setVarname(const StringRef s) { VarName = std::string(s); }
bool varnameUsed() const { return VarNameUsed; }

// Emit code to generate this result as a Value *.
virtual std::string asValue() {
  return varname();
}

// Code generation happens in multiple passes. This method tracks whether a
// Result has yet been visited in a given pass, without the need for a
// tedious loop in between passes that goes through and resets a 'visited'
// flag back to false: you just set Pass=1 the first time round, and Pass=2
// the second time.
bool needsVisiting(unsigned Pass) {
  bool ToRet = Visited < Pass;
  Visited = Pass;
  return ToRet;
}
549};

551// Result subclass that retrieves one of the arguments to the clang builtin
552// function. In cases where the argument has pointer type, we call
553// EmitPointerWithAlignment and store the result in a variable of type Address,
554// so that load and store IR nodes can know the right alignment. Otherwise, we
555// call EmitScalarExpr.
556//
557// There are aggregate parameters in the MVE intrinsics API, but we don't deal
558// with them in this Tablegen back end: they only arise in the vld2q/vld4q and
559// vst2q/vst4q family, which is few enough that we just write the code by hand
560// for those in CGBuiltin.cpp.
561class BuiltinArgResult : public Result {
562public:
unsigned ArgNum;
bool AddressType;
bool Immediate;
BuiltinArgResult(unsigned ArgNum, bool AddressType, bool Immediate)
    : ArgNum(ArgNum), AddressType(AddressType), Immediate(Immediate) {}
void genCode(raw_ostream &OS, CodeGenParamAllocator &) const override {
  OS << (AddressType ? "EmitPointerWithAlignment" : "EmitScalarExpr")
     << "(E->getArg(" << ArgNum << "))";
}
std::string typeName() const override {
  return AddressType ? "Address" : Result::typeName();
}
// Emit code to generate this result as a Value *.
std::string asValue() override {
  if (AddressType)
    return "(" + varname() + ".getPointer())";
  return Result::asValue();
}
bool hasIntegerValue() const override { return Immediate; }
std::string getIntegerValue(const std::string &IntType) override {
  return "GetIntegerConstantValue<" + IntType + ">(E->getArg(" +
         utostr(ArgNum) + "), getContext())";
}
586};

588// Result subclass for an integer literal appearing in Tablegen. This may need
589// to be turned into an llvm::Result by means of llvm::ConstantInt::get(), or
590// it may be used directly as an integer, depending on which IRBuilder method
591// it's being passed to.
592class IntLiteralResult : public Result {
593public:
const ScalarType *IntegerType;
uint32_t IntegerValue;
IntLiteralResult(const ScalarType *IntegerType, uint32_t IntegerValue)
    : IntegerType(IntegerType), IntegerValue(IntegerValue) {}
void genCode(raw_ostream &OS,
             CodeGenParamAllocator &ParamAlloc) const override {
  OS << "llvm::ConstantInt::get("
     << ParamAlloc.allocParam("llvm::Type *", IntegerType->llvmName())
     << ", ";
  OS << ParamAlloc.allocParam(IntegerType->cName(), utostr(IntegerValue))
     << ")";
}
bool hasIntegerConstantValue() const override { return true; }
uint32_t integerConstantValue() const override { return IntegerValue; }
608};

610// Result subclass representing a cast between different integer types. We use
611// our own ScalarType abstraction as the representation of the target type,
612// which gives both size and signedness.
613class IntCastResult : public Result {
614public:
const ScalarType *IntegerType;
Ptr V;
IntCastResult(const ScalarType *IntegerType, Ptr V)
    : IntegerType(IntegerType), V(V) {}
void genCode(raw_ostream &OS,
             CodeGenParamAllocator &ParamAlloc) const override {
  OS << "Builder.CreateIntCast(" << V->varname() << ", "
     << ParamAlloc.allocParam("llvm::Type *", IntegerType->llvmName()) << ", "
     << ParamAlloc.allocParam("bool",
                              IntegerType->kind() == ScalarTypeKind::SignedInt
                                  ? "true"
                                  : "false")
     << ")";
}
void morePrerequisites(std::vector<Ptr> &output) const override {
  output.push_back(V);
}
632};

634// Result subclass representing a cast between different pointer types.
635class PointerCastResult : public Result {
636public:
const PointerType *PtrType;
Ptr V;
PointerCastResult(const PointerType *PtrType, Ptr V)
    : PtrType(PtrType), V(V) {}
void genCode(raw_ostream &OS,
             CodeGenParamAllocator &ParamAlloc) const override {
  OS << "Builder.CreatePointerCast(" << V->asValue() << ", "
     << ParamAlloc.allocParam("llvm::Type *", PtrType->llvmName()) << ")";
}
void morePrerequisites(std::vector<Ptr> &output) const override {
  output.push_back(V);
}
649};

651// Result subclass representing a call to an IRBuilder method. Each IRBuilder
652// method we want to use will have a Tablegen record giving the method name and
653// describing any important details of how to call it, such as whether a
654// particular argument should be an integer constant instead of an llvm::Value.
655class IRBuilderResult : public Result {
656public:
StringRef CallPrefix;
std::vector<Ptr> Args;
std::set<unsigned> AddressArgs;
std::map<unsigned, std::string> IntegerArgs;
IRBuilderResult(StringRef CallPrefix, std::vector<Ptr> Args,
                std::set<unsigned> AddressArgs,
                std::map<unsigned, std::string> IntegerArgs)
    : CallPrefix(CallPrefix), Args(Args), AddressArgs(AddressArgs),
      IntegerArgs(IntegerArgs) {}
void genCode(raw_ostream &OS,
             CodeGenParamAllocator &ParamAlloc) const override {
  OS << CallPrefix;
  const char *Sep = "";
  for (unsigned i = 0, e = Args.size(); i < e; ++i) {
    Ptr Arg = Args[i];
    auto it = IntegerArgs.find(i);

    OS << Sep;
    Sep = ", ";

    if (it != IntegerArgs.end()) {
      if (Arg->hasIntegerConstantValue())
        OS << "static_cast<" << it->second << ">("
           << ParamAlloc.allocParam(it->second,
                                    utostr(Arg->integerConstantValue()))
           << ")";
      else if (Arg->hasIntegerValue())
        OS << ParamAlloc.allocParam(it->second,
                                    Arg->getIntegerValue(it->second));
    } else {
      OS << Arg->varname();
    }
  }
  OS << ")";
}
void morePrerequisites(std::vector<Ptr> &output) const override {
  for (unsigned i = 0, e = Args.size(); i < e; ++i) {
    Ptr Arg = Args[i];
    if (IntegerArgs.find(i) != IntegerArgs.end())
      continue;
    output.push_back(Arg);
  }
}
700};

702// Result subclass representing making an Address out of a Value.
703class AddressResult : public Result {
704public:
Ptr Arg;
const Type *Ty;
unsigned Align;
AddressResult(Ptr Arg, const Type *Ty, unsigned Align)
    : Arg(Arg), Ty(Ty), Align(Align) {}
void genCode(raw_ostream &OS,
             CodeGenParamAllocator &ParamAlloc) const override {
  OS << "Address(" << Arg->varname() << ", " << Ty->llvmName()
     << ", CharUnits::fromQuantity(" << Align << "))";
}
std::string typeName() const override {
  return "Address";
}
void morePrerequisites(std::vector<Ptr> &output) const override {
  output.push_back(Arg);
}
721};

723// Result subclass representing a call to an IR intrinsic, which we first have
724// to look up using an Intrinsic::ID constant and an array of types.
725class IRIntrinsicResult : public Result {
726public:
std::string IntrinsicID;
std::vector<const Type *> ParamTypes;
std::vector<Ptr> Args;
IRIntrinsicResult(StringRef IntrinsicID, std::vector<const Type *> ParamTypes,
                  std::vector<Ptr> Args)
    : IntrinsicID(std::string(IntrinsicID)), ParamTypes(ParamTypes),
      Args(Args) {}
void genCode(raw_ostream &OS,
             CodeGenParamAllocator &ParamAlloc) const override {
  std::string IntNo = ParamAlloc.allocParam(
      "Intrinsic::ID", "Intrinsic::" + IntrinsicID);
  OS << "Builder.CreateCall(CGM.getIntrinsic(" << IntNo;
  if (!ParamTypes.empty()) {
    OS << ", {";
    const char *Sep = "";
    for (auto T : ParamTypes) {
      OS << Sep << ParamAlloc.allocParam("llvm::Type *", T->llvmName());
      Sep = ", ";
    }
    OS << "}";
  }
  OS << "), {";
  const char *Sep = "";
  for (auto Arg : Args) {
    OS << Sep << Arg->asValue();
    Sep = ", ";
  }
  OS << "})";
}
void morePrerequisites(std::vector<Ptr> &output) const override {
  output.insert(output.end(), Args.begin(), Args.end());
}
759};

761// Result subclass that specifies a type, for use in IRBuilder operations such
762// as CreateBitCast that take a type argument.
763class TypeResult : public Result {
764public:
const Type *T;
TypeResult(const Type *T) : T(T) {}
void genCode(raw_ostream &OS, CodeGenParamAllocator &) const override {
  OS << T->llvmName();
}
std::string typeName() const override {
  return "llvm::Type *";
}
773};

775// -----------------------------------------------------------------------------
776// Class that describes a single ACLE intrinsic.
777//
778// A Tablegen record will typically describe more than one ACLE intrinsic, by
779// means of setting the 'list<Type> Params' field to a list of multiple
780// parameter types, so as to define vaddq_{s8,u8,...,f16,f32} all in one go.
781// We'll end up with one instance of ACLEIntrinsic for *each* parameter type,
782// rather than a single one for all of them. Hence, the constructor takes both
783// a Tablegen record and the current value of the parameter type.

785class ACLEIntrinsic {
// Structure documenting that one of the intrinsic's arguments is required to
// be a compile-time constant integer, and what constraints there are on its
// value. Used when generating Sema checking code.
struct ImmediateArg {
  enum class BoundsType { ExplicitRange, UInt };
  BoundsType boundsType;
  int64_t i1, i2;
  StringRef ExtraCheckType, ExtraCheckArgs;
  const Type *ArgType;
};

// For polymorphic intrinsics, FullName is the explicit name that uniquely
// identifies this variant of the intrinsic, and ShortName is the name it
// shares with at least one other intrinsic.
std::string ShortName, FullName;

// Name of the architecture extension, used in the Clang builtin name
StringRef BuiltinExtension;

// A very small number of intrinsics _only_ have a polymorphic
// variant (vuninitializedq taking an unevaluated argument).
bool PolymorphicOnly;

// Another rarely-used flag indicating that the builtin doesn't
// evaluate its argument(s) at all.
bool NonEvaluating;

// True if the intrinsic needs only the C header part (no codegen, semantic
// checks, etc). Used for redeclaring MVE intrinsics in the arm_cde.h header.
bool HeaderOnly;

const Type *ReturnType;
std::vector<const Type *> ArgTypes;
std::map<unsigned, ImmediateArg> ImmediateArgs;
Result::Ptr Code;

std::map<std::string, std::string> CustomCodeGenArgs;

// Recursive function that does the internals of code generation.
void genCodeDfs(Result::Ptr V, std::list<Result::Ptr> &Used,
                unsigned Pass) const {
  if (!V->needsVisiting(Pass))
    return;

  for (Result::Ptr W : V->prerequisites())
    genCodeDfs(W, Used, Pass);

  Used.push_back(V);
}

836public:
const std::string &shortName() const { return ShortName; }
const std::string &fullName() const { return FullName; }
StringRef builtinExtension() const { return BuiltinExtension; }
const Type *returnType() const { return ReturnType; }
const std::vector<const Type *> &argTypes() const { return ArgTypes; }
bool requiresFloat() const {
  if (ReturnType->requiresFloat())
    return true;
  for (const Type *T : ArgTypes)
    if (T->requiresFloat())
      return true;
  return false;
}
bool requiresMVE() const {
  return ReturnType->requiresMVE() ||
         any_of(ArgTypes, [](const Type *T) { return T->requiresMVE(); });
}
bool polymorphic() const { return ShortName != FullName; }
bool polymorphicOnly() const { return PolymorphicOnly; }
bool nonEvaluating() const { return NonEvaluating; }
bool headerOnly() const { return HeaderOnly; }

// External entry point for code generation, called from EmitterBase.
void genCode(raw_ostream &OS, CodeGenParamAllocator &ParamAlloc,
             unsigned Pass) const {
  assert(!headerOnly() && "Called genCode for header-only intrinsic")(static_cast <bool> (!headerOnly() && "Called genCode for header-only intrinsic"
) ? void (0) : __assert_fail ("!headerOnly() && \"Called genCode for header-only intrinsic\""
, "clang/utils/TableGen/MveEmitter.cpp", 862, __extension__ __PRETTY_FUNCTION__
));
  if (!hasCode()) {
    for (auto kv : CustomCodeGenArgs)
      OS << "  " << kv.first << " = " << kv.second << ";\n";
    OS << "  break; // custom code gen\n";
    return;
  }
  std::list<Result::Ptr> Used;
  genCodeDfs(Code, Used, Pass);

  unsigned varindex = 0;
  for (Result::Ptr V : Used)
    if (V->varnameUsed())
      V->setVarname("Val" + utostr(varindex++));

  for (Result::Ptr V : Used) {
    OS << "  ";
    if (V == Used.back()) {
      assert(!V->varnameUsed())(static_cast <bool> (!V->varnameUsed()) ? void (0) :
 __assert_fail ("!V->varnameUsed()", "clang/utils/TableGen/MveEmitter.cpp"
, 880, __extension__ __PRETTY_FUNCTION__));
      OS << "return "; // FIXME: what if the top-level thing is void?
    } else if (V->varnameUsed()) {
      std::string Type = V->typeName();
      OS << V->typeName();
      if (!StringRef(Type).endswith("*"))
        OS << " ";
      OS << V->varname() << " = ";
    }
    V->genCode(OS, ParamAlloc);
    OS << ";\n";
  }
}
bool hasCode() const { return Code != nullptr; }

static std::string signedHexLiteral(const llvm::APInt &iOrig) {
  llvm::APInt i = iOrig.trunc(64);
  SmallString<40> s;
  i.toString(s, 16, true, true);
  return std::string(s.str());
}

std::string genSema() const {
  assert(!headerOnly() && "Called genSema for header-only intrinsic")(static_cast <bool> (!headerOnly() && "Called genSema for header-only intrinsic"
) ? void (0) : __assert_fail ("!headerOnly() && \"Called genSema for header-only intrinsic\""
, "clang/utils/TableGen/MveEmitter.cpp", 903, __extension__ __PRETTY_FUNCTION__
));
  std::vector<std::string> SemaChecks;

  for (const auto &kv : ImmediateArgs) {
    const ImmediateArg &IA = kv.second;

    llvm::APInt lo(128, 0), hi(128, 0);
    switch (IA.boundsType) {
    case ImmediateArg::BoundsType::ExplicitRange:
      lo = IA.i1;
      hi = IA.i2;
      break;
    case ImmediateArg::BoundsType::UInt:
      lo = 0;
      hi = llvm::APInt::getMaxValue(IA.i1).zext(128);
      break;
    }

    std::string Index = utostr(kv.first);

    // Emit a range check if the legal range of values for the
    // immediate is smaller than the _possible_ range of values for
    // its type.
    unsigned ArgTypeBits = IA.ArgType->sizeInBits();
    llvm::APInt ArgTypeRange = llvm::APInt::getMaxValue(ArgTypeBits).zext(128);
    llvm::APInt ActualRange = (hi-lo).trunc(64).sext(128);
    if (ActualRange.ult(ArgTypeRange))
      SemaChecks.push_back("SemaBuiltinConstantArgRange(TheCall, " + Index +
                           ", " + signedHexLiteral(lo) + ", " +
                           signedHexLiteral(hi) + ")");

    if (!IA.ExtraCheckType.empty()) {
      std::string Suffix;
      if (!IA.ExtraCheckArgs.empty()) {
        std::string tmp;
        StringRef Arg = IA.ExtraCheckArgs;
        if (Arg == "!lanesize") {
          tmp = utostr(IA.ArgType->sizeInBits());
          Arg = tmp;
        }
        Suffix = (Twine(", ") + Arg).str();
      }
      SemaChecks.push_back((Twine("SemaBuiltinConstantArg") +
                            IA.ExtraCheckType + "(TheCall, " + Index +
                            Suffix + ")")
                               .str());
    }

    assert(!SemaChecks.empty())(static_cast <bool> (!SemaChecks.empty()) ? void (0) : __assert_fail
 ("!SemaChecks.empty()", "clang/utils/TableGen/MveEmitter.cpp"
, 951, __extension__ __PRETTY_FUNCTION__));
  }
  if (SemaChecks.empty())
    return "";
  return join(std::begin(SemaChecks), std::end(SemaChecks),
              " ||\n         ") +
         ";\n";
}

ACLEIntrinsic(EmitterBase &ME, Record *R, const Type *Param);
961};

963// -----------------------------------------------------------------------------
964// The top-level class that holds all the state from analyzing the entire
965// Tablegen input.

967class EmitterBase {
968protected:
// EmitterBase holds a collection of all the types we've instantiated.
VoidType Void;
std::map<std::string, std::unique_ptr<ScalarType>> ScalarTypes;
std::map<std::tuple<ScalarTypeKind, unsigned, unsigned>,
         std::unique_ptr<VectorType>>
    VectorTypes;
std::map<std::pair<std::string, unsigned>, std::unique_ptr<MultiVectorType>>
    MultiVectorTypes;
std::map<unsigned, std::unique_ptr<PredicateType>> PredicateTypes;
std::map<std::string, std::unique_ptr<PointerType>> PointerTypes;

// And all the ACLEIntrinsic instances we've created.
std::map<std::string, std::unique_ptr<ACLEIntrinsic>> ACLEIntrinsics;

983public:
// Methods to create a Type object, or return the right existing one from the
// maps stored in this object.
const VoidType *getVoidType() { return &Void; }
const ScalarType *getScalarType(StringRef Name) {
  return ScalarTypes[std::string(Name)].get();
}
const ScalarType *getScalarType(Record *R) {
  return getScalarType(R->getName());
}
const VectorType *getVectorType(const ScalarType *ST, unsigned Lanes) {
  std::tuple<ScalarTypeKind, unsigned, unsigned> key(ST->kind(),
                                                     ST->sizeInBits(), Lanes);
  if (VectorTypes.find(key) == VectorTypes.end())
    VectorTypes[key] = std::make_unique<VectorType>(ST, Lanes);
  return VectorTypes[key].get();
}
const VectorType *getVectorType(const ScalarType *ST) {
  return getVectorType(ST, 128 / ST->sizeInBits());
}
const MultiVectorType *getMultiVectorType(unsigned Registers,
                                          const VectorType *VT) {
  std::pair<std::string, unsigned> key(VT->cNameBase(), Registers);
  if (MultiVectorTypes.find(key) == MultiVectorTypes.end())
    MultiVectorTypes[key] = std::make_unique<MultiVectorType>(Registers, VT);
  return MultiVectorTypes[key].get();
}
const PredicateType *getPredicateType(unsigned Lanes) {
  unsigned key = Lanes;
  if (PredicateTypes.find(key) == PredicateTypes.end())
    PredicateTypes[key] = std::make_unique<PredicateType>(Lanes);
  return PredicateTypes[key].get();
}
const PointerType *getPointerType(const Type *T, bool Const) {
  PointerType PT(T, Const);
  std::string key = PT.cName();
  if (PointerTypes.find(key) == PointerTypes.end())
    PointerTypes[key] = std::make_unique<PointerType>(PT);
  return PointerTypes[key].get();
}

// Methods to construct a type from various pieces of Tablegen. These are
// always called in the context of setting up a particular ACLEIntrinsic, so
// there's always an ambient parameter type (because we're iterating through
// the Params list in the Tablegen record for the intrinsic), which is used
// to expand Tablegen classes like 'Vector' which mean something different in
// each member of a parametric family.
const Type *getType(Record *R, const Type *Param);
const Type *getType(DagInit *D, const Type *Param);
const Type *getType(Init *I, const Type *Param);

// Functions that translate the Tablegen representation of an intrinsic's
// code generation into a collection of Value objects (which will then be
// reprocessed to read out the actual C++ code included by CGBuiltin.cpp).
Result::Ptr getCodeForDag(DagInit *D, const Result::Scope &Scope,
                          const Type *Param);
Result::Ptr getCodeForDagArg(DagInit *D, unsigned ArgNum,
                             const Result::Scope &Scope, const Type *Param);
Result::Ptr getCodeForArg(unsigned ArgNum, const Type *ArgType, bool Promote,
                          bool Immediate);

void GroupSemaChecks(std::map<std::string, std::set<std::string>> &Checks);

// Constructor and top-level functions.

EmitterBase(RecordKeeper &Records);
virtual ~EmitterBase() = default;

virtual void EmitHeader(raw_ostream &OS) = 0;
virtual void EmitBuiltinDef(raw_ostream &OS) = 0;
virtual void EmitBuiltinSema(raw_ostream &OS) = 0;
void EmitBuiltinCG(raw_ostream &OS);
void EmitBuiltinAliases(raw_ostream &OS);
1056};

1058const Type *EmitterBase::getType(Init *I, const Type *Param) {
if (auto Dag = dyn_cast<DagInit>(I))
  return getType(Dag, Param);
if (auto Def = dyn_cast<DefInit>(I))
  return getType(Def->getDef(), Param);

PrintFatalError("Could not convert this value into a type");
1065}

1067const Type *EmitterBase::getType(Record *R, const Type *Param) {
// Pass to a subfield of any wrapper records. We don't expect more than one
// of these: immediate operands are used as plain numbers rather than as
// llvm::Value, so it's meaningless to promote their type anyway.
if (R->isSubClassOf("Immediate"))
  R = R->getValueAsDef("type");
else if (R->isSubClassOf("unpromoted"))
  R = R->getValueAsDef("underlying_type");

if (R->getName() == "Void")
  return getVoidType();
if (R->isSubClassOf("PrimitiveType"))
  return getScalarType(R);
if (R->isSubClassOf("ComplexType"))
  return getType(R->getValueAsDag("spec"), Param);

PrintFatalError(R->getLoc(), "Could not convert this record into a type");
1084}

1086const Type *EmitterBase::getType(DagInit *D, const Type *Param) {
// The meat of the getType system: types in the Tablegen are represented by a
// dag whose operators select sub-cases of this function.

Record *Op = cast<DefInit>(D->getOperator())->getDef();
if (!Op->isSubClassOf("ComplexTypeOp"))
  PrintFatalError(
      "Expected ComplexTypeOp as dag operator in type expression");

if (Op->getName() == "CTO_Parameter") {
  if (isa<VoidType>(Param))
    PrintFatalError("Parametric type in unparametrised context");
  return Param;
}

if (Op->getName() == "CTO_Vec") {
  const Type *Element = getType(D->getArg(0), Param);
  if (D->getNumArgs() == 1) {
    return getVectorType(cast<ScalarType>(Element));
  } else {
    const Type *ExistingVector = getType(D->getArg(1), Param);
    return getVectorType(cast<ScalarType>(Element),
                         cast<VectorType>(ExistingVector)->lanes());
  }
}

if (Op->getName() == "CTO_Pred") {
  const Type *Element = getType(D->getArg(0), Param);
  return getPredicateType(128 / Element->sizeInBits());
}

if (Op->isSubClassOf("CTO_Tuple")) {
  unsigned Registers = Op->getValueAsInt("n");
  const Type *Element = getType(D->getArg(0), Param);
  return getMultiVectorType(Registers, cast<VectorType>(Element));
}

if (Op->isSubClassOf("CTO_Pointer")) {
  const Type *Pointee = getType(D->getArg(0), Param);
  return getPointerType(Pointee, Op->getValueAsBit("const"));
}

if (Op->getName() == "CTO_CopyKind") {
  const ScalarType *STSize = cast<ScalarType>(getType(D->getArg(0), Param));
  const ScalarType *STKind = cast<ScalarType>(getType(D->getArg(1), Param));
  for (const auto &kv : ScalarTypes) {
    const ScalarType *RT = kv.second.get();
    if (RT->kind() == STKind->kind() && RT->sizeInBits() == STSize->sizeInBits())
      return RT;
  }
  PrintFatalError("Cannot find a type to satisfy CopyKind");
}

if (Op->isSubClassOf("CTO_ScaleSize")) {
  const ScalarType *STKind = cast<ScalarType>(getType(D->getArg(0), Param));
  int Num = Op->getValueAsInt("num"), Denom = Op->getValueAsInt("denom");
  unsigned DesiredSize = STKind->sizeInBits() * Num / Denom;
  for (const auto &kv : ScalarTypes) {
    const ScalarType *RT = kv.second.get();
    if (RT->kind() == STKind->kind() && RT->sizeInBits() == DesiredSize)
      return RT;
  }
  PrintFatalError("Cannot find a type to satisfy ScaleSize");
}

PrintFatalError("Bad operator in type dag expression");
1152}

1154Result::Ptr EmitterBase::getCodeForDag(DagInit *D, const Result::Scope &Scope,
                                     const Type *Param) {
Record *Op = cast<DefInit>(D->getOperator())->getDef();

if (Op->getName() == "seq") {
  Result::Scope SubScope = Scope;
  Result::Ptr PrevV = nullptr;
  for (unsigned i = 0, e = D->getNumArgs(); i < e; ++i) {
    // We don't use getCodeForDagArg here, because the argument name
    // has different semantics in a seq
    Result::Ptr V =
        getCodeForDag(cast<DagInit>(D->getArg(i)), SubScope, Param);
    StringRef ArgName = D->getArgNameStr(i);
    if (!ArgName.empty())
      SubScope[std::string(ArgName)] = V;
    if (PrevV)
      V->setPredecessor(PrevV);
    PrevV = V;
  }
  return PrevV;
} else if (Op->isSubClassOf("Type")) {
  if (D->getNumArgs() != 1)
    PrintFatalError("Type casts should have exactly one argument");
  const Type *CastType = getType(Op, Param);
  Result::Ptr Arg = getCodeForDagArg(D, 0, Scope, Param);
  if (const auto *ST = dyn_cast<ScalarType>(CastType)) {
    if (!ST->requiresFloat()) {
      if (Arg->hasIntegerConstantValue())
        return std::make_shared<IntLiteralResult>(
            ST, Arg->integerConstantValue());
      else
        return std::make_shared<IntCastResult>(ST, Arg);
    }
  } else if (const auto *PT = dyn_cast<PointerType>(CastType)) {
    return std::make_shared<PointerCastResult>(PT, Arg);
  }
  PrintFatalError("Unsupported type cast");
} else if (Op->getName() == "address") {
  if (D->getNumArgs() != 2)
    PrintFatalError("'address' should have two arguments");
  Result::Ptr Arg = getCodeForDagArg(D, 0, Scope, Param);

  const Type *Ty = nullptr;
  if (auto *DI = dyn_cast<DagInit>(D->getArg(0)))
    if (auto *PTy = dyn_cast<PointerType>(getType(DI->getOperator(), Param)))
      Ty = PTy->getPointeeType();
  if (!Ty)
    PrintFatalError("'address' pointer argument should be a pointer");

  unsigned Alignment;
  if (auto *II = dyn_cast<IntInit>(D->getArg(1))) {
    Alignment = II->getValue();
  } else {
    PrintFatalError("'address' alignment argument should be an integer");
  }
  return std::make_shared<AddressResult>(Arg, Ty, Alignment);
} else if (Op->getName() == "unsignedflag") {
  if (D->getNumArgs() != 1)
    PrintFatalError("unsignedflag should have exactly one argument");
  Record *TypeRec = cast<DefInit>(D->getArg(0))->getDef();
  if (!TypeRec->isSubClassOf("Type"))
    PrintFatalError("unsignedflag's argument should be a type");
  if (const auto *ST = dyn_cast<ScalarType>(getType(TypeRec, Param))) {
    return std::make_shared<IntLiteralResult>(
      getScalarType("u32"), ST->kind() == ScalarTypeKind::UnsignedInt);
  } else {
    PrintFatalError("unsignedflag's argument should be a scalar type");
  }
} else if (Op->getName() == "bitsize") {
  if (D->getNumArgs() != 1)
    PrintFatalError("bitsize should have exactly one argument");
  Record *TypeRec = cast<DefInit>(D->getArg(0))->getDef();
  if (!TypeRec->isSubClassOf("Type"))
    PrintFatalError("bitsize's argument should be a type");
  if (const auto *ST = dyn_cast<ScalarType>(getType(TypeRec, Param))) {
    return std::make_shared<IntLiteralResult>(getScalarType("u32"),
                                              ST->sizeInBits());
  } else {
    PrintFatalError("bitsize's argument should be a scalar type");
  }
} else {
  std::vector<Result::Ptr> Args;
  for (unsigned i = 0, e = D->getNumArgs(); i < e; ++i)
    Args.push_back(getCodeForDagArg(D, i, Scope, Param));
  if (Op->isSubClassOf("IRBuilderBase")) {
    std::set<unsigned> AddressArgs;
    std::map<unsigned, std::string> IntegerArgs;
    for (Record *sp : Op->getValueAsListOfDefs("special_params")) {
      unsigned Index = sp->getValueAsInt("index");
      if (sp->isSubClassOf("IRBuilderAddrParam")) {
        AddressArgs.insert(Index);
      } else if (sp->isSubClassOf("IRBuilderIntParam")) {
        IntegerArgs[Index] = std::string(sp->getValueAsString("type"));
      }
    }
    return std::make_shared<IRBuilderResult>(Op->getValueAsString("prefix"),
                                             Args, AddressArgs, IntegerArgs);
  } else if (Op->isSubClassOf("IRIntBase")) {
    std::vector<const Type *> ParamTypes;
    for (Record *RParam : Op->getValueAsListOfDefs("params"))
      ParamTypes.push_back(getType(RParam, Param));
    std::string IntName = std::string(Op->getValueAsString("intname"));
    if (Op->getValueAsBit("appendKind"))
      IntName += "_" + toLetter(cast<ScalarType>(Param)->kind());
    return std::make_shared<IRIntrinsicResult>(IntName, ParamTypes, Args);
  } else {
    PrintFatalError("Unsupported dag node " + Op->getName());
  }
}
1263}

1265Result::Ptr EmitterBase::getCodeForDagArg(DagInit *D, unsigned ArgNum,
                                        const Result::Scope &Scope,
                                        const Type *Param) {
Init *Arg = D->getArg(ArgNum);
StringRef Name = D->getArgNameStr(ArgNum);

if (!Name.empty()) {
  if (!isa<UnsetInit>(Arg))
    PrintFatalError(
        "dag operator argument should not have both a value and a name");
  auto it = Scope.find(std::string(Name));
  if (it == Scope.end())
    PrintFatalError("unrecognized variable name '" + Name + "'");
  return it->second;
}

// Sometimes the Arg is a bit. Prior to multiclass template argument
// checking, integers would sneak through the bit declaration,
// but now they really are bits.
if (auto *BI = dyn_cast<BitInit>(Arg))
  return std::make_shared<IntLiteralResult>(getScalarType("u32"),
                                            BI->getValue());

if (auto *II = dyn_cast<IntInit>(Arg))
  return std::make_shared<IntLiteralResult>(getScalarType("u32"),
                                            II->getValue());

if (auto *DI = dyn_cast<DagInit>(Arg))
  return getCodeForDag(DI, Scope, Param);

if (auto *DI = dyn_cast<DefInit>(Arg)) {
  Record *Rec = DI->getDef();
  if (Rec->isSubClassOf("Type")) {
    const Type *T = getType(Rec, Param);
    return std::make_shared<TypeResult>(T);
  }
}

PrintError("bad DAG argument type for code generation");
PrintNote("DAG: " + D->getAsString());
if (TypedInit *Typed = dyn_cast<TypedInit>(Arg))
  PrintNote("argument type: " + Typed->getType()->getAsString());
PrintFatalNote("argument number " + Twine(ArgNum) + ": " + Arg->getAsString());
1308}

1310Result::Ptr EmitterBase::getCodeForArg(unsigned ArgNum, const Type *ArgType,
                                     bool Promote, bool Immediate) {
Result::Ptr V = std::make_shared<BuiltinArgResult>(
    ArgNum, isa<PointerType>(ArgType), Immediate);

if (Promote) {
  if (const auto *ST = dyn_cast<ScalarType>(ArgType)) {
    if (ST->isInteger() && ST->sizeInBits() < 32)
      V = std::make_shared<IntCastResult>(getScalarType("u32"), V);
  } else if (const auto *PT = dyn_cast<PredicateType>(ArgType)) {
    V = std::make_shared<IntCastResult>(getScalarType("u32"), V);
    V = std::make_shared<IRIntrinsicResult>("arm_mve_pred_i2v",
                                            std::vector<const Type *>{PT},
                                            std::vector<Result::Ptr>{V});
  }
}

return V;
1328}

1330ACLEIntrinsic::ACLEIntrinsic(EmitterBase &ME, Record *R, const Type *Param)
  : ReturnType(ME.getType(R->getValueAsDef("ret"), Param)) {
// Derive the intrinsic's full name, by taking the name of the
// Tablegen record (or override) and appending the suffix from its
// parameter type. (If the intrinsic is unparametrised, its
// parameter type will be given as Void, which returns the empty
// string for acleSuffix.)
StringRef BaseName =
    (R->isSubClassOf("NameOverride") ? R->getValueAsString("basename")
5
←
'?' condition is false→
                                     : R->getName());
StringRef overrideLetter = R->getValueAsString("overrideKindLetter");
FullName =
    (Twine(BaseName) + Param->acleSuffix(std::string(overrideLetter))).str();

// Derive the intrinsic's polymorphic name, by removing components from the
// full name as specified by its 'pnt' member ('polymorphic name type'),
// which indicates how many type suffixes to remove, and any other piece of
// the name that should be removed.
Record *PolymorphicNameType = R->getValueAsDef("pnt");
SmallVector<StringRef, 8> NameParts;
StringRef(FullName).split(NameParts, '_');
for (unsigned i = 0, e = PolymorphicNameType->getValueAsInt(
7
←
Loop condition is false. Execution continues on line 1355→
                         "NumTypeSuffixesToDiscard");
     i < e; ++i)
6
←
Assuming 'i' is >= 'e'→
  NameParts.pop_back();
if (!PolymorphicNameType->isValueUnset("ExtraSuffixToDiscard")) {
8
←
Taking true branch→
  StringRef ExtraSuffix =
      PolymorphicNameType->getValueAsString("ExtraSuffixToDiscard");
  auto it = NameParts.end();
  while (it != NameParts.begin()) {
9
←
Assuming the condition is false→
10
←
Loop condition is false. Execution continues on line 1367→
    --it;
    if (*it == ExtraSuffix) {
      NameParts.erase(it);
      break;
    }
  }
}
ShortName = join(std::begin(NameParts), std::end(NameParts), "_");

BuiltinExtension = R->getValueAsString("builtinExtension");

PolymorphicOnly = R->getValueAsBit("polymorphicOnly");
NonEvaluating = R->getValueAsBit("nonEvaluating");
HeaderOnly = R->getValueAsBit("headerOnly");

// Process the intrinsic's argument list.
DagInit *ArgsDag = R->getValueAsDag("args");
Result::Scope Scope;
for (unsigned i = 0, e = ArgsDag->getNumArgs(); i < e; ++i) {
11
←
Assuming 'i' is < 'e'→
12
←
Loop condition is true.  Entering loop body→
  Init *TypeInit = ArgsDag->getArg(i);

  bool Promote = true;
  if (auto TypeDI13.1
'TypeDI' is non-null
1
'TypeDI' is non-null
 = dyn_cast<DefInit>(TypeInit))
13
←
Assuming 'TypeInit' is a 'DefInit'→
14
←
Taking true branch→
    if (TypeDI->getDef()->isSubClassOf("unpromoted"))
15
←
Taking false branch→
      Promote = false;

  // Work out the type of the argument, for use in the function prototype in
  // the header file.
  const Type *ArgType = ME.getType(TypeInit, Param);
  ArgTypes.push_back(ArgType);

  // If the argument is a subclass of Immediate, record the details about
  // what values it can take, for Sema checking.
  bool Immediate = false;
  if (auto TypeDI16.1
'TypeDI' is non-null
1
'TypeDI' is non-null
 = dyn_cast<DefInit>(TypeInit)) {
16
←
'TypeInit' is a 'DefInit'→
17
←
Taking true branch→
    Record *TypeRec = TypeDI->getDef();
    if (TypeRec->isSubClassOf("Immediate")) {
18
←
Taking true branch→
      Immediate = true;

      Record *Bounds = TypeRec->getValueAsDef("bounds");
      ImmediateArg &IA = ImmediateArgs[i];
      if (Bounds->isSubClassOf("IB_ConstRange")) {
19
←
Taking false branch→
        IA.boundsType = ImmediateArg::BoundsType::ExplicitRange;
        IA.i1 = Bounds->getValueAsInt("lo");
        IA.i2 = Bounds->getValueAsInt("hi");
      } else if (Bounds->getName() == "IB_UEltValue") {
20
←
Assuming the condition is false→
21
←
Taking false branch→
        IA.boundsType = ImmediateArg::BoundsType::UInt;
        IA.i1 = Param->sizeInBits();
      } else if (Bounds->getName() == "IB_LaneIndex") {
22
←
Assuming the condition is true→
23
←
Taking true branch→
        IA.boundsType = ImmediateArg::BoundsType::ExplicitRange;
        IA.i1 = 0;
        IA.i2 = 128 / Param->sizeInBits() - 1;
24
←
Calling 'VoidType::sizeInBits'→
26
←
Returning from 'VoidType::sizeInBits'→
27
←
Division by zero
      } else if (Bounds->isSubClassOf("IB_EltBit")) {
        IA.boundsType = ImmediateArg::BoundsType::ExplicitRange;
        IA.i1 = Bounds->getValueAsInt("base");
        const Type *T = ME.getType(Bounds->getValueAsDef("type"), Param);
        IA.i2 = IA.i1 + T->sizeInBits() - 1;
      } else {
        PrintFatalError("unrecognised ImmediateBounds subclass");
      }

      IA.ArgType = ArgType;

      if (!TypeRec->isValueUnset("extra")) {
        IA.ExtraCheckType = TypeRec->getValueAsString("extra");
        if (!TypeRec->isValueUnset("extraarg"))
          IA.ExtraCheckArgs = TypeRec->getValueAsString("extraarg");
      }
    }
  }

  // The argument will usually have a name in the arguments dag, which goes
  // into the variable-name scope that the code gen will refer to.
  StringRef ArgName = ArgsDag->getArgNameStr(i);
  if (!ArgName.empty())
    Scope[std::string(ArgName)] =
        ME.getCodeForArg(i, ArgType, Promote, Immediate);
}

// Finally, go through the codegen dag and translate it into a Result object
// (with an arbitrary DAG of depended-on Results hanging off it).
DagInit *CodeDag = R->getValueAsDag("codegen");
Record *MainOp = cast<DefInit>(CodeDag->getOperator())->getDef();
if (MainOp->isSubClassOf("CustomCodegen")) {
  // Or, if it's the special case of CustomCodegen, just accumulate
  // a list of parameters we're going to assign to variables before
  // breaking from the loop.
  CustomCodeGenArgs["CustomCodeGenType"] =
      (Twine("CustomCodeGen::") + MainOp->getValueAsString("type")).str();
  for (unsigned i = 0, e = CodeDag->getNumArgs(); i < e; ++i) {
    StringRef Name = CodeDag->getArgNameStr(i);
    if (Name.empty()) {
      PrintFatalError("Operands to CustomCodegen should have names");
    } else if (auto *II = dyn_cast<IntInit>(CodeDag->getArg(i))) {
      CustomCodeGenArgs[std::string(Name)] = itostr(II->getValue());
    } else if (auto *SI = dyn_cast<StringInit>(CodeDag->getArg(i))) {
      CustomCodeGenArgs[std::string(Name)] = std::string(SI->getValue());
    } else {
      PrintFatalError("Operands to CustomCodegen should be integers");
    }
  }
} else {
  Code = ME.getCodeForDag(CodeDag, Scope, Param);
}
1464}

1466EmitterBase::EmitterBase(RecordKeeper &Records) {
// Construct the whole EmitterBase.

// First, look up all the instances of PrimitiveType. This gives us the list
// of vector typedefs we have to put in arm_mve.h, and also allows us to
// collect all the useful ScalarType instances into a big list so that we can
// use it for operations such as 'find the unsigned version of this signed
// integer type'.
for (Record *R : Records.getAllDerivedDefinitions("PrimitiveType"))
  ScalarTypes[std::string(R->getName())] = std::make_unique<ScalarType>(R);

// Now go through the instances of Intrinsic, and for each one, iterate
// through its list of type parameters making an ACLEIntrinsic for each one.
for (Record *R : Records.getAllDerivedDefinitions("Intrinsic")) {
  for (Record *RParam : R->getValueAsListOfDefs("params")) {
    const Type *Param = getType(RParam, getVoidType());
    auto Intrinsic = std::make_unique<ACLEIntrinsic>(*this, R, Param);
3
←
Calling 'make_unique<(anonymous namespace)::ACLEIntrinsic, (anonymous namespace)::EmitterBase &, llvm::Record *&, const (anonymous namespace)::Type *&>'→
    ACLEIntrinsics[Intrinsic->fullName()] = std::move(Intrinsic);
  }
}
1486}

1488/// A wrapper on raw_string_ostream that contains its own buffer rather than
1489/// having to point it at one elsewhere. (In other words, it works just like
1490/// std::ostringstream; also, this makes it convenient to declare a whole array
1491/// of them at once.)
1492///
1493/// We have to set this up using multiple inheritance, to ensure that the
1494/// string member has been constructed before raw_string_ostream's constructor
1495/// is given a pointer to it.
1496class string_holder {
1497protected:
std::string S;
1499};
1500class raw_self_contained_string_ostream : private string_holder,
                                        public raw_string_ostream {
1502public:
raw_self_contained_string_ostream() : raw_string_ostream(S) {}
1504};

1506const char LLVMLicenseHeader[] =
  " *\n"
  " *\n"
  " * Part of the LLVM Project, under the Apache License v2.0 with LLVM"
  " Exceptions.\n"
  " * See https://llvm.org/LICENSE.txt for license information.\n"
  " * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception\n"
  " *\n"
  " *===-----------------------------------------------------------------"
  "------===\n"
  " */\n"
  "\n";

1519// Machinery for the grouping of intrinsics by similar codegen.
1520//
1521// The general setup is that 'MergeableGroup' stores the things that a set of
1522// similarly shaped intrinsics have in common: the text of their code
1523// generation, and the number and type of their parameter variables.
1524// MergeableGroup is the key in a std::map whose value is a set of
1525// OutputIntrinsic, which stores the ways in which a particular intrinsic
1526// specializes the MergeableGroup's generic description: the function name and
1527// the _values_ of the parameter variables.

1529struct ComparableStringVector : std::vector<std::string> {
// Infrastructure: a derived class of vector<string> which comes with an
// ordering, so that it can be used as a key in maps and an element in sets.
// There's no requirement on the ordering beyond being deterministic.
bool operator<(const ComparableStringVector &rhs) const {
  if (size() != rhs.size())
    return size() < rhs.size();
  for (size_t i = 0, e = size(); i < e; ++i)
    if ((*this)[i] != rhs[i])
      return (*this)[i] < rhs[i];
  return false;
}
1541};

1543struct OutputIntrinsic {
const ACLEIntrinsic *Int;
std::string Name;
ComparableStringVector ParamValues;
bool operator<(const OutputIntrinsic &rhs) const {
  if (Name != rhs.Name)
    return Name < rhs.Name;
  return ParamValues < rhs.ParamValues;
}
1552};
1553struct MergeableGroup {
std::string Code;
ComparableStringVector ParamTypes;
bool operator<(const MergeableGroup &rhs) const {
  if (Code != rhs.Code)
    return Code < rhs.Code;
  return ParamTypes < rhs.ParamTypes;
}
1561};

1563void EmitterBase::EmitBuiltinCG(raw_ostream &OS) {
// Pass 1: generate code for all the intrinsics as if every type or constant
// that can possibly be abstracted out into a parameter variable will be.
// This identifies the sets of intrinsics we'll group together into a single
// piece of code generation.

std::map<MergeableGroup, std::set<OutputIntrinsic>> MergeableGroupsPrelim;

for (const auto &kv : ACLEIntrinsics) {
  const ACLEIntrinsic &Int = *kv.second;
  if (Int.headerOnly())
    continue;

  MergeableGroup MG;
  OutputIntrinsic OI;

  OI.Int = &Int;
  OI.Name = Int.fullName();
  CodeGenParamAllocator ParamAllocPrelim{&MG.ParamTypes, &OI.ParamValues};
  raw_string_ostream OS(MG.Code);
  Int.genCode(OS, ParamAllocPrelim, 1);
  OS.flush();

  MergeableGroupsPrelim[MG].insert(OI);
}

// Pass 2: for each of those groups, optimize the parameter variable set by
// eliminating 'parameters' that are the same for all intrinsics in the
// group, and merging together pairs of parameter variables that take the
// same values as each other for all intrinsics in the group.

std::map<MergeableGroup, std::set<OutputIntrinsic>> MergeableGroups;

for (const auto &kv : MergeableGroupsPrelim) {
  const MergeableGroup &MG = kv.first;
  std::vector<int> ParamNumbers;
  std::map<ComparableStringVector, int> ParamNumberMap;

  // Loop over the parameters for this group.
  for (size_t i = 0, e = MG.ParamTypes.size(); i < e; ++i) {
    // Is this parameter the same for all intrinsics in the group?
    const OutputIntrinsic &OI_first = *kv.second.begin();
    bool Constant = all_of(kv.second, [&](const OutputIntrinsic &OI) {
      return OI.ParamValues[i] == OI_first.ParamValues[i];
    });

    // If so, record it as -1, meaning 'no parameter variable needed'. Then
    // the corresponding call to allocParam in pass 2 will not generate a
    // variable at all, and just use the value inline.
    if (Constant) {
      ParamNumbers.push_back(-1);
      continue;
    }

    // Otherwise, make a list of the values this parameter takes for each
    // intrinsic, and see if that value vector matches anything we already
    // have. We also record the parameter type, so that we don't accidentally
    // match up two parameter variables with different types. (Not that
    // there's much chance of them having textually equivalent values, but in
    // _principle_ it could happen.)
    ComparableStringVector key;
    key.push_back(MG.ParamTypes[i]);
    for (const auto &OI : kv.second)
      key.push_back(OI.ParamValues[i]);

    auto Found = ParamNumberMap.find(key);
    if (Found != ParamNumberMap.end()) {
      // Yes, an existing parameter variable can be reused for this.
      ParamNumbers.push_back(Found->second);
      continue;
    }

    // No, we need a new parameter variable.
    int ExistingIndex = ParamNumberMap.size();
    ParamNumberMap[key] = ExistingIndex;
    ParamNumbers.push_back(ExistingIndex);
  }

  // Now we're ready to do the pass 2 code generation, which will emit the
  // reduced set of parameter variables we've just worked out.

  for (const auto &OI_prelim : kv.second) {
    const ACLEIntrinsic *Int = OI_prelim.Int;

    MergeableGroup MG;
    OutputIntrinsic OI;

    OI.Int = OI_prelim.Int;
    OI.Name = OI_prelim.Name;
    CodeGenParamAllocator ParamAlloc{&MG.ParamTypes, &OI.ParamValues,
                                     &ParamNumbers};
    raw_string_ostream OS(MG.Code);
    Int->genCode(OS, ParamAlloc, 2);
    OS.flush();

    MergeableGroups[MG].insert(OI);
  }
}

// Output the actual C++ code.

for (const auto &kv : MergeableGroups) {
  const MergeableGroup &MG = kv.first;

  // List of case statements in the main switch on BuiltinID, and an open
  // brace.
  const char *prefix = "";
  for (const auto &OI : kv.second) {
    OS << prefix << "case ARM::BI__builtin_arm_" << OI.Int->builtinExtension()
       << "_" << OI.Name << ":";

    prefix = "\n";
  }
  OS << " {\n";

  if (!MG.ParamTypes.empty()) {
    // If we've got some parameter variables, then emit their declarations...
    for (size_t i = 0, e = MG.ParamTypes.size(); i < e; ++i) {
      StringRef Type = MG.ParamTypes[i];
      OS << "  " << Type;
      if (!Type.endswith("*"))
        OS << " ";
      OS << " Param" << utostr(i) << ";\n";
    }

    // ... and an inner switch on BuiltinID that will fill them in with each
    // individual intrinsic's values.
    OS << "  switch (BuiltinID) {\n";
    for (const auto &OI : kv.second) {
      OS << "  case ARM::BI__builtin_arm_" << OI.Int->builtinExtension()
         << "_" << OI.Name << ":\n";
      for (size_t i = 0, e = MG.ParamTypes.size(); i < e; ++i)
        OS << "    Param" << utostr(i) << " = " << OI.ParamValues[i] << ";\n";
      OS << "    break;\n";
    }
    OS << "  }\n";
  }

  // And finally, output the code, and close the outer pair of braces. (The
  // code will always end with a 'return' statement, so we need not insert a
  // 'break' here.)
  OS << MG.Code << "}\n";
}
1706}

1708void EmitterBase::EmitBuiltinAliases(raw_ostream &OS) {
// Build a sorted table of:
// - intrinsic id number
// - full name
// - polymorphic name or -1
StringToOffsetTable StringTable;
OS << "static const IntrinToName MapData[] = {\n";
for (const auto &kv : ACLEIntrinsics) {
  const ACLEIntrinsic &Int = *kv.second;
  if (Int.headerOnly())
    continue;
  int32_t ShortNameOffset =
      Int.polymorphic() ? StringTable.GetOrAddStringOffset(Int.shortName())
                        : -1;
  OS << "  { ARM::BI__builtin_arm_" << Int.builtinExtension() << "_"
     << Int.fullName() << ", "
     << StringTable.GetOrAddStringOffset(Int.fullName()) << ", "
     << ShortNameOffset << "},\n";
}
OS << "};\n\n";

OS << "ArrayRef<IntrinToName> Map(MapData);\n\n";

OS << "static const char IntrinNames[] = {\n";
StringTable.EmitString(OS);
OS << "};\n\n";
1734}

1736void EmitterBase::GroupSemaChecks(
  std::map<std::string, std::set<std::string>> &Checks) {
for (const auto &kv : ACLEIntrinsics) {
  const ACLEIntrinsic &Int = *kv.second;
  if (Int.headerOnly())
    continue;
  std::string Check = Int.genSema();
  if (!Check.empty())
    Checks[Check].insert(Int.fullName());
}
1746}

1748// -----------------------------------------------------------------------------
1749// The class used for generating arm_mve.h and related Clang bits
1750//

1752class MveEmitter : public EmitterBase {
1753public:
MveEmitter(RecordKeeper &Records) : EmitterBase(Records){};
void EmitHeader(raw_ostream &OS) override;
void EmitBuiltinDef(raw_ostream &OS) override;
void EmitBuiltinSema(raw_ostream &OS) override;
1758};

1760void MveEmitter::EmitHeader(raw_ostream &OS) {
// Accumulate pieces of the header file that will be enabled under various
// different combinations of #ifdef. The index into parts[] is made up of
// the following bit flags.
constexpr unsigned Float = 1;
constexpr unsigned UseUserNamespace = 2;

constexpr unsigned NumParts = 4;
raw_self_contained_string_ostream parts[NumParts];

// Write typedefs for all the required vector types, and a few scalar
// types that don't already have the name we want them to have.

parts[0] << "typedef uint16_t mve_pred16_t;\n";
parts[Float] << "typedef __fp16 float16_t;\n"
                "typedef float float32_t;\n";
for (const auto &kv : ScalarTypes) {
  const ScalarType *ST = kv.second.get();
  if (ST->hasNonstandardName())
    continue;
  raw_ostream &OS = parts[ST->requiresFloat() ? Float : 0];
  const VectorType *VT = getVectorType(ST);

  OS << "typedef __attribute__((__neon_vector_type__(" << VT->lanes()
     << "), __clang_arm_mve_strict_polymorphism)) " << ST->cName() << " "
     << VT->cName() << ";\n";

  // Every vector type also comes with a pair of multi-vector types for
  // the VLD2 and VLD4 instructions.
  for (unsigned n = 2; n <= 4; n += 2) {
    const MultiVectorType *MT = getMultiVectorType(n, VT);
    OS << "typedef struct { " << VT->cName() << " val[" << n << "]; } "
       << MT->cName() << ";\n";
  }
}
parts[0] << "\n";
parts[Float] << "\n";

// Write declarations for all the intrinsics.

for (const auto &kv : ACLEIntrinsics) {
  const ACLEIntrinsic &Int = *kv.second;

  // We generate each intrinsic twice, under its full unambiguous
  // name and its shorter polymorphic name (if the latter exists).
  for (bool Polymorphic : {false, true}) {
    if (Polymorphic && !Int.polymorphic())
      continue;
    if (!Polymorphic && Int.polymorphicOnly())
      continue;

    // We also generate each intrinsic under a name like __arm_vfooq
    // (which is in C language implementation namespace, so it's
    // safe to define in any conforming user program) and a shorter
    // one like vfooq (which is in user namespace, so a user might
    // reasonably have used it for something already). If so, they
    // can #define __ARM_MVE_PRESERVE_USER_NAMESPACE before
    // including the header, which will suppress the shorter names
    // and leave only the implementation-namespace ones. Then they
    // have to write __arm_vfooq everywhere, of course.

    for (bool UserNamespace : {false, true}) {
      raw_ostream &OS = parts[(Int.requiresFloat() ? Float : 0) |
                              (UserNamespace ? UseUserNamespace : 0)];

      // Make the name of the function in this declaration.

      std::string FunctionName =
          Polymorphic ? Int.shortName() : Int.fullName();
      if (!UserNamespace)
        FunctionName = "__arm_" + FunctionName;

      // Make strings for the types involved in the function's
      // prototype.

      std::string RetTypeName = Int.returnType()->cName();
      if (!StringRef(RetTypeName).endswith("*"))
        RetTypeName += " ";

      std::vector<std::string> ArgTypeNames;
      for (const Type *ArgTypePtr : Int.argTypes())
        ArgTypeNames.push_back(ArgTypePtr->cName());
      std::string ArgTypesString =
          join(std::begin(ArgTypeNames), std::end(ArgTypeNames), ", ");

      // Emit the actual declaration. All these functions are
      // declared 'static inline' without a body, which is fine
      // provided clang recognizes them as builtins, and has the
      // effect that this type signature is used in place of the one
      // that Builtins.def didn't provide. That's how we can get
      // structure types that weren't defined until this header was
      // included to be part of the type signature of a builtin that
      // was known to clang already.
      //
      // The declarations use __attribute__(__clang_arm_builtin_alias),
      // so that each function declared will be recognized as the
      // appropriate MVE builtin in spite of its user-facing name.
      //
      // (That's better than making them all wrapper functions,
      // partly because it avoids any compiler error message citing
      // the wrapper function definition instead of the user's code,
      // and mostly because some MVE intrinsics have arguments
      // required to be compile-time constants, and that property
      // can't be propagated through a wrapper function. It can be
      // propagated through a macro, but macros can't be overloaded
      // on argument types very easily - you have to use _Generic,
      // which makes error messages very confusing when the user
      // gets it wrong.)
      //
      // Finally, the polymorphic versions of the intrinsics are
      // also defined with __attribute__(overloadable), so that when
      // the same name is defined with several type signatures, the
      // right thing happens. Each one of the overloaded
      // declarations is given a different builtin id, which
      // has exactly the effect we want: first clang resolves the
      // overload to the right function, then it knows which builtin
      // it's referring to, and then the Sema checking for that
      // builtin can check further things like the constant
      // arguments.
      //
      // One more subtlety is the newline just before the return
      // type name. That's a cosmetic tweak to make the error
      // messages legible if the user gets the types wrong in a call
      // to a polymorphic function: this way, clang will print just
      // the _final_ line of each declaration in the header, to show
      // the type signatures that would have been legal. So all the
      // confusing machinery with __attribute__ is left out of the
      // error message, and the user sees something that's more or
      // less self-documenting: "here's a list of actually readable
      // type signatures for vfooq(), and here's why each one didn't
      // match your call".

      OS << "static __inline__ __attribute__(("
         << (Polymorphic ? "__overloadable__, " : "")
         << "__clang_arm_builtin_alias(__builtin_arm_mve_" << Int.fullName()
         << ")))\n"
         << RetTypeName << FunctionName << "(" << ArgTypesString << ");\n";
    }
  }
}
for (auto &part : parts)
  part << "\n";

// Now we've finished accumulating bits and pieces into the parts[] array.
// Put it all together to write the final output file.

OS << "/*===---- arm_mve.h - ARM MVE intrinsics "
      "-----------------------------------===\n"
   << LLVMLicenseHeader
   << "#ifndef __ARM_MVE_H\n"
      "#define __ARM_MVE_H\n"
      "\n"
      "#if !__ARM_FEATURE_MVE\n"
      "#error \"MVE support not enabled\"\n"
      "#endif\n"
      "\n"
      "#include <stdint.h>\n"
      "\n"
      "#ifdef __cplusplus\n"
      "extern \"C\" {\n"
      "#endif\n"
      "\n";

for (size_t i = 0; i < NumParts; ++i) {
  std::vector<std::string> conditions;
  if (i & Float)
    conditions.push_back("(__ARM_FEATURE_MVE & 2)");
  if (i & UseUserNamespace)
    conditions.push_back("(!defined __ARM_MVE_PRESERVE_USER_NAMESPACE)");

  std::string condition =
      join(std::begin(conditions), std::end(conditions), " && ");
  if (!condition.empty())
    OS << "#if " << condition << "\n\n";
  OS << parts[i].str();
  if (!condition.empty())
    OS << "#endif /* " << condition << " */\n\n";
}

OS << "#ifdef __cplusplus\n"
      "} /* extern \"C\" */\n"
      "#endif\n"
      "\n"
      "#endif /* __ARM_MVE_H */\n";
1944}

1946void MveEmitter::EmitBuiltinDef(raw_ostream &OS) {
for (const auto &kv : ACLEIntrinsics) {
  const ACLEIntrinsic &Int = *kv.second;
  OS << "BUILTIN(__builtin_arm_mve_" << Int.fullName()
     << ", \"\", \"n\")\n";
}

std::set<std::string> ShortNamesSeen;

for (const auto &kv : ACLEIntrinsics) {
  const ACLEIntrinsic &Int = *kv.second;
  if (Int.polymorphic()) {
    StringRef Name = Int.shortName();
    if (ShortNamesSeen.find(std::string(Name)) == ShortNamesSeen.end()) {
      OS << "BUILTIN(__builtin_arm_mve_" << Name << ", \"vi.\", \"nt";
      if (Int.nonEvaluating())
        OS << "u"; // indicate that this builtin doesn't evaluate its args
      OS << "\")\n";
      ShortNamesSeen.insert(std::string(Name));
    }
  }
}
1968}

1970void MveEmitter::EmitBuiltinSema(raw_ostream &OS) {
std::map<std::string, std::set<std::string>> Checks;
GroupSemaChecks(Checks);

for (const auto &kv : Checks) {
  for (StringRef Name : kv.second)
    OS << "case ARM::BI__builtin_arm_mve_" << Name << ":\n";
  OS << "  return " << kv.first;
}
1979}

1981// -----------------------------------------------------------------------------
1982// Class that describes an ACLE intrinsic implemented as a macro.
1983//
1984// This class is used when the intrinsic is polymorphic in 2 or 3 types, but we
1985// want to avoid a combinatorial explosion by reinterpreting the arguments to
1986// fixed types.

1988class FunctionMacro {
std::vector<StringRef> Params;
StringRef Definition;

1992public:
FunctionMacro(const Record &R);

const std::vector<StringRef> &getParams() const { return Params; }
StringRef getDefinition() const { return Definition; }
1997};

1999FunctionMacro::FunctionMacro(const Record &R) {
Params = R.getValueAsListOfStrings("params");
Definition = R.getValueAsString("definition");
2002}

2004// -----------------------------------------------------------------------------
2005// The class used for generating arm_cde.h and related Clang bits
2006//

2008class CdeEmitter : public EmitterBase {
std::map<StringRef, FunctionMacro> FunctionMacros;

2011public:
CdeEmitter(RecordKeeper &Records);
void EmitHeader(raw_ostream &OS) override;
void EmitBuiltinDef(raw_ostream &OS) override;
void EmitBuiltinSema(raw_ostream &OS) override;
2016};

2018CdeEmitter::CdeEmitter(RecordKeeper &Records) : EmitterBase(Records) {
2
←
Calling constructor for 'EmitterBase'→
for (Record *R : Records.getAllDerivedDefinitions("FunctionMacro"))
  FunctionMacros.emplace(R->getName(), FunctionMacro(*R));
2021}

2023void CdeEmitter::EmitHeader(raw_ostream &OS) {
// Accumulate pieces of the header file that will be enabled under various
// different combinations of #ifdef. The index into parts[] is one of the
// following:
constexpr unsigned None = 0;
constexpr unsigned MVE = 1;
constexpr unsigned MVEFloat = 2;

constexpr unsigned NumParts = 3;
raw_self_contained_string_ostream parts[NumParts];

// Write typedefs for all the required vector types, and a few scalar
// types that don't already have the name we want them to have.

parts[MVE] << "typedef uint16_t mve_pred16_t;\n";
parts[MVEFloat] << "typedef __fp16 float16_t;\n"
                   "typedef float float32_t;\n";
for (const auto &kv : ScalarTypes) {
  const ScalarType *ST = kv.second.get();
  if (ST->hasNonstandardName())
    continue;
  // We don't have float64x2_t
  if (ST->kind() == ScalarTypeKind::Float && ST->sizeInBits() == 64)
    continue;
  raw_ostream &OS = parts[ST->requiresFloat() ? MVEFloat : MVE];
  const VectorType *VT = getVectorType(ST);

  OS << "typedef __attribute__((__neon_vector_type__(" << VT->lanes()
     << "), __clang_arm_mve_strict_polymorphism)) " << ST->cName() << " "
     << VT->cName() << ";\n";
}
parts[MVE] << "\n";
parts[MVEFloat] << "\n";

// Write declarations for all the intrinsics.

for (const auto &kv : ACLEIntrinsics) {
  const ACLEIntrinsic &Int = *kv.second;

  // We generate each intrinsic twice, under its full unambiguous
  // name and its shorter polymorphic name (if the latter exists).
  for (bool Polymorphic : {false, true}) {
    if (Polymorphic && !Int.polymorphic())
      continue;
    if (!Polymorphic && Int.polymorphicOnly())
      continue;

    raw_ostream &OS =
        parts[Int.requiresFloat() ? MVEFloat
                                  : Int.requiresMVE() ? MVE : None];

    // Make the name of the function in this declaration.
    std::string FunctionName =
        "__arm_" + (Polymorphic ? Int.shortName() : Int.fullName());

    // Make strings for the types involved in the function's
    // prototype.
    std::string RetTypeName = Int.returnType()->cName();
    if (!StringRef(RetTypeName).endswith("*"))
      RetTypeName += " ";

    std::vector<std::string> ArgTypeNames;
    for (const Type *ArgTypePtr : Int.argTypes())
      ArgTypeNames.push_back(ArgTypePtr->cName());
    std::string ArgTypesString =
        join(std::begin(ArgTypeNames), std::end(ArgTypeNames), ", ");

    // Emit the actual declaration. See MveEmitter::EmitHeader for detailed
    // comments
    OS << "static __inline__ __attribute__(("
       << (Polymorphic ? "__overloadable__, " : "")
       << "__clang_arm_builtin_alias(__builtin_arm_" << Int.builtinExtension()
       << "_" << Int.fullName() << ")))\n"
       << RetTypeName << FunctionName << "(" << ArgTypesString << ");\n";
  }
}

for (const auto &kv : FunctionMacros) {
  StringRef Name = kv.first;
  const FunctionMacro &FM = kv.second;

  raw_ostream &OS = parts[MVE];
  OS << "#define "
     << "__arm_" << Name << "(" << join(FM.getParams(), ", ") << ") "
     << FM.getDefinition() << "\n";
}

for (auto &part : parts)
  part << "\n";

// Now we've finished accumulating bits and pieces into the parts[] array.
// Put it all together to write the final output file.

OS << "/*===---- arm_cde.h - ARM CDE intrinsics "
      "-----------------------------------===\n"
   << LLVMLicenseHeader
   << "#ifndef __ARM_CDE_H\n"
      "#define __ARM_CDE_H\n"
      "\n"
      "#if !__ARM_FEATURE_CDE\n"
      "#error \"CDE support not enabled\"\n"
      "#endif\n"
      "\n"
      "#include <stdint.h>\n"
      "\n"
      "#ifdef __cplusplus\n"
      "extern \"C\" {\n"
      "#endif\n"
      "\n";

for (size_t i = 0; i < NumParts; ++i) {
  std::string condition;
  if (i == MVEFloat)
    condition = "__ARM_FEATURE_MVE & 2";
  else if (i == MVE)
    condition = "__ARM_FEATURE_MVE";

  if (!condition.empty())
    OS << "#if " << condition << "\n\n";
  OS << parts[i].str();
  if (!condition.empty())
    OS << "#endif /* " << condition << " */\n\n";
}

OS << "#ifdef __cplusplus\n"
      "} /* extern \"C\" */\n"
      "#endif\n"
      "\n"
      "#endif /* __ARM_CDE_H */\n";
2152}

2154void CdeEmitter::EmitBuiltinDef(raw_ostream &OS) {
for (const auto &kv : ACLEIntrinsics) {
  if (kv.second->headerOnly())
    continue;
  const ACLEIntrinsic &Int = *kv.second;
  OS << "BUILTIN(__builtin_arm_cde_" << Int.fullName()
     << ", \"\", \"ncU\")\n";
}
2162}

2164void CdeEmitter::EmitBuiltinSema(raw_ostream &OS) {
std::map<std::string, std::set<std::string>> Checks;
GroupSemaChecks(Checks);

for (const auto &kv : Checks) {
  for (StringRef Name : kv.second)
    OS << "case ARM::BI__builtin_arm_cde_" << Name << ":\n";
  OS << "  Err = " << kv.first << "  break;\n";
}
2173}

2175} // namespace

2177namespace clang {

2179// MVE

2181void EmitMveHeader(RecordKeeper &Records, raw_ostream &OS) {
MveEmitter(Records).EmitHeader(OS);
2183}

2185void EmitMveBuiltinDef(RecordKeeper &Records, raw_ostream &OS) {
MveEmitter(Records).EmitBuiltinDef(OS);
2187}

2189void EmitMveBuiltinSema(RecordKeeper &Records, raw_ostream &OS) {
MveEmitter(Records).EmitBuiltinSema(OS);
2191}

2193void EmitMveBuiltinCG(RecordKeeper &Records, raw_ostream &OS) {
MveEmitter(Records).EmitBuiltinCG(OS);
2195}

2197void EmitMveBuiltinAliases(RecordKeeper &Records, raw_ostream &OS) {
MveEmitter(Records).EmitBuiltinAliases(OS);
2199}

2201// CDE

2203void EmitCdeHeader(RecordKeeper &Records, raw_ostream &OS) {
CdeEmitter(Records).EmitHeader(OS);
2205}

2207void EmitCdeBuiltinDef(RecordKeeper &Records, raw_ostream &OS) {
CdeEmitter(Records).EmitBuiltinDef(OS);
2209}

2211void EmitCdeBuiltinSema(RecordKeeper &Records, raw_ostream &OS) {
CdeEmitter(Records).EmitBuiltinSema(OS);
2213}

2215void EmitCdeBuiltinCG(RecordKeeper &Records, raw_ostream &OS) {
CdeEmitter(Records).EmitBuiltinCG(OS);
2217}

2219void EmitCdeBuiltinAliases(RecordKeeper &Records, raw_ostream &OS) {
CdeEmitter(Records).EmitBuiltinAliases(OS);
1
Calling constructor for 'CdeEmitter'→
2221}

2223} // end namespace clang

←

/usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/bits/unique_ptr.h

1// unique_ptr implementation -*- C++ -*-

3// Copyright (C) 2008-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/unique_ptr.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1

33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>
40#if __cplusplus201402L > 201703L
41# include <compare>
42# include <ostream>
43#endif

45namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
46{
47_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

54#if _GLIBCXX_USE_DEPRECATED1
55#pragma GCC diagnostic push
56#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
58#pragma GCC diagnostic pop
59#endif

/// Primary template of default_delete, used by unique_ptr for single objects
template<typename _Tp>
  struct default_delete
  {
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for objects of another type, `_Up`,
     * only if `_Up*` is convertible to `_Tp*`.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up*, _Tp*>>>
      default_delete(const default_delete<_Up>&) noexcept { }

    /// Calls `delete __ptr`
    void
    operator()(_Tp* __ptr) const
    {
static_assert(!is_void<_Tp>::value,
      "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete __ptr;
    }
  };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length

/// Specialization of default_delete for arrays, used by `unique_ptr<T[]>`
template<typename _Tp>
  struct default_delete<_Tp[]>
  {
  public:
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, such as
     * a const-qualified version of `_Tp`.
     *
     * Conversions from types derived from `_Tp` are not allowed because
     * it is undefined to `delete[]` an array of derived types through a
     * pointer to the base type.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
      default_delete(const default_delete<_Up[]>&) noexcept { }

    /// Calls `delete[] __ptr`
    template<typename _Up>
typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
{
 static_assert(sizeof(_Tp)>0,
	"can't delete pointer to incomplete type");
 delete [] __ptr;
}
  };

/// @cond undocumented

// Manages the pointer and deleter of a unique_ptr
template <typename _Tp, typename _Dp>
  class __uniq_ptr_impl
  {
    template <typename _Up, typename _Ep, typename = void>
struct _Ptr
{
 using type = _Up*;
};

    template <typename _Up, typename _Ep>
struct
_Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
{
 using type = typename remove_reference<_Ep>::type::pointer;
};

  public:
    using _DeleterConstraint = enable_if<
      __and_<__not_<is_pointer<_Dp>>,
      is_default_constructible<_Dp>>::value>;

    using pointer = typename _Ptr<_Tp, _Dp>::type;

    static_assert( !is_rvalue_reference<_Dp>::value,
     "unique_ptr's deleter type must be a function object type"
     " or an lvalue reference type" );

    __uniq_ptr_impl() = default;
    __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

    template<typename _Del>
    __uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }

    __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
    : _M_t(std::move(__u._M_t))
    { __u._M_ptr() = nullptr; }

    __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
    {
reset(__u.release());
_M_deleter() = std::forward<_Dp>(__u._M_deleter());
return *this;
    }

    pointer&   _M_ptr() { return std::get<0>(_M_t); }
    pointer    _M_ptr() const { return std::get<0>(_M_t); }
    _Dp&       _M_deleter() { return std::get<1>(_M_t); }
    const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

    void reset(pointer __p) noexcept
    {
const pointer __old_p = _M_ptr();
_M_ptr() = __p;
if (__old_p)
 _M_deleter()(__old_p);
    }

    pointer release() noexcept
    {
pointer __p = _M_ptr();
_M_ptr() = nullptr;
return __p;
    }

    void
    swap(__uniq_ptr_impl& __rhs) noexcept
    {
using std::swap;
swap(this->_M_ptr(), __rhs._M_ptr());
swap(this->_M_deleter(), __rhs._M_deleter());
    }

  private:
    tuple<pointer, _Dp> _M_t;
  };

// Defines move construction + assignment as either defaulted or deleted.
template <typename _Tp, typename _Dp,
   bool = is_move_constructible<_Dp>::value,
   bool = is_move_assignable<_Dp>::value>
  struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };
/// @endcond

/// 20.7.1.2 unique_ptr for single objects.
template <typename _Tp, typename _Dp = default_delete<_Tp>>
  class unique_ptr
  {
    template <typename _Up>
using _DeleterConstraint =
 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

  private:
    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
 __not_<is_array<_Up>>
      >;

  public:
    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_copy_constructible<_Del>>>
unique_ptr(pointer __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  An rvalue reference to a (non-reference) deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_move_constructible<_Del>>>
unique_ptr(pointer __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(__p, std::move(__d))
{ }

    template<typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type>
unique_ptr(pointer,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
{ }

    // Move constructors.

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /** @brief Converting constructor from another type
     *
     * Requires that the pointer owned by @p __u is convertible to the
     * type of pointer owned by this object, @p __u does not own an array,
     * and @p __u has a compatible deleter type.
     */
    template<typename _Up, typename _Ep, typename = _Require<
             __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

344#if _GLIBCXX_USE_DEPRECATED1
345#pragma GCC diagnostic push
346#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    /// Converting constructor from @c auto_ptr
    template<typename _Up, typename = _Require<
      is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
351#pragma GCC diagnostic pop
352#endif

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr() noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(std::move(__ptr));
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr& operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to a non-array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
      typename enable_if< __and_<
        __safe_conversion_up<_Up, _Ep>,
        is_assignable<deleter_type&, _Ep&&>
        >::value,
        unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Dereference the stored pointer.
    typename add_lvalue_reference<element_type>::type
    operator*() const
    {
__glibcxx_assert(get() != pointer());
return *get();
    }

    /// Return the stored pointer.
    pointer
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    void
    reset(pointer __p = pointer()) noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
_M_t.reset(std::move(__p));
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

/// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
  class unique_ptr<_Tp[], _Dp>
  {
    template <typename _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

    template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;

    // like is_base_of<_Tp, _Up> but false if unqualified types are the same
    template<typename _Up>
using __is_derived_Tp
 = __and_< is_base_of<_Tp, _Up>,
    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep,
             typename _UPtr = unique_ptr<_Up, _Ep>,
      typename _UP_pointer = typename _UPtr::pointer,
      typename _UP_element_type = typename _UPtr::element_type>
using __safe_conversion_up = __and_<
        is_array<_Up>,
        is_same<pointer, element_type*>,
        is_same<_UP_pointer, _UP_element_type*>,
        is_convertible<_UP_element_type(*)[], element_type(*)[]>
      >;

    // helper template for detecting a safe conversion from a raw pointer
    template<typename _Up>
      using __safe_conversion_raw = __and_<
        __or_<__or_<is_same<_Up, pointer>,
                    is_same<_Up, nullptr_t>>,
              __and_<is_pointer<_Up>,
                     is_same<pointer, element_type*>,
                     is_convertible<
                       typename remove_pointer<_Up>::type(*)[],
                       element_type(*)[]>
              >
        >
      >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Up,
      typename _Vp = _Dp,
      typename = _DeleterConstraint<_Vp>,
      typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_copy_constructible<_Del>>>
    unique_ptr(_Up __p, const deleter_type& __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_move_constructible<_Del>>>
unique_ptr(_Up __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ }

    template<typename _Up, typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type,
      typename = _Require<__safe_conversion_raw<_Up>>>
unique_ptr(_Up,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
      { }

    template<typename _Up, typename _Ep, typename = _Require<
      __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr()
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(__ptr);
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to an array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                       is_assignable<deleter_type&, _Ep&&>
                >::value,
                unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Access an element of owned array.
    typename std::add_lvalue_reference<element_type>::type
    operator[](size_t __i) const
    {
__glibcxx_assert(get() != pointer());
return get()[__i];
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    template <typename _Up,
              typename = _Require<
                __or_<is_same<_Up, pointer>,
                      __and_<is_same<pointer, element_type*>,
                             is_pointer<_Up>,
                             is_convertible<
                               typename remove_pointer<_Up>::type(*)[],
                               element_type(*)[]
                             >
                      >
                >
             >>
    void
    reset(_Up __p) noexcept
    { _M_t.reset(std::move(__p)); }

    void reset(nullptr_t = nullptr) noexcept
    { reset(pointer()); }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };

/// @relates unique_ptr @{

/// Swap overload for unique_ptr
template<typename _Tp, typename _Dp>
  inline
732#if __cplusplus201402L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__is_swappable<_Dp>::value>::type
735#else
  void
737#endif
  swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
  { __x.swap(__y); }

742#if __cplusplus201402L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename _Tp, typename _Dp>
  typename enable_if<!__is_swappable<_Dp>::value>::type
  swap(unique_ptr<_Tp, _Dp>&,
unique_ptr<_Tp, _Dp>&) = delete;
747#endif

/// Equality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() == __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return !__x; }

763#ifndef __cpp_lib_three_way_comparison
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return !__x; }

/// Inequality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() != __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return (bool)__x; }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return (bool)__x; }
789#endif // three way comparison

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  {
    typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
    return std::less<_CT>()(__x.get(), __y.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(nullptr < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(__x < nullptr); }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  { return (__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__x < __y); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(__x < nullptr); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD inline bool
  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(nullptr < __x); }

888#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Dp, typename _Up, typename _Ep>
  requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
		       typename unique_ptr<_Up, _Ep>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer,
	       typename unique_ptr<_Up, _Ep>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
  { return compare_three_way()(__x.get(), __y.get()); }

template<typename _Tp, typename _Dp>
  requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    using pointer = typename unique_ptr<_Tp, _Dp>::pointer;
    return compare_three_way()(__x.get(), static_cast<pointer>(nullptr));
  }
908#endif
// @} relates unique_ptr

/// @cond undocumented
template<typename _Up, typename _Ptr = typename _Up::pointer,
  bool = __poison_hash<_Ptr>::__enable_hash_call>
  struct __uniq_ptr_hash
915#if ! _GLIBCXX_INLINE_VERSION0
  : private __poison_hash<_Ptr>
917#endif
  {
    size_t
    operator()(const _Up& __u) const
    noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
    { return hash<_Ptr>()(__u.get()); }
  };

template<typename _Up, typename _Ptr>
  struct __uniq_ptr_hash<_Up, _Ptr, false>
  : private __poison_hash<_Ptr>
  { };
/// @endcond

/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
  struct hash<unique_ptr<_Tp, _Dp>>
  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
    public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
  { };

938#if __cplusplus201402L >= 201402L
/// @relates unique_ptr @{
940#define __cpp_lib_make_unique201304 201304

/// @cond undocumented

template<typename _Tp>
  struct _MakeUniq
  { typedef unique_ptr<_Tp> __single_object; };

template<typename _Tp>
  struct _MakeUniq<_Tp[]>
  { typedef unique_ptr<_Tp[]> __array; };

template<typename _Tp, size_t _Bound>
  struct _MakeUniq<_Tp[_Bound]>
  { struct __invalid_type { }; };

/// @endcond

/// std::make_unique for single objects
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__single_object
  make_unique(_Args&&... __args)
  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
4
←
Calling constructor for 'ACLEIntrinsic'→

/// std::make_unique for arrays of unknown bound
template<typename _Tp>
  inline typename _MakeUniq<_Tp>::__array
  make_unique(size_t __num)
  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

/// Disable std::make_unique for arrays of known bound
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__invalid_type
  make_unique(_Args&&...) = delete;
// @} relates unique_ptr
975#endif // C++14

977#if __cplusplus201402L > 201703L && __cpp_concepts
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2948. unique_ptr does not define operator<< for stream output
/// Stream output operator for unique_ptr
template<typename _CharT, typename _Traits, typename _Tp, typename _Dp>
  inline basic_ostream<_CharT, _Traits>&
  operator<<(basic_ostream<_CharT, _Traits>& __os,
      const unique_ptr<_Tp, _Dp>& __p)
  requires requires { __os << __p.get(); }
  {
    __os << __p.get();
    return __os;
  }
990#endif // C++20

// @} group pointer_abstractions

994#if __cplusplus201402L >= 201703L
namespace __detail::__variant
{
  template<typename> struct _Never_valueless_alt; // see <variant>

  // Provide the strong exception-safety guarantee when emplacing a
  // unique_ptr into a variant.
  template<typename _Tp, typename _Del>
    struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
    : std::true_type
    { };
}  // namespace __detail::__variant
1006#endif // C++17

1008_GLIBCXX_END_NAMESPACE_VERSION
1009} // namespace

1011#endif /* _UNIQUE_PTR_H */