NeonEmitter.cpp | Explore in Territory

//===- NeonEmitter.cpp - Generate arm_neon.h for use with clang -*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This tablegen backend is responsible for emitting arm_neon.h, which includes
// a declaration and definition of each function specified by the ARM NEON
// compiler interface.  See ARM document DUI0348B.
//
// Each NEON instruction is implemented in terms of 1 or more functions which
// are suffixed with the element type of the input vectors.  Functions may be
// implemented in terms of generic vector operations such as +, *, -, etc. or
// by calling a __builtin_-prefixed function which will be handled by clang's
// CodeGen library.
//
// Additional validation code can be generated by this file when runHeader() is
// called, rather than the normal run() entry point.
//
// See also the documentation in include/clang/Basic/arm_neon.td.
//
//===----------------------------------------------------------------------===//

#include "TableGenBackends.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/AArch64ImmCheck.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/SetTheory.h"
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cstddef>
#include <cstdint>
#include <deque>
#include <map>
#include <optional>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>

usingnamespacellvm;

namespace {

// While globals are generally bad, this one allows us to perform assertions
// liberally and somehow still trace them back to the def they indirectly
// came from.
static const Record *CurrentRecord = …;
static void assert_with_loc(bool Assertion, const std::string &Str) { … }

enum ClassKind { … };

/// NeonTypeFlags - Flags to identify the types for overloaded Neon
/// builtins.  These must be kept in sync with the flags in
/// include/clang/Basic/TargetBuiltins.h.
namespace NeonTypeFlags {

enum { … };

enum EltType { … };

} // end namespace NeonTypeFlags

class NeonEmitter;

//===----------------------------------------------------------------------===//
// TypeSpec
//===----------------------------------------------------------------------===//

/// A TypeSpec is just a simple wrapper around a string, but gets its own type
/// for strong typing purposes.
///
/// A TypeSpec can be used to create a type.
class TypeSpec : public std::string { … };

//===----------------------------------------------------------------------===//
// Type
//===----------------------------------------------------------------------===//

/// A Type. Not much more to say here.
class Type { … };

//===----------------------------------------------------------------------===//
// Variable
//===----------------------------------------------------------------------===//

/// A variable is a simple class that just has a type and a name.
class Variable { … };

//===----------------------------------------------------------------------===//
// Intrinsic
//===----------------------------------------------------------------------===//

/// The main grunt class. This represents an instantiation of an intrinsic with
/// a particular typespec and prototype.
class Intrinsic { … };

//===----------------------------------------------------------------------===//
// NeonEmitter
//===----------------------------------------------------------------------===//

class NeonEmitter { … };

} // end anonymous namespace

//===----------------------------------------------------------------------===//
// Type implementation
//===----------------------------------------------------------------------===//

std::string Type::str() const { … }

std::string Type::builtin_str() const { … }

unsigned Type::getNeonEnum() const { … }

Type Type::fromTypedefName(StringRef Name) { … }

void Type::applyTypespec(bool &Quad) { … }

void Type::applyModifiers(StringRef Mods) { … }

//===----------------------------------------------------------------------===//
// Intrinsic implementation
//===----------------------------------------------------------------------===//

StringRef Intrinsic::getNextModifiers(StringRef Proto, unsigned &Pos) const { … }

std::string Intrinsic::getInstTypeCode(Type T, ClassKind CK) const { … }

std::string Intrinsic::getBuiltinTypeStr() { … }

std::string Intrinsic::getMangledName(bool ForceClassS) const { … }

std::string Intrinsic::mangleName(std::string Name, ClassKind LocalCK) const { … }

std::string Intrinsic::replaceParamsIn(std::string S) { … }

void Intrinsic::initVariables() { … }

void Intrinsic::emitPrototype(StringRef NamePrefix) { … }

void Intrinsic::emitOpeningBrace() { … }

void Intrinsic::emitClosingBrace() { … }

void Intrinsic::emitNewLine() { … }

void Intrinsic::emitReverseVariable(Variable &Dest, Variable &Src) { … }

void Intrinsic::emitArgumentReversal() { … }

void Intrinsic::emitReturnVarDecl() { … }

void Intrinsic::emitReturnReversal() { … }

void Intrinsic::emitShadowedArgs() { … }

bool Intrinsic::protoHasScalar() const { … }

void Intrinsic::emitBodyAsBuiltinCall() { … }

