Patterns.cpp | Explore in Territory

//===- Patterns.cpp --------------------------------------------*- 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
//
//===----------------------------------------------------------------------===//

#include "Patterns.h"
#include "Basic/CodeGenIntrinsics.h"
#include "CXXPredicates.h"
#include "CodeExpander.h"
#include "CodeExpansions.h"
#include "Common/CodeGenInstruction.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"

namespace llvm {
namespace gi {

//===- PatternType --------------------------------------------------------===//

std::optional<PatternType> PatternType::get(ArrayRef<SMLoc> DiagLoc,
                                            const Record *R, Twine DiagCtx) { … }

PatternType PatternType::getTypeOf(StringRef OpName) { … }

StringRef PatternType::getTypeOfOpName() const { … }

const Record *PatternType::getLLTRecord() const { … }

VariadicPackTypeInfo PatternType::getVariadicPackTypeInfo() const { … }

bool PatternType::operator==(const PatternType &Other) const { … }

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

//===- Pattern ------------------------------------------------------------===//

void Pattern::dump() const { … }

const char *Pattern::getKindName() const { … }

void Pattern::printImpl(raw_ostream &OS, bool PrintName,
                        function_ref<void()> ContentPrinter) const { … }

//===- AnyOpcodePattern ---------------------------------------------------===//

void AnyOpcodePattern::print(raw_ostream &OS, bool PrintName) const { … }

//===- CXXPattern ---------------------------------------------------------===//

CXXPattern::CXXPattern(const StringInit &Code, StringRef Name)
    : … { … }

const CXXPredicateCode &
CXXPattern::expandCode(const CodeExpansions &CE, ArrayRef<SMLoc> Locs,
                       function_ref<void(raw_ostream &)> AddComment) const { … }

void CXXPattern::print(raw_ostream &OS, bool PrintName) const { … }

//===- InstructionOperand -------------------------------------------------===//

std::string InstructionOperand::describe() const { … }

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

void InstructionOperand::dump() const { … }

//===- InstructionPattern -------------------------------------------------===//

bool InstructionPattern::diagnoseAllSpecialTypes(ArrayRef<SMLoc> Loc,
                                                 Twine Msg) const { … }

void InstructionPattern::reportUnreachable(ArrayRef<SMLoc> Locs) const { … }

bool InstructionPattern::checkSemantics(ArrayRef<SMLoc> Loc) { … }

void InstructionPattern::print(raw_ostream &OS, bool PrintName) const { … }

//===- OperandTable -------------------------------------------------------===//

bool OperandTable::addPattern(InstructionPattern *P,
                              function_ref<void(StringRef)> DiagnoseRedef) { … }

void OperandTable::print(raw_ostream &OS, StringRef Name,
                         StringRef Indent) const { … }

void OperandTable::dump() const { … }

//===- MIFlagsInfo --------------------------------------------------------===//

void MIFlagsInfo::addSetFlag(const Record *R) { … }

void MIFlagsInfo::addUnsetFlag(const Record *R) { … }

void MIFlagsInfo::addCopyFlag(StringRef InstName) { … }

//===- CodeGenInstructionPattern ------------------------------------------===//

bool CodeGenInstructionPattern::is(StringRef OpcodeName) const { … }

bool CodeGenInstructionPattern::isVariadic() const { … }

bool CodeGenInstructionPattern::hasVariadicDefs() const { … }

unsigned CodeGenInstructionPattern::getNumInstDefs() const { … }

unsigned CodeGenInstructionPattern::getNumInstOperands() const { … }

MIFlagsInfo &CodeGenInstructionPattern::getOrCreateMIFlagsInfo() { … }

StringRef CodeGenInstructionPattern::getInstName() const { … }

void CodeGenInstructionPattern::printExtras(raw_ostream &OS) const { … }

//===- OperandTypeChecker -------------------------------------------------===//

bool OperandTypeChecker::check(
    InstructionPattern &P,
    std::function<bool(const PatternType &)> VerifyTypeOfOperand) { … }

void OperandTypeChecker::propagateTypes() { … }

void OperandTypeChecker::PrintSeenWithTypeIn(InstructionPattern &P,
                                             StringRef OpName,
                                             PatternType Ty) const { … }

StringRef PatFrag::getParamKindStr(ParamKind OK) { … }

//===- PatFrag -----------------------------------------------------------===//

PatFrag::PatFrag(const Record &Def) : … { … }

StringRef PatFrag::getName() const { … }

ArrayRef<SMLoc> PatFrag::getLoc() const { … }

void PatFrag::addInParam(StringRef Name, ParamKind Kind) { … }

iterator_range<PatFrag::ParamIt> PatFrag::in_params() const { … }

void PatFrag::addOutParam(StringRef Name, ParamKind Kind) { … }

iterator_range<PatFrag::ParamIt> PatFrag::out_params() const { … }

unsigned PatFrag::num_roots() const { … }

unsigned PatFrag::getParamIdx(StringRef Name) const { … }

bool PatFrag::checkSemantics() { … }

bool PatFrag::handleUnboundInParam(StringRef ParamName, StringRef ArgName,
                                   ArrayRef<SMLoc> DiagLoc) const { … }

bool PatFrag::buildOperandsTables() { … }

void PatFrag::print(raw_ostream &OS, StringRef Indent) const { … }

void PatFrag::dump() const { … }

void PatFrag::printParamsList(raw_ostream &OS, iterator_range<ParamIt> Params) { … }

void PatFrag::PrintError(Twine Msg) const { … }

ArrayRef<InstructionOperand> PatFragPattern::getApplyDefsNeeded() const { … }

//===- PatFragPattern -----------------------------------------------------===//

bool PatFragPattern::checkSemantics(ArrayRef<SMLoc> DiagLoc) { … }

bool PatFragPattern::mapInputCodeExpansions(const CodeExpansions &ParentCEs,
                                            CodeExpansions &PatFragCEs,
                                            ArrayRef<SMLoc> DiagLoc) const { … }

//===- BuiltinPattern -----------------------------------------------------===//

BuiltinPattern::BuiltinInfo BuiltinPattern::getBuiltinInfo(const Record &Def) { … }

bool BuiltinPattern::checkSemantics(ArrayRef<SMLoc> Loc) { … }

} // namespace gi
} // namespace llvm
llvm/llvm/utils/TableGen/Common/GlobalISel/Patterns.cpp
