llvm/llvm/lib/Target/VE/VECustomDAG.cpp

//===-- VECustomDAG.h - VE Custom DAG Nodes ------------*- 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 file defines the interfaces that VE uses to lower LLVM code into a
// selection DAG.
//
//===----------------------------------------------------------------------===//

#include "VECustomDAG.h"

#ifndef DEBUG_TYPE
#define DEBUG_TYPE …
#endif

namespace llvm {

bool isPackedVectorType(EVT SomeVT) { … }

MVT splitVectorType(MVT VT) { … }

MVT getLegalVectorType(Packing P, MVT ElemVT) { … }

Packing getTypePacking(EVT VT) { … }

bool isMaskType(EVT SomeVT) { … }

bool isMaskArithmetic(SDValue Op) { … }

/// \returns the VVP_* SDNode opcode corresponsing to \p OC.
std::optional<unsigned> getVVPOpcode(unsigned Opcode) { … }

bool maySafelyIgnoreMask(SDValue Op) { … }

bool supportsPackedMode(unsigned Opcode, EVT IdiomVT) { … }

bool isPackingSupportOpcode(unsigned Opc) { … }

bool isVVPOrVEC(unsigned Opcode) { … }

bool isVVPUnaryOp(unsigned VVPOpcode) { … }

bool isVVPBinaryOp(unsigned VVPOpcode) { … }

bool isVVPReductionOp(unsigned Opcode) { … }

// Return the AVL operand position for this VVP or VEC Op.
std::optional<int> getAVLPos(unsigned Opc) { … }

std::optional<int> getMaskPos(unsigned Opc) { … }

bool isLegalAVL(SDValue AVL) { … }

/// Node Properties {

SDValue getNodeChain(SDValue Op) { … }

SDValue getMemoryPtr(SDValue Op) { … }

std::optional<EVT> getIdiomaticVectorType(SDNode *Op) { … }

SDValue getLoadStoreStride(SDValue Op, VECustomDAG &CDAG) { … }

SDValue getGatherScatterIndex(SDValue Op) { … }

SDValue getGatherScatterScale(SDValue Op) { … }

SDValue getStoredValue(SDValue Op) { … }

SDValue getNodePassthru(SDValue Op) { … }

bool hasReductionStartParam(unsigned OPC) { … }

unsigned getScalarReductionOpcode(unsigned VVPOC, bool IsMask) { … }

/// } Node Properties

SDValue getNodeAVL(SDValue Op) { … }

SDValue getNodeMask(SDValue Op) { … }

std::pair<SDValue, bool> getAnnotatedNodeAVL(SDValue Op) { … }

SDValue VECustomDAG::getConstant(uint64_t Val, EVT VT, bool IsTarget,
                                 bool IsOpaque) const { … }

SDValue VECustomDAG::getConstantMask(Packing Packing, bool AllTrue) const { … }

SDValue VECustomDAG::getMaskBroadcast(EVT ResultVT, SDValue Scalar,
                                      SDValue AVL) const { … }

SDValue VECustomDAG::getBroadcast(EVT ResultVT, SDValue Scalar,
                                  SDValue AVL) const { … }

SDValue VECustomDAG::annotateLegalAVL(SDValue AVL) const { … }

SDValue VECustomDAG::getUnpack(EVT DestVT, SDValue Vec, PackElem Part,
                               SDValue AVL) const { … }

SDValue VECustomDAG::getPack(EVT DestVT, SDValue LoVec, SDValue HiVec,
                             SDValue AVL) const { … }

VETargetMasks VECustomDAG::getTargetSplitMask(SDValue RawMask, SDValue RawAVL,
                                              PackElem Part) const { … }

SDValue VECustomDAG::getSplitPtrOffset(SDValue Ptr, SDValue ByteStride,
                                       PackElem Part) const { … }

SDValue VECustomDAG::getSplitPtrStride(SDValue PackStride) const { … }

SDValue VECustomDAG::getGatherScatterAddress(SDValue BasePtr, SDValue Scale,
                                             SDValue Index, SDValue Mask,
                                             SDValue AVL) const { … }

SDValue VECustomDAG::getLegalReductionOpVVP(unsigned VVPOpcode, EVT ResVT,
                                            SDValue StartV, SDValue VectorV,
                                            SDValue Mask, SDValue AVL,
                                            SDNodeFlags Flags) const { … }

} // namespace llvm