llvm/llvm/utils/TableGen/Common/PredicateExpander.cpp

//===--------------------- PredicateExpander.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
//
//===----------------------------------------------------------------------===//
/// \file
/// Functionalities used by the Tablegen backends to expand machine predicates.
//
//===----------------------------------------------------------------------===//

#include "PredicateExpander.h"
#include "CodeGenSchedule.h" // Definition of STIPredicateFunction.
#include "llvm/TableGen/Record.h"

namespace llvm {

void PredicateExpander::expandTrue(raw_ostream &OS) {}
void PredicateExpander::expandFalse(raw_ostream &OS) {}

void PredicateExpander::expandCheckImmOperand(raw_ostream &OS, int OpIndex,
                                              int ImmVal,
                                              StringRef FunctionMapper) {}

void PredicateExpander::expandCheckImmOperand(raw_ostream &OS, int OpIndex,
                                              StringRef ImmVal,
                                              StringRef FunctionMapper) {}

void PredicateExpander::expandCheckImmOperandSimple(raw_ostream &OS,
                                                    int OpIndex,
                                                    StringRef FunctionMapper) {}

void PredicateExpander::expandCheckImmOperandLT(raw_ostream &OS, int OpIndex,
                                                int ImmVal,
                                                StringRef FunctionMapper) {}

void PredicateExpander::expandCheckImmOperandGT(raw_ostream &OS, int OpIndex,
                                                int ImmVal,
                                                StringRef FunctionMapper) {}

void PredicateExpander::expandCheckRegOperand(raw_ostream &OS, int OpIndex,
                                              const Record *Reg,
                                              StringRef FunctionMapper) {}

void PredicateExpander::expandCheckRegOperandSimple(raw_ostream &OS,
                                                    int OpIndex,
                                                    StringRef FunctionMapper) {}

void PredicateExpander::expandCheckInvalidRegOperand(raw_ostream &OS,
                                                     int OpIndex) {}

void PredicateExpander::expandCheckSameRegOperand(raw_ostream &OS, int First,
                                                  int Second) {}

void PredicateExpander::expandCheckNumOperands(raw_ostream &OS, int NumOps) {}

void PredicateExpander::expandCheckOpcode(raw_ostream &OS, const Record *Inst) {}

void PredicateExpander::expandCheckOpcode(raw_ostream &OS,
                                          ArrayRef<const Record *> Opcodes) {}

void PredicateExpander::expandCheckPseudo(raw_ostream &OS,
                                          ArrayRef<const Record *> Opcodes) {}

void PredicateExpander::expandPredicateSequence(
    raw_ostream &OS, ArrayRef<const Record *> Sequence, bool IsCheckAll) {}

void PredicateExpander::expandTIIFunctionCall(raw_ostream &OS,
                                              StringRef MethodName) {}

void PredicateExpander::expandCheckIsRegOperand(raw_ostream &OS, int OpIndex) {}

void PredicateExpander::expandCheckIsVRegOperand(raw_ostream &OS, int OpIndex) {}

void PredicateExpander::expandCheckIsImmOperand(raw_ostream &OS, int OpIndex) {}

void PredicateExpander::expandCheckFunctionPredicateWithTII(
    raw_ostream &OS, StringRef MCInstFn, StringRef MachineInstrFn,
    StringRef TIIPtr) {}

void PredicateExpander::expandCheckFunctionPredicate(raw_ostream &OS,
                                                     StringRef MCInstFn,
                                                     StringRef MachineInstrFn) {}

void PredicateExpander::expandCheckNonPortable(raw_ostream &OS,
                                               StringRef Code) {}

void PredicateExpander::expandReturnStatement(raw_ostream &OS,
                                              const Record *Rec) {}

void PredicateExpander::expandOpcodeSwitchCase(raw_ostream &OS,
                                               const Record *Rec) {}

void PredicateExpander::expandOpcodeSwitchStatement(
    raw_ostream &OS, ArrayRef<const Record *> Cases, const Record *Default) {}

void PredicateExpander::expandStatement(raw_ostream &OS, const Record *Rec) {}

void PredicateExpander::expandPredicate(raw_ostream &OS, const Record *Rec) {}

void STIPredicateExpander::expandHeader(raw_ostream &OS,
                                        const STIPredicateFunction &Fn) {}

void STIPredicateExpander::expandPrologue(raw_ostream &OS,
                                          const STIPredicateFunction &Fn) {}

void STIPredicateExpander::expandOpcodeGroup(raw_ostream &OS,
                                             const OpcodeGroup &Group,
                                             bool ShouldUpdateOpcodeMask) {}

void STIPredicateExpander::expandBody(raw_ostream &OS,
                                      const STIPredicateFunction &Fn) {}

void STIPredicateExpander::expandEpilogue(raw_ostream &OS,
                                          const STIPredicateFunction &Fn) {}

void STIPredicateExpander::expandSTIPredicate(raw_ostream &OS,
                                              const STIPredicateFunction &Fn) {}

} // namespace llvm