llvm/llvm/lib/CodeGen/ValueTypes.cpp

//===----------- ValueTypes.cpp - Implementation of EVT methods -----------===//
//
// 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
//
//===----------------------------------------------------------------------===//

#include "llvm/CodeGen/ValueTypes.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Type.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/TypeSize.h"
#include "llvm/Support/WithColor.h"
usingnamespacellvm;

EVT EVT::changeExtendedTypeToInteger() const { … }

EVT EVT::changeExtendedVectorElementTypeToInteger() const { … }

EVT EVT::changeExtendedVectorElementType(EVT EltVT) const { … }

EVT EVT::getExtendedIntegerVT(LLVMContext &Context, unsigned BitWidth) { … }

EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT, unsigned NumElements,
                             bool IsScalable) { … }

EVT EVT::getExtendedVectorVT(LLVMContext &Context, EVT VT, ElementCount EC) { … }

bool EVT::isExtendedFloatingPoint() const { … }

bool EVT::isExtendedInteger() const { … }

bool EVT::isExtendedScalarInteger() const { … }

bool EVT::isExtendedVector() const { … }

bool EVT::isExtended16BitVector() const { … }

bool EVT::isExtended32BitVector() const { … }

bool EVT::isExtended64BitVector() const { … }

bool EVT::isExtended128BitVector() const { … }

bool EVT::isExtended256BitVector() const { … }

bool EVT::isExtended512BitVector() const { … }

bool EVT::isExtended1024BitVector() const { … }

bool EVT::isExtended2048BitVector() const { … }

bool EVT::isExtendedFixedLengthVector() const { … }

bool EVT::isExtendedScalableVector() const { … }

EVT EVT::getExtendedVectorElementType() const { … }

unsigned EVT::getExtendedVectorNumElements() const { … }

ElementCount EVT::getExtendedVectorElementCount() const { … }

TypeSize EVT::getExtendedSizeInBits() const { … }

/// getEVTString - This function returns value type as a string, e.g. "i32".
std::string EVT::getEVTString() const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void EVT::dump() const {
  print(dbgs());
  dbgs() << "\n";
}
#endif

/// getTypeForEVT - This method returns an LLVM type corresponding to the
/// specified EVT.  For integer types, this returns an unsigned type.  Note
/// that this will abort for types that cannot be represented.
Type *EVT::getTypeForEVT(LLVMContext &Context) const { … }

/// Return the value type corresponding to the specified type.
/// If HandleUnknown is true, unknown types are returned as Other, otherwise
/// they are invalid.
/// NB: This includes pointer types, which require a DataLayout to convert
/// to a concrete value type.
MVT MVT::getVT(Type *Ty, bool HandleUnknown){ … }

/// getEVT - Return the value type corresponding to the specified type.
/// If HandleUnknown is true, unknown types are returned as Other, otherwise
/// they are invalid.
/// NB: This includes pointer types, which require a DataLayout to convert
/// to a concrete value type.
EVT EVT::getEVT(Type *Ty, bool HandleUnknown){ … }

const fltSemantics &MVT::getFltSemantics() const { … }

const fltSemantics &EVT::getFltSemantics() const { … }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void MVT::dump() const {
  print(dbgs());
  dbgs() << "\n";
}
#endif

void MVT::print(raw_ostream &OS) const { … }