llvm/llvm/utils/TableGen/Common/InfoByHwMode.cpp

//===--- InfoByHwMode.cpp -------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
// Classes that implement data parameterized by HW modes for instruction
// selection. Currently it is ValueTypeByHwMode (parameterized ValueType),
// and RegSizeInfoByHwMode (parameterized register/spill size and alignment
// data).
//===----------------------------------------------------------------------===//

#include "InfoByHwMode.h"
#include "CodeGenTarget.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/Record.h"
#include <string>

usingnamespacellvm;

std::string llvm::getModeName(unsigned Mode) { … }

ValueTypeByHwMode::ValueTypeByHwMode(Record *R, const CodeGenHwModes &CGH) { … }

ValueTypeByHwMode::ValueTypeByHwMode(Record *R, MVT T) : … { … }

bool ValueTypeByHwMode::operator==(const ValueTypeByHwMode &T) const { … }

bool ValueTypeByHwMode::operator<(const ValueTypeByHwMode &T) const { … }

MVT &ValueTypeByHwMode::getOrCreateTypeForMode(unsigned Mode, MVT Type) { … }

StringRef ValueTypeByHwMode::getMVTName(MVT T) { … }

void ValueTypeByHwMode::writeToStream(raw_ostream &OS) const { … }

LLVM_DUMP_METHOD
void ValueTypeByHwMode::dump() const { … }

ValueTypeByHwMode llvm::getValueTypeByHwMode(Record *Rec,
                                             const CodeGenHwModes &CGH) { … }

RegSizeInfo::RegSizeInfo(Record *R) { … }

bool RegSizeInfo::operator<(const RegSizeInfo &I) const { … }

bool RegSizeInfo::isSubClassOf(const RegSizeInfo &I) const { … }

void RegSizeInfo::writeToStream(raw_ostream &OS) const { … }

RegSizeInfoByHwMode::RegSizeInfoByHwMode(Record *R, const CodeGenHwModes &CGH) { … }

bool RegSizeInfoByHwMode::operator<(const RegSizeInfoByHwMode &I) const { … }

bool RegSizeInfoByHwMode::operator==(const RegSizeInfoByHwMode &I) const { … }

bool RegSizeInfoByHwMode::isSubClassOf(const RegSizeInfoByHwMode &I) const { … }

bool RegSizeInfoByHwMode::hasStricterSpillThan(
    const RegSizeInfoByHwMode &I) const { … }

void RegSizeInfoByHwMode::writeToStream(raw_ostream &OS) const { … }

SubRegRange::SubRegRange(Record *R) { … }

SubRegRangeByHwMode::SubRegRangeByHwMode(Record *R, const CodeGenHwModes &CGH) { … }

EncodingInfoByHwMode::EncodingInfoByHwMode(Record *R,
                                           const CodeGenHwModes &CGH) { … }

namespace llvm {
raw_ostream &operator<<(raw_ostream &OS, const ValueTypeByHwMode &T) { … }

raw_ostream &operator<<(raw_ostream &OS, const RegSizeInfo &T) { … }

raw_ostream &operator<<(raw_ostream &OS, const RegSizeInfoByHwMode &T) { … }
} // namespace llvm