radeon/llvm: Remove AMDILModuleInfo.cpp

4 files changed, 0 insertions, 1432 deletions

diff --git a/src/gallium/drivers/radeon/AMDILMachineFunctionInfo.cpp b/src/gallium/drivers/radeon/AMDILMachineFunctionInfo.cpp
index 0061d29e7df..ec42b9c0e44 100644
--- a/src/gallium/drivers/radeon/AMDILMachineFunctionInfo.cpp
+++ b/src/gallium/drivers/radeon/AMDILMachineFunctionInfo.cpp
@@ -8,7 +8,6 @@
 //==-----------------------------------------------------------------------===//
 #include "AMDILMachineFunctionInfo.h"
 #include "AMDILCompilerErrors.h"
-#include "AMDILModuleInfo.h"
 #include "AMDILSubtarget.h"
 #include "AMDILTargetMachine.h"
 #include "AMDILUtilityFunctions.h"
@@ -84,15 +83,10 @@ AMDILMachineFunctionInfo::AMDILMachineFunctionInfo(MachineFunction& MF)
   for (uint32_t x = 0; x < AMDILDevice::MAX_IDS; ++x) {
     mUsedMem[x] = false;
   }
-  const Function *F = MF.getFunction();
   mMF = &MF;
-  MachineModuleInfo &mmi = MF.getMMI();
   const AMDILTargetMachine *TM = 
       reinterpret_cast<const AMDILTargetMachine*>(&MF.getTarget());
-  AMDILModuleInfo *AMI = &(mmi.getObjFileInfo<AMDILModuleInfo>());
-  AMI->processModule(mmi.getModule(), TM);
   mSTM = TM->getSubtargetImpl();
-  mKernel = AMI->getKernel(F->getName());
 
   mScratchSize = -1;
   mArgSize = -1;
