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