void Intrinsic::emitBody(StringRef CallPrefix) { … }

void Intrinsic::emitReturn() { … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDag(DagInit *DI) { … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagOp(DagInit *DI) { … }

std::pair<Type, std::string>
Intrinsic::DagEmitter::emitDagCall(DagInit *DI, bool MatchMangledName) { … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagCast(DagInit *DI,
                                                                bool IsBitCast){ … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagShuffle(DagInit *DI){ … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagDup(DagInit *DI) { … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagDupTyped(DagInit *DI) { … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagSplat(DagInit *DI) { … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagSaveTemp(DagInit *DI) { … }

std::pair<Type, std::string>
Intrinsic::DagEmitter::emitDagNameReplace(DagInit *DI) { … }

std::pair<Type, std::string> Intrinsic::DagEmitter::emitDagLiteral(DagInit *DI){ … }

std::pair<Type, std::string>
Intrinsic::DagEmitter::emitDagArg(Init *Arg, std::string ArgName) { … }

std::string Intrinsic::generate() { … }

void Intrinsic::generateImpl(bool ReverseArguments,
                             StringRef NamePrefix, StringRef CallPrefix) { … }

void Intrinsic::indexBody() { … }

//===----------------------------------------------------------------------===//
// NeonEmitter implementation
//===----------------------------------------------------------------------===//

Intrinsic &NeonEmitter::getIntrinsic(StringRef Name, ArrayRef<Type> Types,
                                     std::optional<std::string> MangledName) { … }

void NeonEmitter::createIntrinsic(const Record *R,
                                  SmallVectorImpl<Intrinsic *> &Out) { … }

/// genBuiltinsDef: Generate the BuiltinsARM.def and  BuiltinsAArch64.def
/// declaration of builtins, checking for unique builtin declarations.
void NeonEmitter::genBuiltinsDef(raw_ostream &OS,
                                 SmallVectorImpl<Intrinsic *> &Defs) { … }

void NeonEmitter::genStreamingSVECompatibleList(
    raw_ostream &OS, SmallVectorImpl<Intrinsic *> &Defs) { … }

/// Generate the ARM and AArch64 overloaded type checking code for
/// SemaChecking.cpp, checking for unique builtin declarations.
void NeonEmitter::genOverloadTypeCheckCode(raw_ostream &OS,
                                           SmallVectorImpl<Intrinsic *> &Defs) { … }

inline bool
NeonEmitter::areRangeChecksCompatible(const ArrayRef<ImmCheck> ChecksA,
                                      const ArrayRef<ImmCheck> ChecksB) { … }

void NeonEmitter::genIntrinsicRangeCheckCode(
    raw_ostream &OS, SmallVectorImpl<Intrinsic *> &Defs) { … }

/// runHeader - Emit a file with sections defining:
/// 1. the NEON section of BuiltinsARM.def and BuiltinsAArch64.def.
/// 2. the SemaChecking code for the type overload checking.
/// 3. the SemaChecking code for validation of intrinsic immediate arguments.
void NeonEmitter::runHeader(raw_ostream &OS) { … }

static void emitNeonTypeDefs(const std::string& types, raw_ostream &OS) { … }

/// run - Read the records in arm_neon.td and output arm_neon.h.  arm_neon.h
/// is comprised of type definitions and function declarations.
void NeonEmitter::run(raw_ostream &OS) { … }

/// run - Read the records in arm_fp16.td and output arm_fp16.h.  arm_fp16.h
/// is comprised of type definitions and function declarations.
void NeonEmitter::runFP16(raw_ostream &OS) { … }

void NeonEmitter::runVectorTypes(raw_ostream &OS) { … }

void NeonEmitter::runBF16(raw_ostream &OS) { … }

void clang::EmitNeon(const RecordKeeper &Records, raw_ostream &OS) { … }

void clang::EmitFP16(const RecordKeeper &Records, raw_ostream &OS) { … }

void clang::EmitBF16(const RecordKeeper &Records, raw_ostream &OS) { … }

void clang::EmitNeonSema(const RecordKeeper &Records, raw_ostream &OS) { … }

void clang::EmitVectorTypes(const RecordKeeper &Records, raw_ostream &OS) { … }

void clang::EmitNeonTest(const RecordKeeper &Records, raw_ostream &OS) { … }
llvm/clang/utils/TableGen/NeonEmitter.cpp