diff --git a/src/gallium/drivers/radeon/AMDILModuleInfo.cpp b/src/gallium/drivers/radeon/AMDILModuleInfo.cpp
deleted file mode 100644
index 82c3e4ccca9..00000000000
--- a/src/gallium/drivers/radeon/AMDILModuleInfo.cpp
+++ /dev/null
@@ -1,1266 +0,0 @@
-//===-- AMDILModuleInfo.cpp - TODO: Add brief description -------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//==-----------------------------------------------------------------------===//
-#include "AMDILModuleInfo.h"
-#include "AMDILDevices.h"
-#include "AMDILKernel.h"
-#include "AMDILSubtarget.h"
-
-#include "AMDILAlgorithms.tpp"
-#include "AMDILModuleInfo.h"
-#include "AMDILDevices.h"
-#include "AMDILKernel.h"
-#include "AMDILSubtarget.h"
-#include "AMDILUtilityFunctions.h"
-#include "llvm/CodeGen/MachineConstantPool.h"
-#include "llvm/Constants.h"
-#include "llvm/DerivedTypes.h"
-#include "llvm/Instructions.h"
-#include "llvm/Support/FormattedStream.h"
-
-#include <cstdio>
-
-#define CB_BASE_OFFSET 2
-using namespace llvm;
-
-AMDILModuleInfo::AMDILModuleInfo(const MachineModuleInfo &MMI)
-{
-  mMMI = &MMI;
-  mOffset = 0;
-  mReservedBuffs = 0;
-  symTab = NULL;
-  mCurrentCPOffset = 0;
-  mPrintfOffset = 0;
-}
-
-AMDILModuleInfo::~AMDILModuleInfo() {
-  for (StringMap<AMDILKernel*>::iterator kb = mKernels.begin(), ke = mKernels.end();
-      kb != ke; ++kb) {
-    StringMapEntry<AMDILKernel*> cur = *kb;
-    AMDILKernel *ptr = cur.getValue();
-    delete ptr;
-  }
-}
-
-static const AMDILConstPtr *getConstPtr(const AMDILKernel *krnl, const std::string &arg) {
-  llvm::SmallVector<AMDILConstPtr, DEFAULT_VEC_SLOTS>::const_iterator begin, end;
-  for (begin = krnl->constPtr.begin(), end = krnl->constPtr.end();
-       begin != end; ++begin) {
-    if (!strcmp(begin->name.data(),arg.c_str())) {
-      return &(*begin);
-    }
-  }
-  return NULL;
-}
-#if 0
-static bool structContainsSub32bitType(const StructType *ST) {
-  StructType::element_iterator eib, eie;
-  for (eib = ST->element_begin(), eie = ST->element_end(); eib != eie; ++eib) {
-    Type *ptr = *eib;
-    uint32_t size = (uint32_t)GET_SCALAR_SIZE(ptr);
-    if (!size) {
-      if (const StructType *ST = dyn_cast<StructType>(ptr)) {
-        if (structContainsSub32bitType(ST)) {
-          return true;
-        }
-      }
-    } else if (size < 32) {
-      return true;
-    }
-  }
-  return false;
-}
-#endif
-
-void AMDILModuleInfo::processModule(const Module *M,
-                                       const AMDILTargetMachine *mTM)
-{
-  Module::const_global_iterator GI;
-  Module::const_global_iterator GE;
-  mSTM = mTM->getSubtargetImpl();
-  for (GI = M->global_begin(), GE = M->global_end(); GI != GE; ++GI) {
-    const GlobalValue *GV = GI;
-    llvm::StringRef GVName = GV->getName();
-    const char *name = GVName.data();
-    if (!strncmp(name, "sgv", 3)) {
-      mKernelArgs[GVName] = parseSGV(GV);
-    } else if (!strncmp(name, "fgv", 3)) {
-      // we can ignore this since we don't care about the filename
-      // string
-    } else if (!strncmp(name, "lvgv", 4)) {
-      mLocalArgs[GVName] = parseLVGV(GV);
-    } else if (!strncmp(name, "llvm.image.annotations", 22)) {
-      parseImageAnnotate(GV);
-    } else if (!strncmp(name, "llvm.global.annotations", 23)) {
-      parseGlobalAnnotate(GV);
-    } else if (!strncmp(name, "llvm.constpointer.annotations", 29)) {
-      parseConstantPtrAnnotate(GV);
-    } else if (!strncmp(name, "llvm.readonlypointer.annotations", 32)) {
-      // These are skipped as we handle them later in AMDILPointerManager.cpp
-    } else if (GV->getType()->getAddressSpace() == 3) { // *** Match cl_kernel.h local AS #
-      parseAutoArray(GV, false);
-    } else if (strstr(name, "clregion")) {
-      parseAutoArray(GV, true);
-    } else if (!GV->use_empty()
-               && mIgnoreStr.find(GVName) == mIgnoreStr.end()) {
-      parseConstantPtr(GV);
-    }
-  }
-  allocateGlobalCB();
-
-  safeForEach(M->begin(), M->end(),
-      std::bind1st(
-        std::mem_fun(&AMDILModuleInfo::checkConstPtrsUseHW),
-        this));
-}
-
-void AMDILModuleInfo::allocateGlobalCB(void) {
-  uint32_t maxCBSize = mSTM->device()->getMaxCBSize();
-  uint32_t offset = 0;
-  uint32_t curCB = 0;
-  uint32_t swoffset = 0;
-  for (StringMap<AMDILConstPtr>::iterator cpb = mConstMems.begin(),
-       cpe = mConstMems.end(); cpb != cpe; ++cpb) {
-    bool constHW = mSTM->device()->usesHardware(AMDILDeviceInfo::ConstantMem);
-    cpb->second.usesHardware = false;
-    if (constHW) {
-      // If we have a limit on the max CB Size, then we need to make sure that
-      // the constant sizes fall within the limits.
-      if (cpb->second.size <= maxCBSize) {
-        if (offset + cpb->second.size > maxCBSize) {
-          offset = 0;
-          curCB++;
-        }
-        if (curCB < mSTM->device()->getMaxNumCBs()) {
-          cpb->second.cbNum = curCB + CB_BASE_OFFSET;
-          cpb->second.offset = offset;
-          offset += (cpb->second.size + 15) & (~15);
-          cpb->second.usesHardware = true;
-          continue;
-        }
-      }
-    }
-    cpb->second.cbNum = 0;
-    cpb->second.offset = swoffset;
-    swoffset += (cpb->second.size + 15) & (~15);
-  }
-  if (!mConstMems.empty()) {
-    mReservedBuffs = curCB + 1;
-  }
-}
-
-bool AMDILModuleInfo::checkConstPtrsUseHW(llvm::Module::const_iterator *FCI)
-{
-  Function::const_arg_iterator AI, AE;
-  const Function *func = *FCI;
-  std::string name = func->getName();
-  if (!strstr(name.c_str(), "__OpenCL")
-      || !strstr(name.c_str(), "_AMDILKernel")) {
-    return false;
-  }
-  AMDILKernel *krnl = mKernels[name];
-  if (mSTM->device()->usesHardware(AMDILDeviceInfo::ConstantMem)) {
-    for (AI = func->arg_begin(), AE = func->arg_end();
-         AI != AE; ++AI) {
-      const Argument *Arg = &(*AI);
-      const PointerType *P = dyn_cast<PointerType>(Arg->getType());
-      if (!P) {
-        continue;
-      }
-      if (P->getAddressSpace() != AMDILAS::CONSTANT_ADDRESS) {
-        continue;
-      }
-      const AMDILConstPtr *ptr = getConstPtr(krnl, Arg->getName());
-      if (ptr) {
-        continue;
-      }
-      AMDILConstPtr constAttr;
-      constAttr.name = Arg->getName();
-      constAttr.size = this->mSTM->device()->getMaxCBSize();
-      constAttr.base = Arg;
-      constAttr.isArgument = true;
-      constAttr.isArray = false;
-      constAttr.offset = 0;
-      constAttr.usesHardware =
-        mSTM->device()->usesHardware(AMDILDeviceInfo::ConstantMem);
-      if (constAttr.usesHardware) {
-        constAttr.cbNum = krnl->constPtr.size() + 2;
-      } else {
-        constAttr.cbNum = 0;
-      }
-      krnl->constPtr.push_back(constAttr);
-    }
-  }
-  // Now lets make sure that only the N largest buffers
-  // get allocated in hardware if we have too many buffers
-  uint32_t numPtrs = krnl->constPtr.size();
-  if (numPtrs > (this->mSTM->device()->getMaxNumCBs() - mReservedBuffs)) {
-    // TODO: Change this routine so it sorts
-    // AMDILConstPtr instead of pulling the sizes out
-    // and then grab the N largest and disable the rest
-    llvm::SmallVector<uint32_t, 16> sizes;
-    for (uint32_t x = 0; x < numPtrs; ++x) {
-      sizes.push_back(krnl->constPtr[x].size);
-    }
-    std::sort(sizes.begin(), sizes.end());
-    uint32_t numToDisable = numPtrs - (mSTM->device()->getMaxNumCBs() -
-                                       mReservedBuffs);
-    uint32_t safeSize = sizes[numToDisable-1];
-    for (uint32_t x = 0; x < numPtrs && numToDisable; ++x) {
-      if (krnl->constPtr[x].size <= safeSize) {
-        krnl->constPtr[x].usesHardware = false;
-        --numToDisable;
-      }
-    }
-  }
-  // Renumber all of the valid CB's so that
-  // they are linear increase
-  uint32_t CBid = 2 + mReservedBuffs;
-  for (uint32_t x = 0; x < numPtrs; ++x) {
-    if (krnl->constPtr[x].usesHardware) {
-      krnl->constPtr[x].cbNum = CBid++;
-    }
-  }
-  for (StringMap<AMDILConstPtr>::iterator cpb = mConstMems.begin(),
-       cpe = mConstMems.end(); cpb != cpe; ++cpb) {
-    if (cpb->second.usesHardware) {
-      krnl->constPtr.push_back(cpb->second);
-    }
-  }
-  for (uint32_t x = 0; x < krnl->constPtr.size(); ++x) {
-    AMDILConstPtr &c = krnl->constPtr[x];
-    uint32_t cbNum = c.cbNum - CB_BASE_OFFSET;
-    if (cbNum < HW_MAX_NUM_CB && c.cbNum >= CB_BASE_OFFSET) {
-      if ((c.size + c.offset) > krnl->constSizes[cbNum]) {
-        krnl->constSizes[cbNum] =
-          ((c.size + c.offset) + 15) & ~15;
-      }
-    } else {
-      krnl->constPtr[x].usesHardware = false;
-    }
-  }
-  return false;
-}
-
-int32_t AMDILModuleInfo::getArrayOffset(const llvm::StringRef &a) const {
-  StringMap<AMDILArrayMem>::const_iterator iter = mArrayMems.find(a);
-  if (iter != mArrayMems.end()) {
-    return iter->second.offset;
-  } else {
-    return -1;
-  }
-}
-
-int32_t AMDILModuleInfo::getConstOffset(const llvm::StringRef &a) const {
-  StringMap<AMDILConstPtr>::const_iterator iter = mConstMems.find(a);
-  if (iter != mConstMems.end()) {
-    return iter->second.offset;
-  } else {
-    return -1;
-  }
-}
-
-bool AMDILModuleInfo::getConstHWBit(const llvm::StringRef &name) const {
-  StringMap<AMDILConstPtr>::const_iterator iter = mConstMems.find(name);
-  if (iter != mConstMems.end()) {
-    return iter->second.usesHardware;
-  } else {
-    return false;
-  }
-}
-
-// As of right now we only care about the required group size
-// so we can skip the variable encoding
-AMDILKernelAttr AMDILModuleInfo::parseSGV(const GlobalValue *G) {
-  AMDILKernelAttr nArg;
-  const GlobalVariable *GV = dyn_cast<GlobalVariable>(G);
-  memset(&nArg, 0, sizeof(nArg));
-  for (int x = 0; x < 3; ++x) {
-    nArg.reqGroupSize[x] = mSTM->getDefaultSize(x);
-    nArg.reqRegionSize[x] = mSTM->getDefaultSize(x);
-  }
-  if (!GV || !GV->hasInitializer()) {
-    return nArg;
-  }
-  const Constant *CV = GV->getInitializer();
-  const ConstantDataArray *CA = dyn_cast_or_null<ConstantDataArray>(CV);
-  if (!CA || !CA->isString()) {
-    return nArg;
-  }
-  std::string init = CA->getAsString();
-  size_t pos = init.find("RWG");
-  if (pos != llvm::StringRef::npos) {
-    pos += 3;
-    std::string LWS = init.substr(pos, init.length() - pos);
-    const char *lws = LWS.c_str();
-    sscanf(lws, "%u,%u,%u", &(nArg.reqGroupSize[0]),
-           &(nArg.reqGroupSize[1]),
-           &(nArg.reqGroupSize[2]));
-    nArg.mHasRWG = true;
-  }
-  pos = init.find("RWR");
-  if (pos != llvm::StringRef::npos) {
-    pos += 3;
-    std::string LWS = init.substr(pos, init.length() - pos);
-    const char *lws = LWS.c_str();
-    sscanf(lws, "%u,%u,%u", &(nArg.reqRegionSize[0]),
-           &(nArg.reqRegionSize[1]),
-           &(nArg.reqRegionSize[2]));
-    nArg.mHasRWR = true;
-  }
-  return nArg;
-}
-
-AMDILLocalArg AMDILModuleInfo::parseLVGV(const GlobalValue *G) {
-  AMDILLocalArg nArg;
-  const GlobalVariable *GV = dyn_cast<GlobalVariable>(G);
-  nArg.name = "";
-  if (!GV || !GV->hasInitializer()) {
-    return nArg;
-  }
-  const ConstantArray *CA =
-    dyn_cast_or_null<ConstantArray>(GV->getInitializer());
-  if (!CA) {
-    return nArg;
-  }
-  for (size_t x = 0, y = CA->getNumOperands(); x < y; ++x) {
-    const Value *local = CA->getOperand(x);
-    const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(local);
-    if (!CE || !CE->getNumOperands()) {
-      continue;
-    }
-    nArg.name = (*(CE->op_begin()))->getName();
-    if (mArrayMems.find(nArg.name) != mArrayMems.end()) {
-      nArg.local.push_back(&(mArrayMems[nArg.name]));
-    }
-  }
-  return nArg;
-}
-
-void AMDILModuleInfo::parseConstantPtrAnnotate(const GlobalValue *G) {
-  const GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(G);
-  const ConstantArray *CA =
-    dyn_cast_or_null<ConstantArray>(GV->getInitializer());
-  if (!CA) {
-    return;
-  }
-  uint32_t numOps = CA->getNumOperands();
-  for (uint32_t x = 0; x < numOps; ++x) {
-    const Value *V = CA->getOperand(x);
-    const ConstantStruct *CS = dyn_cast_or_null<ConstantStruct>(V);
-    if (!CS) {
-      continue;
-    }
-    assert(CS->getNumOperands() == 2 && "There can only be 2"
-           " fields, a name and size");
-    const ConstantExpr *nameField = dyn_cast<ConstantExpr>(CS->getOperand(0));
-    const ConstantInt *sizeField = dyn_cast<ConstantInt>(CS->getOperand(1));
-    assert(nameField && "There must be a constant name field");
-    assert(sizeField && "There must be a constant size field");
-    const GlobalVariable *nameGV =
-      dyn_cast<GlobalVariable>(nameField->getOperand(0));
-    const ConstantDataArray *nameArray =
-      dyn_cast<ConstantDataArray>(nameGV->getInitializer());
-    // Lets add this string to the set of strings we should ignore processing
-    mIgnoreStr.insert(nameGV->getName());
-    if (mConstMems.find(nameGV->getName())
-        != mConstMems.end()) {
-      // If we already processesd this string as a constant, lets remove it from
-      // the list of known constants.  This way we don't process unneeded data
-      // and don't generate code/metadata for strings that are never used.
-      mConstMems.erase(mConstMems.find(nameGV->getName()));
-    } else {
-      mIgnoreStr.insert(CS->getOperand(0)->getName());
-    }
-    AMDILConstPtr constAttr;
-    constAttr.name = nameArray->getAsString();
-    constAttr.size = (sizeField->getZExtValue() + 15) & ~15;
-    constAttr.base = CS;
-    constAttr.isArgument = true;
-    constAttr.isArray = false;
-    constAttr.cbNum = 0;
-    constAttr.offset = 0;
-    constAttr.usesHardware = (constAttr.size <= mSTM->device()->getMaxCBSize());
-    // Now that we have all our constant information,
-    // lets update the AMDILKernel
-    llvm::StringRef  AMDILKernelName = G->getName().data() + 30;
-    AMDILKernel *k;
-    if (mKernels.find(AMDILKernelName) != mKernels.end()) {
-      k = mKernels[AMDILKernelName];
-    } else {
-      k = new AMDILKernel;
-      k->curSize = 0;
-      k->curRSize = 0;
-      k->curHWSize = 0;
-      k->curHWRSize = 0;
-      k->constSize = 0;
-      k->lvgv = NULL;
-      k->sgv = NULL;
-      memset(k->constSizes, 0, sizeof(uint32_t) * HW_MAX_NUM_CB);
-    }
-    constAttr.cbNum = k->constPtr.size() + 2;
-    k->constPtr.push_back(constAttr);
-    mKernels[AMDILKernelName] = k;
-  }
-}
-
-void AMDILModuleInfo::parseImageAnnotate(const GlobalValue *G) {
-  const GlobalVariable *GV = dyn_cast<GlobalVariable>(G);
-  const ConstantArray *CA = dyn_cast<ConstantArray>(GV->getInitializer());
-  if (!CA) {
-    return;
-  }
-  if (isa<GlobalValue>(CA)) {
-    return;
-  }
-  uint32_t e = CA->getNumOperands();
-  if (!e) {
-    return;
-  }
-  AMDILKernel *k;
-  llvm::StringRef name = G->getName().data() + 23;
-  if (mKernels.find(name) != mKernels.end()) {
-    k = mKernels[name];
-  } else {
-    k = new AMDILKernel;
-    k->curSize = 0;
-    k->curRSize = 0;
-    k->curHWSize = 0;
-    k->curHWRSize = 0;
-    k->constSize = 0;
-    k->lvgv = NULL;
-    k->sgv = NULL;
-    memset(k->constSizes, 0, sizeof(uint32_t) * HW_MAX_NUM_CB);
-  }
-  for (uint32_t i = 0; i != e; ++i) {
-    const Value *V = CA->getOperand(i);
-    const Constant *C = dyn_cast<Constant>(V);
-    const ConstantStruct *CS = dyn_cast<ConstantStruct>(C);
-    if (CS && CS->getNumOperands() == 2) {
-      if (mConstMems.find(CS->getOperand(0)->getOperand(0)->getName()) !=
-          mConstMems.end()) {
-        // If we already processesd this string as a constant, lets remove it
-        // from the list of known constants.  This way we don't process unneeded
-        // data and don't generate code/metadata for strings that are never
-        // used.
-        mConstMems.erase(
-            mConstMems.find(CS->getOperand(0)->getOperand(0)->getName()));
-      } else {
-        mIgnoreStr.insert(CS->getOperand(0)->getOperand(0)->getName());
-      }
-      const ConstantInt *CI = dyn_cast<ConstantInt>(CS->getOperand(1));
-      uint32_t val = (uint32_t)CI->getZExtValue();
-      if (val == 1) {
-        k->readOnly.insert(i);
-      } else if (val == 2) {
-        k->writeOnly.insert(i);
-      } else {
-        assert(!"Unknown image type value!");
-      }
-    }
-  }
-  mKernels[name] = k;
-}
-
-void AMDILModuleInfo::parseAutoArray(const GlobalValue *GV, bool isRegion) {
-  const GlobalVariable *G = dyn_cast<GlobalVariable>(GV);
-  Type *Ty = (G) ? G->getType() : NULL;
-  AMDILArrayMem tmp;
-  tmp.isHW = true;
-  tmp.offset = 0;
-  tmp.vecSize = getTypeSize(Ty, true);
-  tmp.isRegion = isRegion;
-  mArrayMems[GV->getName()] = tmp;
-}
-
-void AMDILModuleInfo::parseConstantPtr(const GlobalValue *GV) {
-  const GlobalVariable *G = dyn_cast<GlobalVariable>(GV);
-  Type *Ty = (G) ? G->getType() : NULL;
-  AMDILConstPtr constAttr;
-  constAttr.name = G->getName();
-  constAttr.size = getTypeSize(Ty, true);
-  constAttr.base = GV;
-  constAttr.isArgument = false;
-  constAttr.isArray = true;
-  constAttr.offset = 0;
-  constAttr.cbNum = 0;
-  constAttr.usesHardware = false;
-  mConstMems[GV->getName()] = constAttr;
-}
-
-void AMDILModuleInfo::parseGlobalAnnotate(const GlobalValue *G) {
-  const GlobalVariable *GV = dyn_cast<GlobalVariable>(G);
-  if (!GV->hasInitializer()) {
-    return;
-  }
-  const Constant *CT = GV->getInitializer();
-  if (!CT || isa<GlobalValue>(CT)) {
-    return;
-  }
-  const ConstantArray *CA = dyn_cast<ConstantArray>(CT);
-  if (!CA) {
-    return;
-  }
-
-  unsigned int nKernels = CA->getNumOperands();
-  for (unsigned int i = 0, e = nKernels; i != e; ++i) {
-    parseKernelInformation(CA->getOperand(i));
-  }
-}
-
-void AMDILModuleInfo::parseKernelInformation(const Value *V) {
-  if (isa<GlobalValue>(V)) {
-    return;
-  }
-  const ConstantStruct *CS = dyn_cast_or_null<ConstantStruct>(V);
-  if (!CS) {
-    return;
-  }
-  uint32_t N = CS->getNumOperands();
-  if (N != 5) {
-    return;
-  }
-  AMDILKernel *tmp;
-
-  // The first operand is always a pointer to the AMDILKernel.
-  const Constant *CV = dyn_cast<Constant>(CS->getOperand(0));
-  llvm::StringRef AMDILKernelName = "";
-  if (CV->getNumOperands()) {
-    AMDILKernelName = (*(CV->op_begin()))->getName();
-  }
-
-  // If we have images, then we have already created the AMDILKernel and we just need
-  // to get the AMDILKernel information.
-  if (mKernels.find(AMDILKernelName) != mKernels.end()) {
-    tmp = mKernels[AMDILKernelName];
-  } else {
-    tmp = new AMDILKernel;
-    tmp->curSize = 0;
-    tmp->curRSize = 0;
-    tmp->curHWSize = 0;
-    tmp->curHWRSize = 0;
-    tmp->constSize = 0;
-    tmp->lvgv = NULL;
-    tmp->sgv = NULL;
-    memset(tmp->constSizes, 0, sizeof(uint32_t) * HW_MAX_NUM_CB);
-  }
-
-
-  // The second operand is SGV, there can only be one so we don't need to worry
-  // about parsing out multiple data points.
-  CV = dyn_cast<Constant>(CS->getOperand(1));
-
-  llvm::StringRef sgvName;
-  if (CV->getNumOperands()) {
-    sgvName = (*(CV->op_begin()))->getName();
-  }
-
-  if (mKernelArgs.find(sgvName) != mKernelArgs.end()) {
-    tmp->sgv = &mKernelArgs[sgvName];
-  }
-  // The third operand is FGV, which is skipped
-  // The fourth operand is LVGV
-  // There can be multiple local arrays, so we
-  // need to handle each one seperatly
-  CV = dyn_cast<Constant>(CS->getOperand(3));
-  llvm::StringRef lvgvName = "";
-  if (CV->getNumOperands()) {
-    lvgvName = (*(CV->op_begin()))->getName();
-  }
-  if (mLocalArgs.find(lvgvName) != mLocalArgs.end()) {
-    AMDILLocalArg *ptr = &mLocalArgs[lvgvName];
-    tmp->lvgv = ptr;
-    llvm::SmallVector<AMDILArrayMem *, DEFAULT_VEC_SLOTS>::iterator ib, ie;
-    for (ib = ptr->local.begin(), ie = ptr->local.end(); ib != ie; ++ib) {
-      if ((*ib)->isRegion) {
-        if ((*ib)->isHW) {
-          (*ib)->offset = tmp->curHWRSize;
-          tmp->curHWRSize += ((*ib)->vecSize + 15) & ~15;
-        } else {
-          (*ib)->offset = tmp->curRSize;
-          tmp->curRSize += ((*ib)->vecSize + 15) & ~15;
-        }
-      } else {
-        if ((*ib)->isHW) {
-          (*ib)->offset = tmp->curHWSize;
-          tmp->curHWSize += ((*ib)->vecSize + 15) & ~15;
-        } else {
-          (*ib)->offset = tmp->curSize;
-          tmp->curSize += ((*ib)->vecSize + 15) & ~15;
-        }
-      }
-    }
-  }
-
-  // The fifth operand is NULL
-  mKernels[AMDILKernelName] = tmp;
-}
-
-AMDILKernel *
-AMDILModuleInfo::getKernel(const llvm::StringRef &name) {
-  StringMap<AMDILKernel*>::iterator iter = mKernels.find(name);
-  if (iter == mKernels.end()) {
-      return NULL; 
-  } else {
-    return iter->second;
-  }
-}
-
-bool AMDILModuleInfo::isKernel(const llvm::StringRef &name) const {
-  return (mKernels.find(name) != mKernels.end());
-}
-
-bool AMDILModuleInfo::isWriteOnlyImage(const llvm::StringRef &name,
-                                          uint32_t iID) const {
-  const StringMap<AMDILKernel*>::const_iterator kiter = mKernels.find(name);
-  if (kiter == mKernels.end()) {
-    return false;
-  }
-  return kiter->second->writeOnly.count(iID);
-}
-#if 0
-uint32_t
-AMDILModuleInfo::getNumWriteImages(const llvm::StringRef &name) const {
-  char *env = NULL;
-  env = getenv("GPU_DISABLE_RAW_UAV");
-  if (env && env[0] == '1') {
-    return 8;
-  }
-  const StringMap<AMDILKernel*>::const_iterator kiter = mKernels.find(name);
-  if (kiter == mKernels.end()) {
-    return 0;
-  } else {
-    return kiter->second->writeOnly.size();
-  }
-}
-#endif
-bool AMDILModuleInfo::isReadOnlyImage(const llvm::StringRef &name,
-                                         uint32_t iID) const {
-  const StringMap<AMDILKernel*>::const_iterator kiter = mKernels.find(name);
-  if (kiter == mKernels.end()) {
-    return false;
-  }
-  return kiter->second->readOnly.count(iID);
-}
-#if 0
-bool AMDILModuleInfo::hasRWG(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    AMDILKernelAttr *ptr = iter->second->sgv;
-    if (ptr) {
-      return ptr->mHasRWG;
-    }
-  }
-  return false;
-}
-
-bool AMDILModuleInfo::hasRWR(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    AMDILKernelAttr *ptr = iter->second->sgv;
-    if (ptr) {
-      return ptr->mHasRWR;
-    }
-  }
-  return false;
-}
-
-uint32_t
-AMDILModuleInfo::getMaxGroupSize(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    AMDILKernelAttr *sgv = iter->second->sgv;
-    if (sgv) {
-      return sgv->reqGroupSize[0] * sgv->reqGroupSize[1] * sgv->reqGroupSize[2];
-    }
-  }
-  return mSTM->getDefaultSize(0) *
-         mSTM->getDefaultSize(1) *
-         mSTM->getDefaultSize(2);
-}
-
-uint32_t
-AMDILModuleInfo::getMaxRegionSize(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    AMDILKernelAttr *sgv = iter->second->sgv;
-    if (sgv) {
-      return sgv->reqRegionSize[0] *
-             sgv->reqRegionSize[1] *
-             sgv->reqRegionSize[2];
-    }
-  }
-  return mSTM->getDefaultSize(0) *
-         mSTM->getDefaultSize(1) *
-         mSTM->getDefaultSize(2);
-}
-uint32_t AMDILModuleInfo::getRegionSize(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    return iter->second->curRSize;
-  } else {
-    return 0;
-  }
-}
-
-uint32_t AMDILModuleInfo::getLocalSize(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    return iter->second->curSize;
-  } else {
-    return 0;
-  }
-}
-
-uint32_t AMDILModuleInfo::getConstSize(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    return iter->second->constSize;
-  } else {
-    return 0;
-  }
-}
-
-uint32_t
-AMDILModuleInfo::getHWRegionSize(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    return iter->second->curHWRSize;
-  } else {
-    return 0;
-  }
-}
-
-uint32_t AMDILModuleInfo::getHWLocalSize(const llvm::StringRef &name) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end()) {
-    return iter->second->curHWSize;
-  } else {
-    return 0;
-  }
-}
-#endif
-
-int32_t AMDILModuleInfo::getArgID(const Argument *arg) {
-  DenseMap<const Argument *, int32_t>::iterator argiter = mArgIDMap.find(arg);
-  if (argiter != mArgIDMap.end()) {
-    return argiter->second;
-  } else {
-    return -1;
-  }
-}
-
-
-uint32_t
-AMDILModuleInfo::getRegion(const llvm::StringRef &name, uint32_t dim) const {
-  StringMap<AMDILKernel*>::const_iterator iter = mKernels.find(name);
-  if (iter != mKernels.end() && iter->second->sgv) {
-    AMDILKernelAttr *sgv = iter->second->sgv;
-    switch (dim) {
-    default: break;
-    case 0:
-    case 1:
-    case 2:
-      return sgv->reqRegionSize[dim];
-      break;
-    case 3:
-      return sgv->reqRegionSize[0] *
-             sgv->reqRegionSize[1] *
-             sgv->reqRegionSize[2];
-    };
-  }
-  switch (dim) {
-  default:
-    return 1;
-  case 3:
-    return mSTM->getDefaultSize(0) *
-           mSTM->getDefaultSize(1) *
-           mSTM->getDefaultSize(2);
-  case 2:
-  case 1:
-  case 0:
-    return mSTM->getDefaultSize(dim);
-    break;
-  };
-  return 1;
-}
-
-StringMap<AMDILConstPtr>::iterator AMDILModuleInfo::consts_begin() {
-  return mConstMems.begin();
-}
-
-
-StringMap<AMDILConstPtr>::iterator AMDILModuleInfo::consts_end() {
-  return mConstMems.end();
-}
-
-bool AMDILModuleInfo::byteStoreExists(StringRef S) const {
-  return mByteStore.find(S) != mByteStore.end();
-}
-
-uint32_t AMDILModuleInfo::getConstPtrSize(const AMDILKernel *krnl,
-                                             const llvm::StringRef &arg)
-{
-  const AMDILConstPtr *curConst = getConstPtr(krnl, arg);
-  if (curConst) {
-    return curConst->size;
-  } else {
-    return 0;
-  }
-}
-
-uint32_t AMDILModuleInfo::getConstPtrOff(const AMDILKernel *krnl,
-                                            const llvm::StringRef &arg)
-{
-  const AMDILConstPtr *curConst = getConstPtr(krnl, arg);
-  if (curConst) {
-    return curConst->offset;
-  } else {
-    return 0;
-  }
-}
-
-uint32_t AMDILModuleInfo::getConstPtrCB(const AMDILKernel *krnl,
-                                           const llvm::StringRef &arg)
-{
-  const AMDILConstPtr *curConst = getConstPtr(krnl, arg);
-  if (curConst) {
-    return curConst->cbNum;
-  } else {
-    return 0;
-  }
-}
-
-void AMDILModuleInfo::calculateCPOffsets(const MachineFunction *MF,
-                                            AMDILKernel *krnl)
-{
-  const MachineConstantPool *MCP = MF->getConstantPool();
-  if (!MCP) {
-    return;
-  }
-  const std::vector<MachineConstantPoolEntry> consts = MCP->getConstants();
-  size_t numConsts = consts.size();
-  for (size_t x = 0; x < numConsts; ++x) {
-    krnl->CPOffsets.push_back(
-        std::make_pair<uint32_t, const Constant*>(
-          mCurrentCPOffset, consts[x].Val.ConstVal));
-    size_t curSize = getTypeSize(consts[x].Val.ConstVal->getType(), true);
-    // Align the size to the vector boundary
-    curSize = (curSize + 15) & (~15);
-    mCurrentCPOffset += curSize;
-  }
-}
-
-bool AMDILModuleInfo::isConstPtrArray(const AMDILKernel *krnl,
-                                         const llvm::StringRef &arg) {
-  const AMDILConstPtr *curConst = getConstPtr(krnl, arg);
-  if (curConst) {
-    return curConst->isArray;
-  } else {
-    return false;
-  }
-}
-
-bool AMDILModuleInfo::isConstPtrArgument(const AMDILKernel *krnl,
-                                            const llvm::StringRef &arg)
-{
-  const AMDILConstPtr *curConst = getConstPtr(krnl, arg);
-  if (curConst) {
-    return curConst->isArgument;
-  } else {
-    return false;
-  }
-}
-
-const Value *AMDILModuleInfo::getConstPtrValue(const AMDILKernel *krnl,
-                                                  const llvm::StringRef &arg) {
-  const AMDILConstPtr *curConst = getConstPtr(krnl, arg);
-  if (curConst) {
-    return curConst->base;
-  } else {
-    return NULL;
-  }
-}
-
-static void
-dumpZeroElements(StructType * const T, llvm::raw_ostream &O, bool asBytes);
-static void
-dumpZeroElements(IntegerType * const T, llvm::raw_ostream &O, bool asBytes);
-static void
-dumpZeroElements(ArrayType * const T, llvm::raw_ostream &O, bool asBytes);
-static void
-dumpZeroElements(VectorType * const T, llvm::raw_ostream &O, bool asBytes);
-static void
-dumpZeroElements(Type * const T, llvm::raw_ostream &O, bool asBytes);
-
-void dumpZeroElements(Type * const T, llvm::raw_ostream &O, bool asBytes) {
-  if (!T) {
-    return;
-  }
-  switch(T->getTypeID()) {
-  case Type::X86_FP80TyID:
-  case Type::FP128TyID:
-  case Type::PPC_FP128TyID:
-  case Type::LabelTyID:
-    assert(0 && "These types are not supported by this backend");
-  default:
-  case Type::DoubleTyID:
-    if (asBytes) {
-      O << ":0:0:0:0:0:0:0:0";
-    } else {
-      O << ":0";
-    }
-    break;
-  case Type::FloatTyID:
-  case Type::PointerTyID:
-  case Type::FunctionTyID:
-    if (asBytes) {
-      O << ":0:0:0:0";
-    } else {
-      O << ":0";
-    }
-  case Type::IntegerTyID:
-    dumpZeroElements(dyn_cast<IntegerType>(T), O, asBytes);
-    break;
-  case Type::StructTyID:
-    {
-      const StructType *ST = cast<StructType>(T);
-      if (!ST->isOpaque()) {
-        dumpZeroElements(dyn_cast<StructType>(T), O, asBytes);
-      } else { // A pre-LLVM 3.0 opaque type
-        if (asBytes) {
-          O << ":0:0:0:0";
-        } else {
-          O << ":0";
-        }
-      }
-    }
-    break;
-  case Type::ArrayTyID:
-    dumpZeroElements(dyn_cast<ArrayType>(T), O, asBytes);
-    break;
-  case Type::VectorTyID:
-    dumpZeroElements(dyn_cast<VectorType>(T), O, asBytes);
-    break;
-  };
-}
-
-void
-dumpZeroElements(StructType * const ST, llvm::raw_ostream &O, bool asBytes) {
-  if (!ST) {
-    return;
-  }
-  Type *curType;
-  StructType::element_iterator eib = ST->element_begin();
-  StructType::element_iterator eie = ST->element_end();
-  for (;eib != eie; ++eib) {
-    curType = *eib;
-    dumpZeroElements(curType, O, asBytes);
-  }
-}
-
-void
-dumpZeroElements(IntegerType * const IT, llvm::raw_ostream &O, bool asBytes) {
-  if (asBytes) {
-    unsigned byteWidth = (IT->getBitWidth() >> 3);
-    for (unsigned x = 0; x < byteWidth; ++x) {
-      O << ":0";
-    }
-  }
-}
-
-void
-dumpZeroElements(ArrayType * const AT, llvm::raw_ostream &O, bool asBytes) {
-  size_t size = AT->getNumElements();
-  for (size_t x = 0; x < size; ++x) {
-    dumpZeroElements(AT->getElementType(), O, asBytes);
-  }
-}
-
-void
-dumpZeroElements(VectorType * const VT, llvm::raw_ostream &O, bool asBytes) {
-  size_t size = VT->getNumElements();
-  for (size_t x = 0; x < size; ++x) {
-    dumpZeroElements(VT->getElementType(), O, asBytes);
-  }
-}
-
-void AMDILModuleInfo::printConstantValue(const Constant *CAval,
-                                            llvm::raw_ostream &O, bool asBytes) {
-  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CAval)) {
-    bool isDouble = &CFP->getValueAPF().getSemantics()==&APFloat::IEEEdouble;
-    if (isDouble) {
-      double val = CFP->getValueAPF().convertToDouble();
-      union dtol_union {
-        double d;
-        uint64_t l;
-        char c[8];
-      } conv;
-      conv.d = val;
-      if (!asBytes) {
-        O << ":";
-        O.write_hex(conv.l);
-      } else {
-        for (int i = 0; i < 8; ++i) {
-          O << ":";
-          O.write_hex((unsigned)conv.c[i] & 0xFF);
-        }
-      }
-    } else {
-      float val = CFP->getValueAPF().convertToFloat();
-      union ftoi_union {
-        float f;
-        uint32_t u;
-        char c[4];
-      } conv;
-      conv.f = val;
-      if (!asBytes) {
-        O << ":";
-        O.write_hex(conv.u);
-      } else {
-        for (int i = 0; i < 4; ++i) {
-          O << ":";
-          O.write_hex((unsigned)conv.c[i] & 0xFF);
-        }
-      }
-    }
-  } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(CAval)) {
-    uint64_t zVal = CI->getValue().getZExtValue();
-    if (!asBytes) {
-      O << ":";
-      O.write_hex(zVal);
-    } else {
-      switch (CI->getBitWidth()) {
-      default:
-        {
-          union ltob_union {
-            uint64_t l;
-            char c[8];
-          } conv;
-          conv.l = zVal;
-          for (int i = 0; i < 8; ++i) {
-            O << ":";
-            O.write_hex((unsigned)conv.c[i] & 0xFF);
-          }
-        }
-        break;
-      case 8:
-        O << ":";
-        O.write_hex(zVal & 0xFF);
-        break;
-      case 16:
-        {
-          union stob_union {
-            uint16_t s;
-            char c[2];
-          } conv;
-          conv.s = (uint16_t)zVal;
-          O << ":";
-          O.write_hex((unsigned)conv.c[0] & 0xFF);
-          O << ":";
-          O.write_hex((unsigned)conv.c[1] & 0xFF);
-        }
-        break;
-      case 32:
-        {
-          union itob_union {
-            uint32_t i;
-            char c[4];
-          } conv;
-          conv.i = (uint32_t)zVal;
-          for (int i = 0; i < 4; ++i) {
-            O << ":";
-            O.write_hex((unsigned)conv.c[i] & 0xFF);
-          }
-        }
-        break;
-      }
-    }
-  } else if (const ConstantVector *CV = dyn_cast<ConstantVector>(CAval)) {
-    int y = CV->getNumOperands()-1;
-    int x = 0;
-    for (; x < y; ++x) {
-      printConstantValue(CV->getOperand(x), O, asBytes);
-    }
-    printConstantValue(CV->getOperand(x), O, asBytes);
-  } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CAval)) {
-    int y = CS->getNumOperands();
-    int x = 0;
-    for (; x < y; ++x) {
-      printConstantValue(CS->getOperand(x), O, asBytes);
-    }
-  } else if (const ConstantAggregateZero *CAZ
-      = dyn_cast<ConstantAggregateZero>(CAval)) {
-    int y = CAZ->getNumOperands();
-    if (y > 0) {
-      int x = 0;
-      for (; x < y; ++x) {
-        printConstantValue((llvm::Constant *)CAZ->getOperand(x),
-            O, asBytes);
-      }
-    } else {
-      if (asBytes) {
-        dumpZeroElements(CAval->getType(), O, asBytes);
-      } else {
-        int y = getNumElements(CAval->getType())-1;
-        for (int x = 0; x < y; ++x) {
-          O << ":0";
-        }
-        O << ":0";
-      }
-    }
-  } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CAval)) {
-    int y = CA->getNumOperands();
-    int x = 0;
-    for (; x < y; ++x) {
-      printConstantValue(CA->getOperand(x), O, asBytes);
-    }
-  } else if (dyn_cast<ConstantPointerNull>(CAval)) {
-    O << ":0";
-    //assert(0 && "Hit condition which was not expected");
-  } else if (dyn_cast<ConstantExpr>(CAval)) {
-    O << ":0";
-    //assert(0 && "Hit condition which was not expected");
-  } else if (dyn_cast<UndefValue>(CAval)) {
-    O << ":0";
-    //assert(0 && "Hit condition which was not expected");
-  } else {
-    assert(0 && "Hit condition which was not expected");
-  }
-}
-#if 0
-static bool isStruct(Type * const T)
-{
-  if (!T) {
-    return false;
-  }
-  switch (T->getTypeID()) {
-  default:
-    return false;
-  case Type::PointerTyID:
-    return isStruct(T->getContainedType(0));
-  case Type::StructTyID:
-    return true;
-  case Type::ArrayTyID:
-  case Type::VectorTyID:
-    return isStruct(dyn_cast<SequentialType>(T)->getElementType());
-  };
-
-}
-
-void AMDILModuleInfo::dumpDataToCB(llvm::raw_ostream &O, AMDILKernelManager *km,
-                                      uint32_t id) {
-  uint32_t size = 0;
-  for (StringMap<AMDILConstPtr>::iterator cmb = consts_begin(),
-      cme = consts_end(); cmb != cme; ++cmb) {
-    if (id == cmb->second.cbNum) {
-      size += (cmb->second.size + 15) & (~15);
-    }
-  }
-  if (id == 0) {
-    O << ";#DATASTART:" << (size + mCurrentCPOffset) << "\n";
-    if (mCurrentCPOffset) {
-      for (StringMap<AMDILKernel*>::iterator kcpb = mKernels.begin(),
-          kcpe = mKernels.end(); kcpb != kcpe; ++kcpb) {
-        const AMDILKernel *k = kcpb->second;
-        size_t numConsts = k->CPOffsets.size();
-        for (size_t x = 0; x < numConsts; ++x) {
-          size_t offset = k->CPOffsets[x].first;
-          const Constant *C = k->CPOffsets[x].second;
-          Type *Ty = C->getType();
-          size_t size = (isStruct(Ty) ? getTypeSize(Ty, true)
-                                      : getNumElements(Ty));
-          O << ";#" << km->getTypeName(Ty, symTab) << ":";
-          O << offset << ":" << size ;
-          printConstantValue(C, O, isStruct(Ty));
-          O << "\n";
-        }
-      }
-    }
-  } else {
-    O << ";#DATASTART:" << id << ":" << size << "\n";
-  }
-
-  for (StringMap<AMDILConstPtr>::iterator cmb = consts_begin(), cme = consts_end();
-       cmb != cme; ++cmb) {
-    if (cmb->second.cbNum != id) {
-      continue;
-    }
-    const GlobalVariable *G = dyn_cast<GlobalVariable>(cmb->second.base);
-    Type *Ty = (G) ? G->getType() : NULL;
-    size_t offset = cmb->second.offset;
-    const Constant *C = G->getInitializer();
-    size_t size = (isStruct(Ty)
-        ? getTypeSize(Ty, true)
-        : getNumElements(Ty));
-    O << ";#" << km->getTypeName(Ty, symTab) << ":";
-    if (!id) {
-      O << (offset + mCurrentCPOffset) << ":" << size;
-    } else {
-      O << offset << ":" << size;
-    }
-    if (C) {
-      printConstantValue(C, O, isStruct(Ty));
-    } else {
-      assert(0 && "Cannot have a constant pointer"
-          " without an initializer!");
-    }
-    O <<"\n";
-  }
-  if (id == 0) {
-    O << ";#DATAEND\n";
-  } else {
-    O << ";#DATAEND:" << id << "\n";
-  }
-}
-
-void
-AMDILModuleInfo::dumpDataSection(llvm::raw_ostream &O, AMDILKernelManager *km) {
-  if (mConstMems.empty() && !mCurrentCPOffset) {
-    return;
-  } else {
-    llvm::DenseSet<uint32_t> const_set;
-    for (StringMap<AMDILConstPtr>::iterator cmb = consts_begin(), cme = consts_end();
-         cmb != cme; ++cmb) {
-      const_set.insert(cmb->second.cbNum);
-    }
-    if (mCurrentCPOffset) {
-      const_set.insert(0);
-    }
-    for (llvm::DenseSet<uint32_t>::iterator setb = const_set.begin(),
-           sete = const_set.end(); setb != sete; ++setb) {
-      dumpDataToCB(O, km, *setb);
-    }
-  }
-}
-#endif
-/// Create a function ID if it is not known or return the known
-/// function ID.
-uint32_t AMDILModuleInfo::getOrCreateFunctionID(const GlobalValue* func) {
-  if (func->getName().size()) {
-    return getOrCreateFunctionID(func->getName());
-  } 
-  uint32_t id;
-  if (mFuncPtrNames.find(func) == mFuncPtrNames.end()) {
-    id = mFuncPtrNames.size() + RESERVED_FUNCS + mFuncNames.size();
-    mFuncPtrNames[func] = id;
-  } else {
-    id = mFuncPtrNames[func];
-  }
-  return id;
-}
-uint32_t AMDILModuleInfo::getOrCreateFunctionID(const std::string &func) {
-  uint32_t id;
-  if (mFuncNames.find(func) == mFuncNames.end()) {
-    id = mFuncNames.size() + RESERVED_FUNCS + mFuncPtrNames.size();
-    mFuncNames[func] = id;
-  } else {
-    id = mFuncNames[func];
-  }
-  return id;
-}
diff --git a/src/gallium/drivers/radeon/AMDILModuleInfo.h b/src/gallium/drivers/radeon/AMDILModuleInfo.h
deleted file mode 100644
index 5111b87c338..00000000000
--- a/src/gallium/drivers/radeon/AMDILModuleInfo.h
+++ /dev/null
@@ -1,159 +0,0 @@
-//===--------------- AMDILModuleInfo.h -------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//==-----------------------------------------------------------------------===//
-//
-// This is an MMI implementation for AMDIL targets.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _AMDIL_MACHINE_MODULE_INFO_H_
-#define _AMDIL_MACHINE_MODULE_INFO_H_
-#include "AMDIL.h"
-#include "AMDILKernel.h"
-#include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/SmallSet.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringMap.h"
-#include "llvm/CodeGen/MachineModuleInfo.h"
-#include "llvm/Module.h"
-#include "llvm/Support/raw_ostream.h"
-
-#include <set>
-#include <string>
-
-namespace llvm {
-  class AMDILKernel;
-  class Argument;
-  class TypeSymbolTable;
-  class GlobalValue;
-  class MachineFunction;
-  class GlobalValue;
-
-  class AMDILModuleInfo : public MachineModuleInfoImpl {
-    protected:
-      const MachineModuleInfo *mMMI;
-    public:
-      AMDILModuleInfo(const MachineModuleInfo &);
-      virtual ~AMDILModuleInfo();
-
-      void processModule(const Module *MF, const AMDILTargetMachine* mTM);
-
-      /// Process the given module and parse out the global variable metadata passed
-      /// down from the frontend-compiler
-
-      /// Returns true if the image ID corresponds to a read only image.
-      bool isReadOnlyImage(const llvm::StringRef &name, uint32_t iID) const;
-
-      /// Returns true if the image ID corresponds to a write only image.
-      bool isWriteOnlyImage(const llvm::StringRef &name, uint32_t iID) const;
-
-      /// Gets the group size of the kernel for the given dimension.
-      uint32_t getRegion(const llvm::StringRef &name, uint32_t dim) const;
-
-      /// Get the offset of the array for the kernel.
-      int32_t getArrayOffset(const llvm::StringRef &name) const;
-
-      /// Get the offset of the const memory for the kernel.
-      int32_t getConstOffset(const llvm::StringRef &name) const;
-
-      /// Get the boolean value if this particular constant uses HW or not.
-      bool getConstHWBit(const llvm::StringRef &name) const;
-
-      /// Get a reference to the kernel metadata information for the given function
-      /// name.
-      AMDILKernel *getKernel(const llvm::StringRef &name);
-      bool isKernel(const llvm::StringRef &name) const;
-
-      /// Dump the data section to the output stream for the given kernel.
-      //void dumpDataSection(llvm::raw_ostream &O, AMDILKernelManager *km);
-
-      /// Iterate through the constants that are global to the compilation unit.
-      StringMap<AMDILConstPtr>::iterator consts_begin();
-      StringMap<AMDILConstPtr>::iterator consts_end();
-
-      /// Query if the kernel has a byte store.
-      bool byteStoreExists(llvm::StringRef S) const;
-
-      /// Query if the constant pointer is an argument.
-      bool isConstPtrArgument(const AMDILKernel *krnl, const llvm::StringRef &arg);
-
-      /// Query if the constant pointer is an array that is globally scoped.
-      bool isConstPtrArray(const AMDILKernel *krnl, const llvm::StringRef &arg);
-
-      /// Query the size of the constant pointer.
-      uint32_t getConstPtrSize(const AMDILKernel *krnl, const llvm::StringRef &arg);
-
-      /// Query the offset of the constant pointer.
-      uint32_t getConstPtrOff(const AMDILKernel *krnl, const llvm::StringRef &arg);
-
-      /// Query the constant buffer number for a constant pointer.
-      uint32_t getConstPtrCB(const AMDILKernel *krnl, const llvm::StringRef &arg);
-
-      /// Query the Value* that the constant pointer originates from.
-      const Value *getConstPtrValue(const AMDILKernel *krnl, const llvm::StringRef &arg);
-
-      /// Get the ID of the argument.
-      int32_t getArgID(const Argument *arg);
-
-      /// Get the unique function ID for the specific function name and create a new
-      /// unique ID if it is not found.
-      uint32_t getOrCreateFunctionID(const GlobalValue* func);
-      uint32_t getOrCreateFunctionID(const std::string& func);
-
-      /// Calculate the offsets of the constant pool for the given kernel and
-      /// machine function.
-      void calculateCPOffsets(const MachineFunction *MF, AMDILKernel *krnl);
-
-      void add_printf_offset(uint32_t offset) { mPrintfOffset += offset; }
-      uint32_t get_printf_offset() { return mPrintfOffset; }
-
-    private:
-      /// Various functions that parse global value information and store them in
-      /// the global manager. This approach is used instead of dynamic parsing as it
-      /// might require more space, but should allow caching of data that gets
-      /// requested multiple times.
-      AMDILKernelAttr parseSGV(const GlobalValue *GV);
-      AMDILLocalArg  parseLVGV(const GlobalValue *GV);
-      void parseGlobalAnnotate(const GlobalValue *G);
-      void parseImageAnnotate(const GlobalValue *G);
-      void parseConstantPtrAnnotate(const GlobalValue *G);
-      void printConstantValue(const Constant *CAval,
-          llvm::raw_ostream& O,
-          bool asByte);
-      void parseKernelInformation(const Value *V);
-      void parseAutoArray(const GlobalValue *G, bool isRegion);
-      void parseConstantPtr(const GlobalValue *G);
-      void allocateGlobalCB();
-      bool checkConstPtrsUseHW(Module::const_iterator *F);
-
-      llvm::StringMap<AMDILKernel*> mKernels;
-      llvm::StringMap<AMDILKernelAttr> mKernelArgs;
-      llvm::StringMap<AMDILArrayMem> mArrayMems;
-      llvm::StringMap<AMDILConstPtr> mConstMems;
-      llvm::StringMap<AMDILLocalArg> mLocalArgs;
-      llvm::StringMap<uint32_t> mFuncNames;
-      llvm::DenseMap<const GlobalValue*, uint32_t> mFuncPtrNames;
-      llvm::DenseMap<uint32_t, llvm::StringRef> mImageNameMap;
-      std::set<llvm::StringRef> mByteStore;
-      std::set<llvm::StringRef> mIgnoreStr;
-      llvm::DenseMap<const Argument *, int32_t> mArgIDMap;
-      const TypeSymbolTable *symTab;
-      const AMDILSubtarget *mSTM;
-      size_t mOffset;
-      uint32_t mReservedBuffs;
-      uint32_t mCurrentCPOffset;
-      uint32_t mPrintfOffset;
-  };
-
-
-
-} // end namespace llvm
-
-#endif // _AMDIL_COFF_MACHINE_MODULE_INFO_H_
-
diff --git a/src/gallium/drivers/radeon/Makefile.sources b/src/gallium/drivers/radeon/Makefile.sources
index 462b0eb651a..dc156047298 100644
--- a/src/gallium/drivers/radeon/Makefile.sources
+++ b/src/gallium/drivers/radeon/Makefile.sources
@@ -31,7 +31,6 @@ CPP_SOURCES := \
 	AMDILMachineFunctionInfo.cpp	\
 	AMDILMachinePeephole.cpp	\
 	AMDILMCCodeEmitter.cpp		\
-	AMDILModuleInfo.cpp		\
 	AMDILNIDevice.cpp		\
 	AMDILPeepholeOptimizer.cpp	\
 	AMDILRegisterInfo.cpp		\