llvm/llvm/utils/TableGen/Common/DAGISelMatcher.cpp

//===- DAGISelMatcher.cpp - Representation of DAG pattern matcher ---------===//
//
// 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 "DAGISelMatcher.h"
#include "CodeGenDAGPatterns.h"
#include "CodeGenInstruction.h"
#include "CodeGenRegisters.h"
#include "CodeGenTarget.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TableGen/Record.h"
usingnamespacellvm;

void Matcher::anchor() { … }

void Matcher::dump() const { … }

void Matcher::print(raw_ostream &OS, indent Indent) const { … }

void Matcher::printOne(raw_ostream &OS) const { … }

/// unlinkNode - Unlink the specified node from this chain.  If Other == this,
/// we unlink the next pointer and return it.  Otherwise we unlink Other from
/// the list and return this.
Matcher *Matcher::unlinkNode(Matcher *Other) { … }

/// canMoveBefore - Return true if this matcher is the same as Other, or if
/// we can move this matcher past all of the nodes in-between Other and this
/// node.  Other must be equal to or before this.
bool Matcher::canMoveBefore(const Matcher *Other) const { … }

/// canMoveBeforeNode - Return true if it is safe to move the current matcher
/// across the specified one.
bool Matcher::canMoveBeforeNode(const Matcher *Other) const { … }

ScopeMatcher::~ScopeMatcher() { … }

SwitchOpcodeMatcher::~SwitchOpcodeMatcher() { … }

SwitchTypeMatcher::~SwitchTypeMatcher() { … }

CheckPredicateMatcher::CheckPredicateMatcher(const TreePredicateFn &pred,
                                             ArrayRef<unsigned> Ops)
    : … { … }

TreePredicateFn CheckPredicateMatcher::getPredicate() const { … }

unsigned CheckPredicateMatcher::getNumOperands() const { … }

unsigned CheckPredicateMatcher::getOperandNo(unsigned i) const { … }

// printImpl methods.

void ScopeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void RecordMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void RecordChildMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void RecordMemRefMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CaptureGlueInputMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void MoveChildMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void MoveSiblingMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void MoveParentMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckSameMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckChildSameMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckPatternPredicateMatcher::printImpl(raw_ostream &OS,
                                             indent Indent) const { … }

void CheckPredicateMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckOpcodeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void SwitchOpcodeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckTypeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void SwitchTypeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckChildTypeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckIntegerMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckChildIntegerMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckCondCodeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckChild2CondCodeMatcher::printImpl(raw_ostream &OS,
                                           indent Indent) const { … }

void CheckValueTypeMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckComplexPatMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckAndImmMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckOrImmMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckFoldableChainNodeMatcher::printImpl(raw_ostream &OS,
                                              indent Indent) const { … }

void CheckImmAllOnesVMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void CheckImmAllZerosVMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void EmitIntegerMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void EmitStringIntegerMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void EmitRegisterMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void EmitConvertToTargetMatcher::printImpl(raw_ostream &OS,
                                           indent Indent) const { … }

void EmitMergeInputChainsMatcher::printImpl(raw_ostream &OS,
                                            indent Indent) const { … }

void EmitCopyToRegMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void EmitNodeXFormMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

void EmitNodeMatcherCommon::printImpl(raw_ostream &OS, indent Indent) const { … }

void CompleteMatchMatcher::printImpl(raw_ostream &OS, indent Indent) const { … }

bool CheckOpcodeMatcher::isEqualImpl(const Matcher *M) const { … }

bool EmitNodeMatcherCommon::isEqualImpl(const Matcher *m) const { … }

void EmitNodeMatcher::anchor() { … }

void MorphNodeToMatcher::anchor() { … }

// isContradictoryImpl Implementations.

static bool TypesAreContradictory(MVT::SimpleValueType T1,
                                  MVT::SimpleValueType T2) { … }

bool CheckOpcodeMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckTypeMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckChildTypeMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckIntegerMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckChildIntegerMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckValueTypeMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckImmAllOnesVMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckImmAllZerosVMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckCondCodeMatcher::isContradictoryImpl(const Matcher *M) const { … }

bool CheckChild2CondCodeMatcher::isContradictoryImpl(const Matcher *M) const { … }