Line data    Source code

       1             : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
       2             : |*                                                                            *|
       3             : |* Target DFA Packetizer Tables                                               *|
       4             : |*                                                                            *|
       5             : |* Automatically generated file, do not edit!                                 *|
       6             : |*                                                                            *|
       7             : \*===----------------------------------------------------------------------===*/
       8             : 
       9             : namespace llvm {
      10             : 
      11             : // Input format:
      12             : #define DFA_MAX_RESTERMS        4       // maximum AND'ed resource terms
      13             : #define DFA_MAX_RESOURCES       16      // maximum resource bits in one term
      14             : 
      15             : // AMDGPUDFAStateInputTable[][2] = pairs of <Input, NextState> for all valid
      16             : //                           transitions.
      17             : // 46   states
      18             : // 9    instruction classes
      19             : // 6    resources max
      20             : // 0    combo resources
      21             : // 1    stages max
      22             : const int64_t AMDGPUDFAStateInputTable[][2] = {
      23             : {0x1, 5},       {0xf, 1},       {0x10, 4},      {0x1f, 3},      {0x20, 2},       // state 0: 0-4
      24             : {0x1, 6},       {0xf, 44},      {0x10, 27},     {0x1f, 34},     {0x20, 41},      // state 1: 5-9
      25             : {0x1, 7},       {0xf, 41},      {0x10, 28},     {0x1f, 35},      // state 2: 10-13
      26             : {0x1, 8},       {0xf, 34},      {0x10, 27},     {0x1f, 34},     {0x20, 35},      // state 3: 14-18
      27             : {0x1, 9},       {0xf, 27},      {0x1f, 27},     {0x20, 28},      // state 4: 19-22
      28             : {0xf, 6},       {0x10, 9},      {0x1f, 8},      {0x20, 7},       // state 5: 23-26
      29             : {0xf, 25},      {0x10, 10},     {0x1f, 17},     {0x20, 22},      // state 6: 27-30
      30             : {0xf, 22},      {0x10, 11},     {0x1f, 18},      // state 7: 31-33
      31             : {0xf, 17},      {0x10, 10},     {0x1f, 17},     {0x20, 18},      // state 8: 34-37
      32             : {0xf, 10},      {0x1f, 10},     {0x20, 11},      // state 9: 38-40
      33             : {0xf, 15},      {0x1f, 15},     {0x20, 12},      // state 10: 41-43
      34             : {0xf, 12},      {0x1f, 12},      // state 11: 44-45
      35             : {0xf, 13},      {0x1f, 13},      // state 12: 46-47
      36             : {0xf, 14},      {0x1f, 14},      // state 13: 48-49
      37             : {-1, -1},        // state 14: 50
      38             : {0xf, 16},      {0x1f, 16},     {0x20, 13},      // state 15: 51-53
      39             : {0x20, 14},      // state 16: 54
      40             : {0xf, 21},      {0x10, 15},     {0x1f, 21},     {0x20, 19},      // state 17: 55-58
      41             : {0xf, 19},      {0x10, 12},     {0x1f, 19},      // state 18: 59-61
      42             : {0xf, 20},      {0x10, 13},     {0x1f, 20},      // state 19: 62-64
      43             : {0xf, 14},      {0x10, 14},     {0x1f, 14},      // state 20: 65-67
      44             : {0xf, 16},      {0x10, 16},     {0x1f, 16},     {0x20, 20},      // state 21: 68-71
      45             : {0xf, 23},      {0x10, 12},     {0x1f, 19},      // state 22: 72-74
      46             : {0xf, 24},      {0x10, 13},     {0x1f, 20},      // state 23: 75-77
      47             : {0x10, 14},     {0x1f, 14},      // state 24: 78-79
      48             : {0xf, 26},      {0x10, 15},     {0x1f, 21},     {0x20, 23},      // state 25: 80-83
      49             : {0x10, 16},     {0x1f, 16},     {0x20, 24},      // state 26: 84-86
      50             : {0x1, 10},      {0xf, 32},      {0x1f, 32},     {0x20, 29},      // state 27: 87-90
      51             : {0x1, 11},      {0xf, 29},      {0x1f, 29},      // state 28: 91-93
      52             : {0x1, 12},      {0xf, 30},      {0x1f, 30},      // state 29: 94-96
      53             : {0x1, 13},      {0xf, 31},      {0x1f, 31},      // state 30: 97-99
      54             : {0x1, 14},      {0xf, 14},      {0x1f, 14},      // state 31: 100-102
      55             : {0x1, 15},      {0xf, 33},      {0x1f, 33},     {0x20, 30},      // state 32: 103-106
      56             : {0x1, 16},      {0xf, 16},      {0x1f, 16},     {0x20, 31},      // state 33: 107-110
      57             : {0x1, 17},      {0xf, 39},      {0x10, 32},     {0x1f, 39},     {0x20, 36},      // state 34: 111-115
      58             : {0x1, 18},      {0xf, 36},      {0x10, 29},     {0x1f, 36},      // state 35: 116-119
      59             : {0x1, 19},      {0xf, 37},      {0x10, 30},     {0x1f, 37},      // state 36: 120-123
      60             : {0x1, 20},      {0xf, 38},      {0x10, 31},     {0x1f, 38},      // state 37: 124-127
      61             : {0x1, 14},      {0xf, 14},      {0x10, 14},     {0x1f, 14},      // state 38: 128-131
      62             : {0x1, 21},      {0xf, 40},      {0x10, 33},     {0x1f, 40},     {0x20, 37},      // state 39: 132-136
      63             : {0x1, 16},      {0xf, 16},      {0x10, 16},     {0x1f, 16},     {0x20, 38},      // state 40: 137-141
      64             : {0x1, 22},      {0xf, 42},      {0x10, 29},     {0x1f, 36},      // state 41: 142-145
      65             : {0x1, 23},      {0xf, 43},      {0x10, 30},     {0x1f, 37},      // state 42: 146-149
      66             : {0x1, 24},      {0xf, 24},      {0x10, 31},     {0x1f, 38},      // state 43: 150-153
      67             : {0x1, 25},      {0xf, 45},      {0x10, 32},     {0x1f, 39},     {0x20, 42},      // state 44: 154-158
      68             : {0x1, 26},      {0xf, 26},      {0x10, 33},     {0x1f, 40},     {0x20, 43},      // state 45: 159-163
      69             : {-1, -1}         // state 46: 164
      70             : };
      71             : 
      72             : // AMDGPUDFAStateEntryTable[i] = Index of the first entry in DFAStateInputTable for
      73             : //                         the ith state.
      74             : // 46 states
      75             : const unsigned int AMDGPUDFAStateEntryTable[] = {
      76             : 0, 5, 10, 14, 19, 23, 27, 31, 34, 38,    // states 0:9
      77             : 41, 44, 46, 48, 50, 51, 54, 55, 59, 62,    // states 10:19
      78             : 65, 68, 72, 75, 78, 80, 84, 87, 91, 94,    // states 20:29
      79             : 97, 100, 103, 107, 111, 116, 120, 124, 128, 132,    // states 30:39
      80             : 137, 142, 146, 150, 154, 159, 164,    // states 40:46
      81             : };
      82             : } // namespace
      83             : 
      84             : #include "llvm/CodeGen/DFAPacketizer.h"
      85             : namespace llvm {
      86        2231 : DFAPacketizer *AMDGPUGenSubtargetInfo::createDFAPacketizer(const InstrItineraryData *IID) const {
      87        2231 :    return new DFAPacketizer(IID, AMDGPUDFAStateInputTable, AMDGPUDFAStateEntryTable);
      88             : }
      89             : 
      90             : } // End llvm namespace