src/gallium/drivers/radeon/AMDILEvergreenDevice.cpp

   1 //===-- AMDILEvergreenDevice.cpp - TODO: Add brief description -------===//
   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 #include "AMDILIOExpansion.h"
  14 #include "AMDILPointerManager.h"
  15
  16 using namespace llvm;
  17
  18 AMDILEvergreenDevice::AMDILEvergreenDevice(AMDILSubtarget *ST)
  19 : AMDILDevice(ST) {
  20   setCaps();
  21   std::string name = ST->getDeviceName();
  22   if (name == "cedar") {
  23     mDeviceFlag = OCL_DEVICE_CEDAR;
  24   } else if (name == "redwood") {
  25     mDeviceFlag = OCL_DEVICE_REDWOOD;
  26   } else if (name == "cypress") {
  27     mDeviceFlag = OCL_DEVICE_CYPRESS;
  28   } else {
  29     mDeviceFlag = OCL_DEVICE_JUNIPER;
  30   }
  31 }
  32
  33 AMDILEvergreenDevice::~AMDILEvergreenDevice() {
  34 }
  35
  36 size_t AMDILEvergreenDevice::getMaxLDSSize() const {
  37   if (usesHardware(AMDILDeviceInfo::LocalMem)) {
  38     return MAX_LDS_SIZE_800;
  39   } else {
  40     return 0;
  41   }
  42 }
  43 size_t AMDILEvergreenDevice::getMaxGDSSize() const {
  44   if (usesHardware(AMDILDeviceInfo::RegionMem)) {
  45     return MAX_LDS_SIZE_800;
  46   } else {
  47     return 0;
  48   }
  49 }
  50 uint32_t AMDILEvergreenDevice::getMaxNumUAVs() const {
  51   return 12;
  52 }
  53
  54 uint32_t AMDILEvergreenDevice::getResourceID(uint32_t id) const {
  55   switch(id) {
  56   default:
  57     assert(0 && "ID type passed in is unknown!");
  58     break;
  59   case CONSTANT_ID:
  60   case RAW_UAV_ID:
  61     if (mSTM->calVersion() >= CAL_VERSION_GLOBAL_RETURN_BUFFER) {
  62       return GLOBAL_RETURN_RAW_UAV_ID;
  63     } else {
  64       return DEFAULT_RAW_UAV_ID;
  65     }
  66   case GLOBAL_ID:
  67   case ARENA_UAV_ID:
  68     return DEFAULT_ARENA_UAV_ID;
  69   case LDS_ID:
  70     if (usesHardware(AMDILDeviceInfo::LocalMem)) {
  71       return DEFAULT_LDS_ID;
  72     } else {
  73       return DEFAULT_ARENA_UAV_ID;
  74     }
  75   case GDS_ID:
  76     if (usesHardware(AMDILDeviceInfo::RegionMem)) {
  77       return DEFAULT_GDS_ID;
  78     } else {
  79       return DEFAULT_ARENA_UAV_ID;
  80     }
  81   case SCRATCH_ID:
  82     if (usesHardware(AMDILDeviceInfo::PrivateMem)) {
  83       return DEFAULT_SCRATCH_ID;
  84     } else {
  85       return DEFAULT_ARENA_UAV_ID;
  86     }
  87   };
  88   return 0;
  89 }
  90
  91 size_t AMDILEvergreenDevice::getWavefrontSize() const {
  92   return AMDILDevice::WavefrontSize;
  93 }
  94
  95 uint32_t AMDILEvergreenDevice::getGeneration() const {
  96   return AMDILDeviceInfo::HD5XXX;
  97 }
  98
  99 void AMDILEvergreenDevice::setCaps() {
 100   mSWBits.set(AMDILDeviceInfo::ArenaSegment);
 101   mHWBits.set(AMDILDeviceInfo::ArenaUAV);
 102   if (mSTM->calVersion() >= CAL_VERSION_SC_140) {
 103     mHWBits.set(AMDILDeviceInfo::HW64BitDivMod);
 104     mSWBits.reset(AMDILDeviceInfo::HW64BitDivMod);
 105   }
 106   mSWBits.set(AMDILDeviceInfo::Signed24BitOps);
 107   if (mSTM->isOverride(AMDILDeviceInfo::ByteStores)) {
 108     mHWBits.set(AMDILDeviceInfo::ByteStores);
 109   }
 110   if (mSTM->isOverride(AMDILDeviceInfo::Debug)) {
 111     mSWBits.set(AMDILDeviceInfo::LocalMem);
 112     mSWBits.set(AMDILDeviceInfo::RegionMem);
 113   } else {
 114     mHWBits.set(AMDILDeviceInfo::LocalMem);
 115     mHWBits.set(AMDILDeviceInfo::RegionMem);
 116   }
 117   mHWBits.set(AMDILDeviceInfo::Images);
 118   if (mSTM->isOverride(AMDILDeviceInfo::NoAlias)) {
 119     mHWBits.set(AMDILDeviceInfo::NoAlias);
 120   }
 121   if (mSTM->calVersion() > CAL_VERSION_GLOBAL_RETURN_BUFFER) {
 122     mHWBits.set(AMDILDeviceInfo::CachedMem);
 123   }
 124   if (mSTM->isOverride(AMDILDeviceInfo::MultiUAV)) {
 125     mHWBits.set(AMDILDeviceInfo::MultiUAV);
 126   }
 127   if (mSTM->calVersion() > CAL_VERSION_SC_136) {
 128     mHWBits.set(AMDILDeviceInfo::ByteLDSOps);
 129     mSWBits.reset(AMDILDeviceInfo::ByteLDSOps);
 130     mHWBits.set(AMDILDeviceInfo::ArenaVectors);
 131   } else {
 132     mSWBits.set(AMDILDeviceInfo::ArenaVectors);
 133   }
 134   if (mSTM->calVersion() > CAL_VERSION_SC_137) {
 135     mHWBits.set(AMDILDeviceInfo::LongOps);
 136     mSWBits.reset(AMDILDeviceInfo::LongOps);
 137   }
 138   mHWBits.set(AMDILDeviceInfo::TmrReg);
 139 }
 140 FunctionPass*
 141 AMDILEvergreenDevice::getIOExpansion(
 142     TargetMachine& TM AMDIL_OPT_LEVEL_DECL) const
 143 {
 144   return new AMDILEGIOExpansion(TM AMDIL_OPT_LEVEL_VAR);
 145 }
 146
 147 AsmPrinter*
 148 AMDILEvergreenDevice::getAsmPrinter(TargetMachine& TM, MCStreamer &Streamer) const
 149 {
 150 #ifdef UPSTREAM_LLVM
 151   return new AMDILEGAsmPrinter(TM, Streamer);
 152 #else
 153   return NULL;
 154 #endif
 155 }
 156
 157 FunctionPass*
 158 AMDILEvergreenDevice::getPointerManager(
 159     TargetMachine& TM AMDIL_OPT_LEVEL_DECL) const
 160 {
 161   return new AMDILEGPointerManager(TM AMDIL_OPT_LEVEL_VAR);
 162 }
 163
 164 AMDILCypressDevice::AMDILCypressDevice(AMDILSubtarget *ST)
 165   : AMDILEvergreenDevice(ST) {
 166   setCaps();
 167 }
 168
 169 AMDILCypressDevice::~AMDILCypressDevice() {
 170 }
 171
 172 void AMDILCypressDevice::setCaps() {
 173   if (mSTM->isOverride(AMDILDeviceInfo::DoubleOps)) {
 174     mHWBits.set(AMDILDeviceInfo::DoubleOps);
 175     mHWBits.set(AMDILDeviceInfo::FMA);
 176   }
 177 }
 178
 179
 180 AMDILCedarDevice::AMDILCedarDevice(AMDILSubtarget *ST)
 181   : AMDILEvergreenDevice(ST) {
 182   setCaps();
 183 }
 184
 185 AMDILCedarDevice::~AMDILCedarDevice() {
 186 }
 187
 188 void AMDILCedarDevice::setCaps() {
 189   mSWBits.set(AMDILDeviceInfo::FMA);
 190 }
 191
 192 size_t AMDILCedarDevice::getWavefrontSize() const {
 193   return AMDILDevice::QuarterWavefrontSize;
 194 }
 195
 196 AMDILRedwoodDevice::AMDILRedwoodDevice(AMDILSubtarget *ST)
 197   : AMDILEvergreenDevice(ST) {
 198   setCaps();
 199 }
 200
 201 AMDILRedwoodDevice::~AMDILRedwoodDevice()
 202 {
 203 }
 204
 205 void AMDILRedwoodDevice::setCaps() {
 206   mSWBits.set(AMDILDeviceInfo::FMA);
 207 }
 208
 209 size_t AMDILRedwoodDevice::getWavefrontSize() const {
 210   return AMDILDevice::HalfWavefrontSize;
 211 }