src/gallium/drivers/radeon/AMDILEvergreenDevice.cpp

   1 //===-- AMDILEvergreenDevice.cpp - Device Info for Evergreen --------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //==-----------------------------------------------------------------------===//
   9 #include "AMDILEvergreenDevice.h"
  10 #ifdef UPSTREAM_LLVM
  11 #include "AMDILEGAsmPrinter.h"
  12 #endif
  13
  14 using namespace llvm;
  15
  16 AMDGPUEvergreenDevice::AMDGPUEvergreenDevice(AMDGPUSubtarget *ST)
  17 : AMDGPUDevice(ST) {
  18   setCaps();
  19   std::string name = ST->getDeviceName();
  20   if (name == "cedar") {
  21     mDeviceFlag = OCL_DEVICE_CEDAR;
  22   } else if (name == "redwood") {
  23     mDeviceFlag = OCL_DEVICE_REDWOOD;
  24   } else if (name == "cypress") {
  25     mDeviceFlag = OCL_DEVICE_CYPRESS;
  26   } else {
  27     mDeviceFlag = OCL_DEVICE_JUNIPER;
  28   }
  29 }
  30
  31 AMDGPUEvergreenDevice::~AMDGPUEvergreenDevice() {
  32 }
  33
  34 size_t AMDGPUEvergreenDevice::getMaxLDSSize() const {
  35   if (usesHardware(AMDGPUDeviceInfo::LocalMem)) {
  36     return MAX_LDS_SIZE_800;
  37   } else {
  38     return 0;
  39   }
  40 }
  41 size_t AMDGPUEvergreenDevice::getMaxGDSSize() const {
  42   if (usesHardware(AMDGPUDeviceInfo::RegionMem)) {
  43     return MAX_LDS_SIZE_800;
  44   } else {
  45     return 0;
  46   }
  47 }
  48 uint32_t AMDGPUEvergreenDevice::getMaxNumUAVs() const {
  49   return 12;
  50 }
  51
  52 uint32_t AMDGPUEvergreenDevice::getResourceID(uint32_t id) const {
  53   switch(id) {
  54   default:
  55     assert(0 && "ID type passed in is unknown!");
  56     break;
  57   case CONSTANT_ID:
  58   case RAW_UAV_ID:
  59     return GLOBAL_RETURN_RAW_UAV_ID;
  60   case GLOBAL_ID:
  61   case ARENA_UAV_ID:
  62     return DEFAULT_ARENA_UAV_ID;
  63   case LDS_ID:
  64     if (usesHardware(AMDGPUDeviceInfo::LocalMem)) {
  65       return DEFAULT_LDS_ID;
  66     } else {
  67       return DEFAULT_ARENA_UAV_ID;
  68     }
  69   case GDS_ID:
  70     if (usesHardware(AMDGPUDeviceInfo::RegionMem)) {
  71       return DEFAULT_GDS_ID;
  72     } else {
  73       return DEFAULT_ARENA_UAV_ID;
  74     }
  75   case SCRATCH_ID:
  76     if (usesHardware(AMDGPUDeviceInfo::PrivateMem)) {
  77       return DEFAULT_SCRATCH_ID;
  78     } else {
  79       return DEFAULT_ARENA_UAV_ID;
  80     }
  81   };
  82   return 0;
  83 }
  84
  85 size_t AMDGPUEvergreenDevice::getWavefrontSize() const {
  86   return AMDGPUDevice::WavefrontSize;
  87 }
  88
  89 uint32_t AMDGPUEvergreenDevice::getGeneration() const {
  90   return AMDGPUDeviceInfo::HD5XXX;
  91 }
  92
  93 void AMDGPUEvergreenDevice::setCaps() {
  94   mSWBits.set(AMDGPUDeviceInfo::ArenaSegment);
  95   mHWBits.set(AMDGPUDeviceInfo::ArenaUAV);
  96   mHWBits.set(AMDGPUDeviceInfo::HW64BitDivMod);
  97   mSWBits.reset(AMDGPUDeviceInfo::HW64BitDivMod);
  98   mSWBits.set(AMDGPUDeviceInfo::Signed24BitOps);
  99   if (mSTM->isOverride(AMDGPUDeviceInfo::ByteStores)) {
 100     mHWBits.set(AMDGPUDeviceInfo::ByteStores);
 101   }
 102   if (mSTM->isOverride(AMDGPUDeviceInfo::Debug)) {
 103     mSWBits.set(AMDGPUDeviceInfo::LocalMem);
 104     mSWBits.set(AMDGPUDeviceInfo::RegionMem);
 105   } else {
 106     mHWBits.set(AMDGPUDeviceInfo::LocalMem);
 107     mHWBits.set(AMDGPUDeviceInfo::RegionMem);
 108   }
 109   mHWBits.set(AMDGPUDeviceInfo::Images);
 110   if (mSTM->isOverride(AMDGPUDeviceInfo::NoAlias)) {
 111     mHWBits.set(AMDGPUDeviceInfo::NoAlias);
 112   }
 113   mHWBits.set(AMDGPUDeviceInfo::CachedMem);
 114   if (mSTM->isOverride(AMDGPUDeviceInfo::MultiUAV)) {
 115     mHWBits.set(AMDGPUDeviceInfo::MultiUAV);
 116   }
 117   mHWBits.set(AMDGPUDeviceInfo::ByteLDSOps);
 118   mSWBits.reset(AMDGPUDeviceInfo::ByteLDSOps);
 119   mHWBits.set(AMDGPUDeviceInfo::ArenaVectors);
 120   mHWBits.set(AMDGPUDeviceInfo::LongOps);
 121   mSWBits.reset(AMDGPUDeviceInfo::LongOps);
 122   mHWBits.set(AMDGPUDeviceInfo::TmrReg);
 123 }
 124
 125 AsmPrinter*
 126 AMDGPUEvergreenDevice::getAsmPrinter(TargetMachine& TM, MCStreamer &Streamer) const
 127 {
 128 #ifdef UPSTREAM_LLVM
 129   return new AMDGPUEGAsmPrinter(TM, Streamer);
 130 #else
 131   return NULL;
 132 #endif
 133 }
 134
 135 AMDGPUCypressDevice::AMDGPUCypressDevice(AMDGPUSubtarget *ST)
 136   : AMDGPUEvergreenDevice(ST) {
 137   setCaps();
 138 }
 139
 140 AMDGPUCypressDevice::~AMDGPUCypressDevice() {
 141 }
 142
 143 void AMDGPUCypressDevice::setCaps() {
 144   if (mSTM->isOverride(AMDGPUDeviceInfo::DoubleOps)) {
 145     mHWBits.set(AMDGPUDeviceInfo::DoubleOps);
 146     mHWBits.set(AMDGPUDeviceInfo::FMA);
 147   }
 148 }
 149
 150
 151 AMDGPUCedarDevice::AMDGPUCedarDevice(AMDGPUSubtarget *ST)
 152   : AMDGPUEvergreenDevice(ST) {
 153   setCaps();
 154 }
 155
 156 AMDGPUCedarDevice::~AMDGPUCedarDevice() {
 157 }
 158
 159 void AMDGPUCedarDevice::setCaps() {
 160   mSWBits.set(AMDGPUDeviceInfo::FMA);
 161 }
 162
 163 size_t AMDGPUCedarDevice::getWavefrontSize() const {
 164   return AMDGPUDevice::QuarterWavefrontSize;
 165 }
 166
 167 AMDGPURedwoodDevice::AMDGPURedwoodDevice(AMDGPUSubtarget *ST)
 168   : AMDGPUEvergreenDevice(ST) {
 169   setCaps();
 170 }
 171
 172 AMDGPURedwoodDevice::~AMDGPURedwoodDevice()
 173 {
 174 }
 175
 176 void AMDGPURedwoodDevice::setCaps() {
 177   mSWBits.set(AMDGPUDeviceInfo::FMA);
 178 }
 179
 180 size_t AMDGPURedwoodDevice::getWavefrontSize() const {
 181   return AMDGPUDevice::HalfWavefrontSize;
 182 }