lib/Target/AMDGPU/AMDGPUGenRegisterBankInfo.def

   1 //===- AMDGPUGenRegisterBankInfo.def -----------------------------*- C++ -*-==//
   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 /// This file defines all the static objects used by AMDGPURegisterBankInfo.
  10 /// \todo This should be generated by TableGen.
  11 //===----------------------------------------------------------------------===//
  12
  13 namespace llvm {
  14 namespace AMDGPU {
  15
  16 enum PartialMappingIdx {
  17   None = - 1,
  18   PM_SGPR1  = 2,
  19   PM_SGPR16 = 6,
  20   PM_SGPR32 = 7,
  21   PM_SGPR64 = 8,
  22   PM_SGPR128 = 9,
  23   PM_SGPR256 = 10,
  24   PM_SGPR512 = 11,
  25   PM_VGPR1  = 12,
  26   PM_VGPR16 = 16,
  27   PM_VGPR32 = 17,
  28   PM_VGPR64 = 18,
  29   PM_VGPR128 = 19,
  30   PM_VGPR256 = 20,
  31   PM_VGPR512 = 21,
  32   PM_SGPR96 = 22,
  33   PM_VGPR96 = 23
  34 };
  35
  36 const RegisterBankInfo::PartialMapping PartMappings[] {
  37   // StartIdx, Length, RegBank
  38   {0, 1,  SCCRegBank},
  39   {0, 1,  VCCRegBank},
  40
  41   {0, 1,  SGPRRegBank}, // SGPR begin
  42   {0, 16, SGPRRegBank},
  43   {0, 32, SGPRRegBank},
  44   {0, 64, SGPRRegBank},
  45   {0, 128, SGPRRegBank},
  46   {0, 256, SGPRRegBank},
  47   {0, 512, SGPRRegBank},
  48
  49   {0, 1,  VGPRRegBank}, // VGPR begin
  50   {0, 16, VGPRRegBank},
  51   {0, 32, VGPRRegBank},
  52   {0, 64, VGPRRegBank},
  53   {0, 128, VGPRRegBank},
  54   {0, 256, VGPRRegBank},
  55   {0, 512, VGPRRegBank},
  56   {0, 96, SGPRRegBank},
  57   {0, 96, VGPRRegBank},
  58 };
  59
  60 const RegisterBankInfo::ValueMapping ValMappings[] {
  61   // SCC
  62   {&PartMappings[0], 1},
  63
  64   // VCC
  65   {&PartMappings[1], 1},
  66
  67   // SGPRs
  68   {&PartMappings[2], 1},
  69   {nullptr, 0}, // Illegal power of 2 sizes
  70   {nullptr, 0},
  71   {nullptr, 0},
  72   {&PartMappings[3], 1},
  73   {&PartMappings[4], 1},
  74   {&PartMappings[5], 1},
  75   {&PartMappings[6], 1},
  76   {&PartMappings[7], 1},
  77   {&PartMappings[8], 1},
  78
  79     // VGPRs
  80   {&PartMappings[9], 1},
  81   {nullptr, 0},
  82   {nullptr, 0},
  83   {nullptr, 0},
  84   {&PartMappings[10], 1},
  85   {&PartMappings[11], 1},
  86   {&PartMappings[12], 1},
  87   {&PartMappings[13], 1},
  88   {&PartMappings[14], 1},
  89   {&PartMappings[15], 1},
  90   {&PartMappings[16], 1},
  91   {&PartMappings[17], 1}
  92 };
  93
  94 const RegisterBankInfo::PartialMapping SGPROnly64BreakDown[] {
  95      /*32-bit op*/ {0, 32, SGPRRegBank},
  96    /*2x32-bit op*/ {0, 32, SGPRRegBank},
  97                    {32, 32, SGPRRegBank},
  98 /*<2x32-bit> op*/  {0, 64, SGPRRegBank},
  99
 100     /*32-bit op*/  {0, 32, VGPRRegBank},
 101   /*2x32-bit op*/  {0, 32, VGPRRegBank},
 102                    {32, 32, VGPRRegBank},
 103 };
 104
 105
 106 // For some instructions which can operate 64-bit only for the scalar version.
 107 const RegisterBankInfo::ValueMapping ValMappingsSGPR64OnlyVGPR32[] {
 108   /*32-bit sgpr*/     {&SGPROnly64BreakDown[0], 1},
 109   /*2 x 32-bit sgpr*/ {&SGPROnly64BreakDown[1], 2},
 110   /*64-bit sgpr */    {&SGPROnly64BreakDown[3], 1},
 111
 112   /*32-bit vgpr*/     {&SGPROnly64BreakDown[4], 1},
 113   /*2 x 32-bit vgpr*/ {&SGPROnly64BreakDown[5], 2}
 114 };
 115
 116 enum ValueMappingIdx {
 117   SCCStartIdx = 0,
 118   SGPRStartIdx = 2,
 119   VGPRStartIdx = 12
 120 };
 121
 122 const RegisterBankInfo::ValueMapping *getValueMapping(unsigned BankID,
 123                                                       unsigned Size) {
 124   unsigned Idx;
 125   switch (Size) {
 126   case 1:
 127     if (BankID == AMDGPU::SCCRegBankID)
 128       return &ValMappings[0];
 129     if (BankID == AMDGPU::VCCRegBankID)
 130       return &ValMappings[1];
 131
 132     // 1-bit values not from a compare etc.
 133     Idx = BankID == AMDGPU::SGPRRegBankID ? PM_SGPR1 : PM_VGPR1;
 134     break;
 135   case 96:
 136     assert(BankID != AMDGPU::VCCRegBankID);
 137     Idx = BankID == AMDGPU::SGPRRegBankID ? PM_SGPR96 : PM_VGPR96;
 138     break;
 139   default:
 140     assert(BankID != AMDGPU::VCCRegBankID);
 141     Idx = BankID == AMDGPU::VGPRRegBankID ? VGPRStartIdx : SGPRStartIdx;
 142     Idx += Log2_32_Ceil(Size);
 143     break;
 144   }
 145
 146   assert(Log2_32_Ceil(Size) == Log2_32_Ceil(ValMappings[Idx].BreakDown->Length));
 147   assert(BankID == ValMappings[Idx].BreakDown->RegBank->getID());
 148
 149   return &ValMappings[Idx];
 150 }
 151
 152 const RegisterBankInfo::ValueMapping *getValueMappingSGPR64Only(unsigned BankID,
 153                                                                 unsigned Size) {
 154   if (Size != 64)
 155     return getValueMapping(BankID, Size);
 156
 157   if (BankID == AMDGPU::VGPRRegBankID)
 158     return &ValMappingsSGPR64OnlyVGPR32[4];
 159
 160   assert(BankID == AMDGPU::SGPRRegBankID);
 161   return &ValMappingsSGPR64OnlyVGPR32[2];
 162 }
 163
 164 } // End AMDGPU namespace.
 165 } // End llvm namespace.