src/gallium/drivers/radeon/AMDIL7XXIOExpansion.cpp

   1 //===-- AMDIL7XXIOExpansion.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 // @file AMDIL7XXIOExpansion.cpp
  10 // @details Implementation of the IO Printing class for 7XX devices
  11 //
  12 #include "AMDILCompilerErrors.h"
  13 #include "AMDILCompilerWarnings.h"
  14 #include "AMDILDevices.h"
  15 #include "AMDILGlobalManager.h"
  16 #include "AMDILIOExpansion.h"
  17 #include "AMDILKernelManager.h"
  18 #include "AMDILMachineFunctionInfo.h"
  19 #include "AMDILTargetMachine.h"
  20 #include "AMDILUtilityFunctions.h"
  21 #include "llvm/CodeGen/MachineConstantPool.h"
  22 #include "llvm/CodeGen/MachineInstr.h"
  23 #include "llvm/CodeGen/MachineInstrBuilder.h"
  24 #include "llvm/DerivedTypes.h"
  25 #include "llvm/Support/DebugLoc.h"
  26 #include "llvm/Value.h"
  27
  28 using namespace llvm;
  29 AMDIL7XXIOExpansion::AMDIL7XXIOExpansion(TargetMachine &tm
  30     AMDIL_OPT_LEVEL_DECL) : AMDIL789IOExpansion(tm  AMDIL_OPT_LEVEL_VAR)
  31 {
  32 }
  33
  34 AMDIL7XXIOExpansion::~AMDIL7XXIOExpansion() {
  35 }
  36 const char *AMDIL7XXIOExpansion::getPassName() const
  37 {
  38   return "AMDIL 7XX IO Expansion Pass";
  39 }
  40
  41   void
  42 AMDIL7XXIOExpansion::expandGlobalLoad(MachineInstr *MI)
  43 {
  44   DebugLoc DL;
  45   // These instructions go before the current MI.
  46   expandLoadStartCode(MI);
  47   uint32_t ID = getPointerID(MI);
  48   mKM->setOutputInst();
  49   switch(getMemorySize(MI)) {
  50     default:
  51       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWLOAD_v4i32), AMDIL::R1011)
  52         .addReg(AMDIL::R1010)
  53         .addImm(ID);
  54       break;
  55     case 4:
  56       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWLOAD_i32), AMDIL::R1011)
  57         .addReg(AMDIL::R1010)
  58         .addImm(ID);
  59       break;
  60     case 8:
  61       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWLOAD_v2i32), AMDIL::R1011)
  62         .addReg(AMDIL::R1010)
  63         .addImm(ID);
  64       break;
  65     case 1:
  66       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1008)
  67         .addReg(AMDIL::R1010)
  68         .addImm(mMFI->addi32Literal(3));
  69       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1010)
  70         .addReg(AMDIL::R1010)
  71         .addImm(mMFI->addi32Literal(0xFFFFFFFC));
  72       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VCREATE_v4i32), AMDIL::R1008)
  73         .addReg(AMDIL::R1008);
  74       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_v4i32), AMDIL::R1008)
  75         .addReg(AMDIL::R1008)
  76         .addImm(mMFI->addi128Literal(0xFFFFFFFFULL << 32,
  77                 (0xFFFFFFFEULL | (0xFFFFFFFDULL << 32))));
  78       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::IEQ_v4i32), AMDIL::R1012)
  79         .addReg(AMDIL::R1008)
  80         .addImm(mMFI->addi32Literal(0));
  81       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_i32), AMDIL::R1008)
  82         .addReg(AMDIL::R1012)
  83         .addImm(mMFI->addi32Literal(0))
  84         .addImm(mMFI->addi32Literal(24));
  85       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_Y_i32), AMDIL::R1008)
  86         .addReg(AMDIL::R1012)
  87         .addImm(mMFI->addi32Literal(8))
  88         .addReg(AMDIL::R1008);
  89       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_Z_i32), AMDIL::R1008)
  90         .addReg(AMDIL::R1012)
  91         .addImm(mMFI->addi32Literal(16))
  92         .addReg(AMDIL::R1008);
  93       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWLOAD_i32), AMDIL::R1011)
  94         .addReg(AMDIL::R1010)
  95         .addImm(ID);
  96       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i8), AMDIL::R1011)
  97         .addReg(AMDIL::R1011)
  98         .addReg(AMDIL::R1008);
  99       break;
 100     case 2:
 101       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1008)
 102         .addReg(AMDIL::R1010)
 103         .addImm(mMFI->addi32Literal(3));
 104       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1008)
 105         .addReg(AMDIL::R1008)
 106         .addImm(mMFI->addi32Literal(1));
 107       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1010)
 108         .addReg(AMDIL::R1010)
 109         .addImm(mMFI->addi32Literal(0xFFFFFFFC));
 110       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_i32), AMDIL::R1008)
 111         .addReg(AMDIL::R1008)
 112         .addImm(mMFI->addi32Literal(16))
 113         .addImm(mMFI->addi32Literal(0));
 114       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWLOAD_i32), AMDIL::R1011)
 115         .addReg(AMDIL::R1010)
 116         .addImm(ID);
 117       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i16), AMDIL::R1011)
 118         .addReg(AMDIL::R1011)
 119         .addReg(AMDIL::R1008);
 120       break;
 121   }
 122   // These instructions go after the current MI.
 123   expandPackedData(MI);
 124   expandExtendLoad(MI);
 125   BuildMI(*mBB, MI, MI->getDebugLoc(),
 126       mTII->get(getMoveInstFromID(
 127           MI->getDesc().OpInfo[0].RegClass)))
 128     .addOperand(MI->getOperand(0))
 129     .addReg(AMDIL::R1011);
 130   MI->getOperand(0).setReg(AMDIL::R1011);
 131 }
 132
 133   void
 134 AMDIL7XXIOExpansion::expandRegionLoad(MachineInstr *MI)
 135 {
 136   bool HWRegion = mSTM->device()->usesHardware(AMDILDeviceInfo::RegionMem);
 137   if (!mSTM->device()->isSupported(AMDILDeviceInfo::RegionMem)) {
 138     mMFI->addErrorMsg(
 139         amd::CompilerErrorMessage[REGION_MEMORY_ERROR]);
 140     return;
 141   }
 142   if (!HWRegion || !isHardwareRegion(MI)) {
 143     return expandGlobalLoad(MI);
 144   }
 145   if (!mMFI->usesMem(AMDILDevice::GDS_ID)
 146       && mKM->isKernel()) {
 147     mMFI->addErrorMsg(amd::CompilerErrorMessage[MEMOP_NO_ALLOCATION]);
 148   }
 149   uint32_t gID = getPointerID(MI);
 150   assert(gID && "Found a GDS load that was incorrectly marked as zero ID!\n");
 151   if (!gID) {
 152     gID = mSTM->device()->getResourceID(AMDILDevice::GDS_ID);
 153     mMFI->addErrorMsg(amd::CompilerWarningMessage[RECOVERABLE_ERROR]);
 154   }
 155
 156   DebugLoc DL;
 157   // These instructions go before the current MI.
 158   expandLoadStartCode(MI);
 159    switch (getMemorySize(MI)) {
 160     default:
 161       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VCREATE_v4i32), AMDIL::R1010)
 162         .addReg(AMDIL::R1010);
 163       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_v4i32), AMDIL::R1010)
 164         .addReg(AMDIL::R1010)
 165         .addImm(mMFI->addi128Literal(1ULL << 32, 2ULL | (3ULL << 32)));
 166       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD), AMDIL::R1011)
 167         .addReg(AMDIL::R1010)
 168         .addImm(gID);
 169       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD_Y), AMDIL::R1011)
 170         .addReg(AMDIL::R1010)
 171         .addImm(gID);
 172       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD_Z), AMDIL::R1011)
 173         .addReg(AMDIL::R1010)
 174         .addImm(gID);
 175       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD_W), AMDIL::R1011)
 176         .addReg(AMDIL::R1010)
 177         .addImm(gID);
 178       break;
 179     case 1:
 180       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1008)
 181         .addReg(AMDIL::R1010)
 182         .addImm(mMFI->addi32Literal(3));
 183       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UMUL_i32), AMDIL::R1008)
 184         .addReg(AMDIL::R1008)
 185         .addImm(mMFI->addi32Literal(8));
 186       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1010)
 187         .addReg(AMDIL::R1010)
 188         .addImm(mMFI->addi32Literal(0xFFFFFFFC));
 189       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD), AMDIL::R1011)
 190         .addReg(AMDIL::R1010)
 191         .addImm(gID);
 192       // The instruction would normally fit in right here so everything created
 193       // after this point needs to go into the afterInst vector.
 194       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 195         .addReg(AMDIL::R1011)
 196         .addReg(AMDIL::R1008);
 197       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHL_i32), AMDIL::R1011)
 198         .addReg(AMDIL::R1011)
 199         .addImm(mMFI->addi32Literal(24));
 200       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 201         .addReg(AMDIL::R1011)
 202         .addImm(mMFI->addi32Literal(24));
 203       break;
 204     case 2:
 205       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1008)
 206         .addReg(AMDIL::R1010)
 207         .addImm(mMFI->addi32Literal(3));
 208       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UMUL_i32), AMDIL::R1008)
 209         .addReg(AMDIL::R1008)
 210         .addImm(mMFI->addi32Literal(8));
 211       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1010)
 212         .addReg(AMDIL::R1010)
 213         .addImm(mMFI->addi32Literal(0xFFFFFFFC));
 214       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD), AMDIL::R1011)
 215         .addReg(AMDIL::R1010)
 216         .addImm(gID);
 217       // The instruction would normally fit in right here so everything created
 218       // after this point needs to go into the afterInst vector.
 219       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 220         .addReg(AMDIL::R1011)
 221         .addReg(AMDIL::R1008);
 222       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHL_i32), AMDIL::R1011)
 223         .addReg(AMDIL::R1011)
 224         .addImm(mMFI->addi32Literal(16));
 225       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 226         .addReg(AMDIL::R1011)
 227         .addImm(mMFI->addi32Literal(16));
 228       break;
 229     case 4:
 230       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD), AMDIL::R1011)
 231         .addReg(AMDIL::R1010)
 232         .addImm(gID);
 233       break;
 234     case 8:
 235       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VCREATE_v2i32), AMDIL::R1010)
 236         .addReg(AMDIL::R1010);
 237       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_v4i32), AMDIL::R1010)
 238         .addReg(AMDIL::R1010)
 239         .addImm(mMFI->addi64Literal(1ULL << 32));
 240       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD), AMDIL::R1011)
 241         .addReg(AMDIL::R1010)
 242         .addImm(gID);
 243       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSLOAD_Y), AMDIL::R1011)
 244         .addReg(AMDIL::R1010)
 245         .addImm(gID);
 246       break;
 247    }
 248
 249   // These instructions go after the current MI.
 250   expandPackedData(MI);
 251   expandExtendLoad(MI);
 252   BuildMI(*mBB, MI, MI->getDebugLoc(),
 253       mTII->get(getMoveInstFromID(
 254           MI->getDesc().OpInfo[0].RegClass)))
 255     .addOperand(MI->getOperand(0))
 256     .addReg(AMDIL::R1011);
 257   MI->getOperand(0).setReg(AMDIL::R1011);
 258 }
 259   void
 260 AMDIL7XXIOExpansion::expandLocalLoad(MachineInstr *MI)
 261 {
 262   bool HWLocal = mSTM->device()->usesHardware(AMDILDeviceInfo::LocalMem);
 263   if (!HWLocal || !isHardwareLocal(MI)) {
 264     return expandGlobalLoad(MI);
 265   }
 266   if (!mMFI->usesMem(AMDILDevice::LDS_ID)
 267       && mKM->isKernel()) {
 268     mMFI->addErrorMsg(amd::CompilerErrorMessage[MEMOP_NO_ALLOCATION]);
 269   }
 270   uint32_t lID = getPointerID(MI);
 271   assert(lID && "Found a LDS load that was incorrectly marked as zero ID!\n");
 272   if (!lID) {
 273     lID = mSTM->device()->getResourceID(AMDILDevice::LDS_ID);
 274     mMFI->addErrorMsg(amd::CompilerWarningMessage[RECOVERABLE_ERROR]);
 275   }
 276   DebugLoc DL;
 277   // These instructions go before the current MI.
 278   expandLoadStartCode(MI);
 279   switch (getMemorySize(MI)) {
 280     default:
 281     case 8:
 282       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LDSLOADVEC), AMDIL::R1011)
 283         .addReg(AMDIL::R1010)
 284         .addImm(lID);
 285       break;
 286     case 4:
 287       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LDSLOAD), AMDIL::R1011)
 288         .addReg(AMDIL::R1010)
 289         .addImm(lID);
 290       break;
 291     case 1:
 292       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1008)
 293         .addReg(AMDIL::R1010)
 294         .addImm(mMFI->addi32Literal(3));
 295       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UMUL_i32), AMDIL::R1008)
 296         .addReg(AMDIL::R1008)
 297         .addImm(mMFI->addi32Literal(8));
 298       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1010)
 299         .addReg(AMDIL::R1010)
 300         .addImm(mMFI->addi32Literal(0xFFFFFFFC));
 301       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LDSLOAD), AMDIL::R1011)
 302         .addReg(AMDIL::R1010)
 303         .addImm(lID);
 304       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 305         .addReg(AMDIL::R1011)
 306         .addReg(AMDIL::R1008);
 307       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHL_i32), AMDIL::R1011)
 308         .addReg(AMDIL::R1011)
 309         .addImm(mMFI->addi32Literal(24));
 310       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 311         .addReg(AMDIL::R1011)
 312         .addImm(mMFI->addi32Literal(24));
 313       break;
 314     case 2:
 315       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1008)
 316         .addReg(AMDIL::R1010)
 317         .addImm(mMFI->addi32Literal(3));
 318       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UMUL_i32), AMDIL::R1008)
 319         .addReg(AMDIL::R1008)
 320         .addImm(mMFI->addi32Literal(8));
 321       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1010)
 322         .addReg(AMDIL::R1010)
 323         .addImm(mMFI->addi32Literal(0xFFFFFFFC));
 324       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LDSLOAD), AMDIL::R1011)
 325         .addReg(AMDIL::R1010)
 326         .addImm(lID);
 327       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 328         .addReg(AMDIL::R1011)
 329         .addReg(AMDIL::R1008);
 330       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHL_i32), AMDIL::R1011)
 331         .addReg(AMDIL::R1011)
 332         .addImm(mMFI->addi32Literal(16));
 333       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1011)
 334         .addReg(AMDIL::R1011)
 335         .addImm(mMFI->addi32Literal(16));
 336       break;
 337    }
 338
 339   // These instructions go after the current MI.
 340   expandPackedData(MI);
 341   expandExtendLoad(MI);
 342   BuildMI(*mBB, MI, MI->getDebugLoc(),
 343       mTII->get(getMoveInstFromID(
 344           MI->getDesc().OpInfo[0].RegClass)))
 345     .addOperand(MI->getOperand(0))
 346     .addReg(AMDIL::R1011);
 347   MI->getOperand(0).setReg(AMDIL::R1011);
 348 }
 349
 350   void
 351 AMDIL7XXIOExpansion::expandGlobalStore(MachineInstr *MI)
 352 {
 353   uint32_t ID = getPointerID(MI);
 354   mKM->setOutputInst();
 355   DebugLoc DL = MI->getDebugLoc();
 356   // These instructions go before the current MI.
 357   expandStoreSetupCode(MI);
 358   switch (getMemorySize(MI)) {
 359     default:
 360       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWSTORE_v4i32), AMDIL::MEM)
 361         .addReg(AMDIL::R1010)
 362         .addReg(AMDIL::R1011)
 363         .addImm(ID);
 364       break;
 365     case 1:
 366       mMFI->addErrorMsg(
 367           amd::CompilerErrorMessage[BYTE_STORE_ERROR]);
 368       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWSTORE_i32), AMDIL::MEM)
 369         .addReg(AMDIL::R1010)
 370         .addReg(AMDIL::R1011)
 371         .addImm(ID);
 372       break;
 373     case 2:
 374       mMFI->addErrorMsg(
 375           amd::CompilerErrorMessage[BYTE_STORE_ERROR]);
 376       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWSTORE_i32), AMDIL::MEM)
 377         .addReg(AMDIL::R1010)
 378         .addReg(AMDIL::R1011)
 379         .addImm(ID);
 380       break;
 381     case 4:
 382       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWSTORE_i32), AMDIL::MEM)
 383         .addReg(AMDIL::R1010)
 384         .addReg(AMDIL::R1011)
 385         .addImm(ID);
 386       break;
 387     case 8:
 388       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UAVRAWSTORE_v2i32), AMDIL::MEM)
 389         .addReg(AMDIL::R1010)
 390         .addReg(AMDIL::R1011)
 391         .addImm(ID);
 392       break;
 393   };
 394 }
 395
 396   void
 397 AMDIL7XXIOExpansion::expandRegionStore(MachineInstr *MI)
 398 {
 399   bool HWRegion = mSTM->device()->usesHardware(AMDILDeviceInfo::RegionMem);
 400   if (!mSTM->device()->isSupported(AMDILDeviceInfo::RegionMem)) {
 401     mMFI->addErrorMsg(
 402         amd::CompilerErrorMessage[REGION_MEMORY_ERROR]);
 403     return;
 404   }
 405   if (!HWRegion || !isHardwareRegion(MI)) {
 406     return expandGlobalStore(MI);
 407   }
 408   DebugLoc DL = MI->getDebugLoc();
 409   mKM->setOutputInst();
 410   if (!mMFI->usesMem(AMDILDevice::GDS_ID)
 411       && mKM->isKernel()) {
 412     mMFI->addErrorMsg(amd::CompilerErrorMessage[MEMOP_NO_ALLOCATION]);
 413   }
 414   uint32_t gID = getPointerID(MI);
 415   assert(gID && "Found a GDS store that was incorrectly marked as zero ID!\n");
 416   if (!gID) {
 417     gID = mSTM->device()->getResourceID(AMDILDevice::GDS_ID);
 418     mMFI->addErrorMsg(amd::CompilerWarningMessage[RECOVERABLE_ERROR]);
 419   }
 420
 421   // These instructions go before the current MI.
 422   expandStoreSetupCode(MI);
 423   switch (getMemorySize(MI)) {
 424     default:
 425       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VCREATE_v4i32), AMDIL::R1010)
 426         .addReg(AMDIL::R1010);
 427       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_v4i32), AMDIL::R1010)
 428         .addReg(AMDIL::R1010)
 429         .addImm(mMFI->addi128Literal(1ULL << 32, 2ULL | (3ULL << 32)));
 430       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE), AMDIL::R1010)
 431         .addReg(AMDIL::R1011)
 432         .addImm(gID);
 433       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE_Y), AMDIL::R1010)
 434         .addReg(AMDIL::R1011)
 435         .addImm(gID);
 436       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE_Z), AMDIL::R1010)
 437         .addReg(AMDIL::R1011)
 438         .addImm(gID);
 439       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE_W), AMDIL::R1010)
 440         .addReg(AMDIL::R1011)
 441         .addImm(gID);
 442       break;
 443     case 1:
 444       mMFI->addErrorMsg(
 445           amd::CompilerErrorMessage[BYTE_STORE_ERROR]);
 446       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1011)
 447         .addReg(AMDIL::R1011)
 448         .addImm(mMFI->addi32Literal(0xFF));
 449       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1012)
 450         .addReg(AMDIL::R1010)
 451         .addImm(mMFI->addi32Literal(3));
 452       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VCREATE_v4i32), AMDIL::R1008)
 453         .addReg(AMDIL::R1008);
 454       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_v4i32), AMDIL::R1008)
 455         .addReg(AMDIL::R1008)
 456         .addImm(mMFI->addi128Literal(0xFFFFFFFFULL << 32,
 457               (0xFFFFFFFEULL | (0xFFFFFFFDULL << 32))));
 458       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::UMUL_i32), AMDIL::R1006)
 459         .addReg(AMDIL::R1008)
 460         .addImm(mMFI->addi32Literal(8));
 461       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_i32), AMDIL::R1007)
 462         .addReg(AMDIL::R1008)
 463         .addImm(mMFI->addi32Literal(0xFFFFFF00))
 464         .addImm(mMFI->addi32Literal(0x00FFFFFF));
 465       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_Y_i32), AMDIL::R1007)
 466         .addReg(AMDIL::R1008)
 467         .addReg(AMDIL::R1007)
 468         .addImm(mMFI->addi32Literal(0xFF00FFFF));
 469       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_Z_i32), AMDIL::R1012)
 470         .addReg(AMDIL::R1008)
 471         .addReg(AMDIL::R1007)
 472         .addImm(mMFI->addi32Literal(0xFFFF00FF));
 473       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHL_i32), AMDIL::R1011)
 474         .addReg(AMDIL::R1011)
 475         .addReg(AMDIL::R1007);
 476        BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE), AMDIL::R1010)
 477         .addReg(AMDIL::R1011)
 478         .addImm(gID);
 479        break;
 480     case 2:
 481       mMFI->addErrorMsg(
 482           amd::CompilerErrorMessage[BYTE_STORE_ERROR]);
 483       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1011)
 484         .addReg(AMDIL::R1011)
 485         .addImm(mMFI->addi32Literal(0x0000FFFF));
 486       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::BINARY_AND_i32), AMDIL::R1008)
 487         .addReg(AMDIL::R1010)
 488         .addImm(mMFI->addi32Literal(3));
 489       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHR_i32), AMDIL::R1008)
 490         .addReg(AMDIL::R1008)
 491         .addImm(mMFI->addi32Literal(1));
 492       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_i32), AMDIL::R1012)
 493         .addReg(AMDIL::R1008)
 494         .addImm(mMFI->addi32Literal(0x0000FFFF))
 495         .addImm(mMFI->addi32Literal(0xFFFF0000));
 496       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::CMOVLOG_i32), AMDIL::R1008)
 497         .addReg(AMDIL::R1008)
 498         .addImm(mMFI->addi32Literal(16))
 499         .addImm(mMFI->addi32Literal(0));
 500       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHL_i32), AMDIL::R1011)
 501         .addReg(AMDIL::R1011)
 502         .addReg(AMDIL::R1008);
 503        BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE), AMDIL::R1010)
 504         .addReg(AMDIL::R1011)
 505         .addImm(gID);
 506        break;
 507     case 4:
 508        BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE), AMDIL::R1010)
 509         .addReg(AMDIL::R1011)
 510         .addImm(gID);
 511       break;
 512     case 8:
 513       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VCREATE_v2i32), AMDIL::R1010)
 514         .addReg(AMDIL::R1010);
 515       BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_v4i32), AMDIL::R1010)
 516         .addReg(AMDIL::R1010)
 517         .addImm(mMFI->addi64Literal(1ULL << 32));
 518        BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE), AMDIL::R1010)
 519         .addReg(AMDIL::R1011)
 520         .addImm(gID);
 521        BuildMI(*mBB, MI, DL, mTII->get(AMDIL::GDSSTORE_Y), AMDIL::R1010)
 522         .addReg(AMDIL::R1011)
 523         .addImm(gID);
 524       break;
 525    };
 526 }
 527
 528   void
 529 AMDIL7XXIOExpansion::expandLocalStore(MachineInstr *MI)
 530 {
 531   bool HWLocal = mSTM->device()->usesHardware(AMDILDeviceInfo::LocalMem);
 532   if (!HWLocal || !isHardwareLocal(MI)) {
 533     return expandGlobalStore(MI);
 534   }
 535   uint32_t lID = getPointerID(MI);
 536   assert(lID && "Found a LDS store that was incorrectly marked as zero ID!\n");
 537   if (!lID) {
 538     lID = mSTM->device()->getResourceID(AMDILDevice::LDS_ID);
 539     mMFI->addErrorMsg(amd::CompilerWarningMessage[RECOVERABLE_ERROR]);
 540   }
 541   DebugLoc DL = MI->getDebugLoc();
 542   // These instructions go before the current MI.
 543   expandStoreSetupCode(MI);
 544   BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LDSSTOREVEC), AMDIL::MEM)
 545     .addReg(AMDIL::R1010)
 546     .addReg(AMDIL::R1011)
 547     .addImm(lID);
 548 }