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,
                                          const RecVec &Opcodes) { … }

void PredicateExpander::expandCheckPseudo(raw_ostream &OS,
                                          const RecVec &Opcodes) { … }

void PredicateExpander::expandPredicateSequence(raw_ostream &OS,
                                                const RecVec &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,
                                                    const RecVec &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