llvm/utils/TableGen/PredicateExpander.h

   1 //===--------------------- PredicateExpander.h ----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 /// \file
   9 /// Functionalities used by the Tablegen backends to expand machine predicates.
  10 ///
  11 /// See file llvm/Target/TargetInstrPredicate.td for a full list and description
  12 /// of all the supported MCInstPredicate classes.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_UTILS_TABLEGEN_PREDICATEEXPANDER_H
  17 #define LLVM_UTILS_TABLEGEN_PREDICATEEXPANDER_H
  18
  19 #include "llvm/ADT/StringRef.h"
  20 #include <vector>
  21
  22 namespace llvm {
  23
  24 class raw_ostream;
  25 class Record;
  26
  27 class PredicateExpander {
  28   bool EmitCallsByRef;
  29   bool NegatePredicate;
  30   bool ExpandForMC;
  31   unsigned IndentLevel;
  32   StringRef TargetName;
  33
  34   PredicateExpander(const PredicateExpander &) = delete;
  35   PredicateExpander &operator=(const PredicateExpander &) = delete;
  36
  37 public:
  38   PredicateExpander(StringRef Target)
  39       : EmitCallsByRef(true), NegatePredicate(false), ExpandForMC(false),
  40         IndentLevel(1U), TargetName(Target) {}
  41   bool isByRef() const { return EmitCallsByRef; }
  42   bool shouldNegate() const { return NegatePredicate; }
  43   bool shouldExpandForMC() const { return ExpandForMC; }
  44   unsigned getIndentLevel() const { return IndentLevel; }
  45   StringRef getTargetName() const { return TargetName; }
  46
  47   void setByRef(bool Value) { EmitCallsByRef = Value; }
  48   void flipNegatePredicate() { NegatePredicate = !NegatePredicate; }
  49   void setNegatePredicate(bool Value) { NegatePredicate = Value; }
  50   void setExpandForMC(bool Value) { ExpandForMC = Value; }
  51   void setIndentLevel(unsigned Level) { IndentLevel = Level; }
  52   void increaseIndentLevel() { ++IndentLevel; }
  53   void decreaseIndentLevel() { --IndentLevel; }
  54
  55   using RecVec = std::vector<Record *>;
  56   void expandTrue(raw_ostream &OS);
  57   void expandFalse(raw_ostream &OS);
  58   void expandCheckImmOperand(raw_ostream &OS, int OpIndex, int ImmVal,
  59                              StringRef FunctionMapper);
  60   void expandCheckImmOperand(raw_ostream &OS, int OpIndex, StringRef ImmVal,
  61                              StringRef FunctionMapperer);
  62   void expandCheckImmOperandSimple(raw_ostream &OS, int OpIndex,
  63                                    StringRef FunctionMapper);
  64   void expandCheckImmOperandLT(raw_ostream &OS, int OpIndex, int ImmVal,
  65                                StringRef FunctionMapper);
  66   void expandCheckImmOperandGT(raw_ostream &OS, int OpIndex, int ImmVal,
  67                                StringRef FunctionMapper);
  68   void expandCheckRegOperand(raw_ostream &OS, int OpIndex, const Record *Reg,
  69                              StringRef FunctionMapper);
  70   void expandCheckRegOperandSimple(raw_ostream &OS, int OpIndex,
  71                                    StringRef FunctionMapper);
  72   void expandCheckSameRegOperand(raw_ostream &OS, int First, int Second);
  73   void expandCheckNumOperands(raw_ostream &OS, int NumOps);
  74   void expandCheckOpcode(raw_ostream &OS, const Record *Inst);
  75
  76   void expandCheckPseudo(raw_ostream &OS, const RecVec &Opcodes);
  77   void expandCheckOpcode(raw_ostream &OS, const RecVec &Opcodes);
  78   void expandPredicateSequence(raw_ostream &OS, const RecVec &Sequence,
  79                                bool IsCheckAll);
  80   void expandTIIFunctionCall(raw_ostream &OS, StringRef MethodName);
  81   void expandCheckIsRegOperand(raw_ostream &OS, int OpIndex);
  82   void expandCheckIsVRegOperand(raw_ostream &OS, int OpIndex);
  83   void expandCheckIsImmOperand(raw_ostream &OS, int OpIndex);
  84   void expandCheckInvalidRegOperand(raw_ostream &OS, int OpIndex);
  85   void expandCheckFunctionPredicate(raw_ostream &OS, StringRef MCInstFn,
  86                                     StringRef MachineInstrFn);
  87   void expandCheckFunctionPredicateWithTII(raw_ostream &OS, StringRef MCInstFn,
  88                                            StringRef MachineInstrFn,
  89                                            StringRef TIIPtr);
  90   void expandCheckNonPortable(raw_ostream &OS, StringRef CodeBlock);
  91   void expandPredicate(raw_ostream &OS, const Record *Rec);
  92   void expandReturnStatement(raw_ostream &OS, const Record *Rec);
  93   void expandOpcodeSwitchCase(raw_ostream &OS, const Record *Rec);
  94   void expandOpcodeSwitchStatement(raw_ostream &OS, const RecVec &Cases,
  95                                    const Record *Default);
  96   void expandStatement(raw_ostream &OS, const Record *Rec);
  97 };
  98
  99 // Forward declarations.
 100 class STIPredicateFunction;
 101 class OpcodeGroup;
 102
 103 class STIPredicateExpander : public PredicateExpander {
 104   StringRef ClassPrefix;
 105   bool ExpandDefinition;
 106
 107   STIPredicateExpander(const PredicateExpander &) = delete;
 108   STIPredicateExpander &operator=(const PredicateExpander &) = delete;
 109
 110   void expandHeader(raw_ostream &OS, const STIPredicateFunction &Fn);
 111   void expandPrologue(raw_ostream &OS, const STIPredicateFunction &Fn);
 112   void expandOpcodeGroup(raw_ostream &OS, const OpcodeGroup &Group,
 113                          bool ShouldUpdateOpcodeMask);
 114   void expandBody(raw_ostream &OS, const STIPredicateFunction &Fn);
 115   void expandEpilogue(raw_ostream &OS, const STIPredicateFunction &Fn);
 116
 117 public:
 118   STIPredicateExpander(StringRef Target)
 119       : PredicateExpander(Target), ExpandDefinition(false) {}
 120
 121   bool shouldExpandDefinition() const { return ExpandDefinition; }
 122   StringRef getClassPrefix() const { return ClassPrefix; }
 123   void setClassPrefix(StringRef S) { ClassPrefix = S; }
 124   void setExpandDefinition(bool Value) { ExpandDefinition = Value; }
 125
 126   void expandSTIPredicate(raw_ostream &OS, const STIPredicateFunction &Fn);
 127 };
 128
 129 } // namespace llvm
 130
 131 #endif