diff options
Diffstat (limited to 'src/gallium/drivers/radeon/AMDILIOExpansion.cpp')
| -rw-r--r-- | src/gallium/drivers/radeon/AMDILIOExpansion.cpp | 1160 |
1 files changed, 0 insertions, 1160 deletions
diff --git a/src/gallium/drivers/radeon/AMDILIOExpansion.cpp b/src/gallium/drivers/radeon/AMDILIOExpansion.cpp deleted file mode 100644 index 68d8eef344d..00000000000 --- a/src/gallium/drivers/radeon/AMDILIOExpansion.cpp +++ /dev/null @@ -1,1160 +0,0 @@ -//===----------- AMDILIOExpansion.cpp - IO Expansion Pass -----------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//==-----------------------------------------------------------------------===// -// The AMDIL IO Expansion class expands pseudo IO instructions into a sequence -// of instructions that produces the correct results. These instructions are -// not expanded earlier in the pass because any pass before this can assume to -// be able to generate a load/store instruction. So this pass can only have -// passes that execute after it if no load/store instructions can be generated. -//===----------------------------------------------------------------------===// -#include "AMDILIOExpansion.h" -#include "AMDIL.h" -#include "AMDILDevices.h" -#include "AMDILGlobalManager.h" -#include "AMDILKernelManager.h" -#include "AMDILMachineFunctionInfo.h" -#include "AMDILTargetMachine.h" -#include "AMDILUtilityFunctions.h" -#include "llvm/CodeGen/MachineConstantPool.h" -#include "llvm/CodeGen/MachineInstr.h" -#include "llvm/CodeGen/MachineInstrBuilder.h" -#include "llvm/CodeGen/MachineMemOperand.h" -#include "llvm/DerivedTypes.h" -#include "llvm/Support/DebugLoc.h" -#include "llvm/Target/TargetMachine.h" -#include "llvm/Value.h" - -using namespace llvm; - -char AMDILIOExpansion::ID = 0; -namespace llvm { - FunctionPass* - createAMDILIOExpansion(TargetMachine &TM AMDIL_OPT_LEVEL_DECL) - { - return TM.getSubtarget<AMDILSubtarget>() - .device()->getIOExpansion(TM AMDIL_OPT_LEVEL_VAR); - } -} - -AMDILIOExpansion::AMDILIOExpansion(TargetMachine &tm - AMDIL_OPT_LEVEL_DECL) : - MachineFunctionPass(ID), TM(tm) -{ - mSTM = &tm.getSubtarget<AMDILSubtarget>(); - mDebug = DEBUGME; - mTII = tm.getInstrInfo(); - mKM = NULL; -} - -AMDILIOExpansion::~AMDILIOExpansion() -{ -} - bool -AMDILIOExpansion::runOnMachineFunction(MachineFunction &MF) -{ - mKM = const_cast<AMDILKernelManager*>(mSTM->getKernelManager()); - mMFI = MF.getInfo<AMDILMachineFunctionInfo>(); - for (MachineFunction::iterator MFI = MF.begin(), MFE = MF.end(); - MFI != MFE; ++MFI) { - MachineBasicBlock *MBB = MFI; - for (MachineBasicBlock::iterator MBI = MBB->begin(), MBE = MBB->end(); - MBI != MBE; ++MBI) { - MachineInstr *MI = MBI; - if (isIOInstruction(MI)) { - mBB = MBB; - saveInst = false; - expandIOInstruction(MI); - if (!saveInst) { - // erase returns the instruction after - // and we want the instruction before - MBI = MBB->erase(MI); - --MBI; - } - } - } - } - return false; -} -const char *AMDILIOExpansion::getPassName() const -{ - return "AMDIL Generic IO Expansion Pass"; -} - bool -AMDILIOExpansion::isIOInstruction(MachineInstr *MI) -{ - if (!MI) { - return false; - } - switch(MI->getOpcode()) { - default: - return false; - ExpandCaseToAllTypes(AMDIL::CPOOLLOAD) - ExpandCaseToAllTypes(AMDIL::CPOOLSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::CPOOLZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::CPOOLAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::CONSTANTLOAD) - ExpandCaseToAllTypes(AMDIL::CONSTANTSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::CONSTANTZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::CONSTANTAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATELOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATESEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATEZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATEAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATESTORE) - ExpandCaseToAllTruncTypes(AMDIL::PRIVATETRUNCSTORE) - ExpandCaseToAllTypes(AMDIL::REGIONSTORE) - ExpandCaseToAllTruncTypes(AMDIL::REGIONTRUNCSTORE) - ExpandCaseToAllTypes(AMDIL::REGIONLOAD) - ExpandCaseToAllTypes(AMDIL::REGIONSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::REGIONZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::REGIONAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALSTORE) - ExpandCaseToAllTruncTypes(AMDIL::LOCALTRUNCSTORE) - ExpandCaseToAllTypes(AMDIL::LOCALLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::GLOBALLOAD) - ExpandCaseToAllTypes(AMDIL::GLOBALSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::GLOBALAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::GLOBALZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::GLOBALSTORE) - ExpandCaseToAllTruncTypes(AMDIL::GLOBALTRUNCSTORE) - return true; - }; - return false; -} -void -AMDILIOExpansion::expandIOInstruction(MachineInstr *MI) -{ - assert(isIOInstruction(MI) && "Must be an IO instruction to " - "be passed to this function!"); - switch (MI->getOpcode()) { - default: - assert(0 && "Not an IO Instruction!"); - ExpandCaseToAllTypes(AMDIL::GLOBALLOAD); - ExpandCaseToAllTypes(AMDIL::GLOBALSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::GLOBALZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::GLOBALAEXTLOAD); - expandGlobalLoad(MI); - break; - ExpandCaseToAllTypes(AMDIL::REGIONLOAD); - ExpandCaseToAllTypes(AMDIL::REGIONSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::REGIONZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::REGIONAEXTLOAD); - expandRegionLoad(MI); - break; - ExpandCaseToAllTypes(AMDIL::LOCALLOAD); - ExpandCaseToAllTypes(AMDIL::LOCALSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::LOCALZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::LOCALAEXTLOAD); - expandLocalLoad(MI); - break; - ExpandCaseToAllTypes(AMDIL::CONSTANTLOAD); - ExpandCaseToAllTypes(AMDIL::CONSTANTSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CONSTANTZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CONSTANTAEXTLOAD); - expandConstantLoad(MI); - break; - ExpandCaseToAllTypes(AMDIL::PRIVATELOAD); - ExpandCaseToAllTypes(AMDIL::PRIVATESEXTLOAD); - ExpandCaseToAllTypes(AMDIL::PRIVATEZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::PRIVATEAEXTLOAD); - expandPrivateLoad(MI); - break; - ExpandCaseToAllTypes(AMDIL::CPOOLLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLAEXTLOAD); - expandConstantPoolLoad(MI); - break; - ExpandCaseToAllTruncTypes(AMDIL::GLOBALTRUNCSTORE) - ExpandCaseToAllTypes(AMDIL::GLOBALSTORE); - expandGlobalStore(MI); - break; - ExpandCaseToAllTruncTypes(AMDIL::PRIVATETRUNCSTORE); - ExpandCaseToAllTypes(AMDIL::PRIVATESTORE); - expandPrivateStore(MI); - break; - ExpandCaseToAllTruncTypes(AMDIL::REGIONTRUNCSTORE); - ExpandCaseToAllTypes(AMDIL::REGIONSTORE); - expandRegionStore(MI); - break; - ExpandCaseToAllTruncTypes(AMDIL::LOCALTRUNCSTORE); - ExpandCaseToAllTypes(AMDIL::LOCALSTORE); - expandLocalStore(MI); - break; - } -} - bool -AMDILIOExpansion::isAddrCalcInstr(MachineInstr *MI) -{ - switch(MI->getOpcode()) { - ExpandCaseToAllTypes(AMDIL::PRIVATELOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATESEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATEZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATEAEXTLOAD) - { - // This section of code is a workaround for the problem of - // globally scoped constant address variables. The problems - // comes that although they are declared in the constant - // address space, all variables must be allocated in the - // private address space. So when there is a load from - // the global address, it automatically goes into the private - // address space. However, the data section is placed in the - // constant address space so we need to check to see if our - // load base address is a global variable or not. Only if it - // is not a global variable can we do the address calculation - // into the private memory ring. - - MachineMemOperand& memOp = (**MI->memoperands_begin()); - const Value *V = memOp.getValue(); - if (V) { - const GlobalValue *GV = dyn_cast<GlobalVariable>(V); - return mSTM->device()->usesSoftware(AMDILDeviceInfo::PrivateMem) - && !(GV); - } else { - return false; - } - } - ExpandCaseToAllTypes(AMDIL::CPOOLLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLAEXTLOAD); - return MI->getOperand(1).isReg(); - ExpandCaseToAllTruncTypes(AMDIL::PRIVATETRUNCSTORE); - ExpandCaseToAllTypes(AMDIL::PRIVATESTORE); - return mSTM->device()->usesSoftware(AMDILDeviceInfo::PrivateMem); - ExpandCaseToAllTruncTypes(AMDIL::LOCALTRUNCSTORE); - ExpandCaseToAllTypes(AMDIL::LOCALSTORE); - ExpandCaseToAllTypes(AMDIL::LOCALLOAD); - ExpandCaseToAllTypes(AMDIL::LOCALSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::LOCALZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::LOCALAEXTLOAD); - return mSTM->device()->usesSoftware(AMDILDeviceInfo::LocalMem); - }; - return false; - -} - bool -AMDILIOExpansion::isExtendLoad(MachineInstr *MI) -{ - return isSExtLoadInst(TM.getInstrInfo(), MI) || - isZExtLoadInst(TM.getInstrInfo(), MI) || - isAExtLoadInst(TM.getInstrInfo(), MI) - || isSWSExtLoadInst(MI); -} - - bool -AMDILIOExpansion::isHardwareRegion(MachineInstr *MI) -{ - switch(MI->getOpcode()) { - default: - return false; - break; - ExpandCaseToAllTypes(AMDIL::REGIONLOAD) - ExpandCaseToAllTypes(AMDIL::REGIONSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::REGIONZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::REGIONAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::REGIONSTORE) - ExpandCaseToAllTruncTypes(AMDIL::REGIONTRUNCSTORE) - return mSTM->device()->usesHardware(AMDILDeviceInfo::RegionMem); - }; - return false; -} - bool -AMDILIOExpansion::isHardwareLocal(MachineInstr *MI) -{ - switch(MI->getOpcode()) { - default: - return false; - break; - ExpandCaseToAllTypes(AMDIL::LOCALLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALSTORE) - ExpandCaseToAllTruncTypes(AMDIL::LOCALTRUNCSTORE) - return mSTM->device()->usesHardware(AMDILDeviceInfo::LocalMem); - }; - return false; -} - bool -AMDILIOExpansion::isPackedData(MachineInstr *MI) -{ - switch(MI->getOpcode()) { - default: - if (isTruncStoreInst(TM.getInstrInfo(), MI)) { - switch (MI->getDesc().OpInfo[0].RegClass) { - default: - break; - case AMDIL::GPRV2I64RegClassID: - case AMDIL::GPRV2I32RegClassID: - switch (getMemorySize(MI)) { - case 2: - case 4: - return true; - default: - break; - } - break; - case AMDIL::GPRV4I32RegClassID: - switch (getMemorySize(MI)) { - case 4: - case 8: - return true; - default: - break; - } - break; - } - } - break; - ExpandCaseToPackedTypes(AMDIL::CPOOLLOAD); - ExpandCaseToPackedTypes(AMDIL::CPOOLSEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::CPOOLZEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::CPOOLAEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::GLOBALLOAD); - ExpandCaseToPackedTypes(AMDIL::GLOBALSEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::GLOBALZEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::GLOBALAEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::LOCALLOAD); - ExpandCaseToPackedTypes(AMDIL::LOCALSEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::LOCALZEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::LOCALAEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::REGIONLOAD); - ExpandCaseToPackedTypes(AMDIL::REGIONSEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::REGIONZEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::REGIONAEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::PRIVATELOAD); - ExpandCaseToPackedTypes(AMDIL::PRIVATESEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::PRIVATEZEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::PRIVATEAEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::CONSTANTLOAD); - ExpandCaseToPackedTypes(AMDIL::CONSTANTSEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::CONSTANTAEXTLOAD); - ExpandCaseToPackedTypes(AMDIL::CONSTANTZEXTLOAD); - ExpandCaseToAllTruncTypes(AMDIL::GLOBALTRUNCSTORE) - ExpandCaseToAllTruncTypes(AMDIL::PRIVATETRUNCSTORE); - ExpandCaseToAllTruncTypes(AMDIL::LOCALTRUNCSTORE); - ExpandCaseToAllTruncTypes(AMDIL::REGIONTRUNCSTORE); - ExpandCaseToPackedTypes(AMDIL::GLOBALSTORE); - ExpandCaseToPackedTypes(AMDIL::PRIVATESTORE); - ExpandCaseToPackedTypes(AMDIL::LOCALSTORE); - ExpandCaseToPackedTypes(AMDIL::REGIONSTORE); - return true; - } - return false; -} - - bool -AMDILIOExpansion::isStaticCPLoad(MachineInstr *MI) -{ - switch(MI->getOpcode()) { - ExpandCaseToAllTypes(AMDIL::CPOOLLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLSEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLZEXTLOAD); - ExpandCaseToAllTypes(AMDIL::CPOOLAEXTLOAD); - { - uint32_t x = 0; - uint32_t num = MI->getNumOperands(); - for (x = 0; x < num; ++x) { - if (MI->getOperand(x).isCPI()) { - return true; - } - } - } - break; - default: - break; - } - return false; -} - - bool -AMDILIOExpansion::isNbitType(Type *mType, uint32_t nBits, bool isScalar) -{ - if (!mType) { - return false; - } - if (dyn_cast<PointerType>(mType)) { - PointerType *PT = dyn_cast<PointerType>(mType); - return isNbitType(PT->getElementType(), nBits); - } else if (dyn_cast<StructType>(mType)) { - return getTypeSize(mType) == nBits; - } else if (dyn_cast<VectorType>(mType)) { - VectorType *VT = dyn_cast<VectorType>(mType); - size_t size = VT->getScalarSizeInBits(); - return (isScalar ? - VT->getNumElements() * size == nBits : size == nBits); - } else if (dyn_cast<ArrayType>(mType)) { - ArrayType *AT = dyn_cast<ArrayType>(mType); - size_t size = AT->getScalarSizeInBits(); - return (isScalar ? - AT->getNumElements() * size == nBits : size == nBits); - } else if (mType->isSized()) { - return mType->getScalarSizeInBits() == nBits; - } else { - assert(0 && "Found a type that we don't know how to handle!"); - return false; - } -} - - bool -AMDILIOExpansion::isHardwareInst(MachineInstr *MI) -{ - AMDILAS::InstrResEnc curRes; - curRes.u16all = MI->getAsmPrinterFlags(); - return curRes.bits.HardwareInst; -} - -REG_PACKED_TYPE -AMDILIOExpansion::getPackedID(MachineInstr *MI) -{ - switch (MI->getOpcode()) { - default: - break; - case AMDIL::GLOBALTRUNCSTORE_v2i64i8: - case AMDIL::REGIONTRUNCSTORE_v2i64i8: - case AMDIL::LOCALTRUNCSTORE_v2i64i8: - case AMDIL::PRIVATETRUNCSTORE_v2i64i8: - case AMDIL::GLOBALTRUNCSTORE_v2i32i8: - case AMDIL::REGIONTRUNCSTORE_v2i32i8: - case AMDIL::LOCALTRUNCSTORE_v2i32i8: - case AMDIL::PRIVATETRUNCSTORE_v2i32i8: - case AMDIL::GLOBALTRUNCSTORE_v2i16i8: - case AMDIL::REGIONTRUNCSTORE_v2i16i8: - case AMDIL::LOCALTRUNCSTORE_v2i16i8: - case AMDIL::PRIVATETRUNCSTORE_v2i16i8: - case AMDIL::GLOBALSTORE_v2i8: - case AMDIL::LOCALSTORE_v2i8: - case AMDIL::REGIONSTORE_v2i8: - case AMDIL::PRIVATESTORE_v2i8: - return PACK_V2I8; - case AMDIL::GLOBALTRUNCSTORE_v4i32i8: - case AMDIL::REGIONTRUNCSTORE_v4i32i8: - case AMDIL::LOCALTRUNCSTORE_v4i32i8: - case AMDIL::PRIVATETRUNCSTORE_v4i32i8: - case AMDIL::GLOBALTRUNCSTORE_v4i16i8: - case AMDIL::REGIONTRUNCSTORE_v4i16i8: - case AMDIL::LOCALTRUNCSTORE_v4i16i8: - case AMDIL::PRIVATETRUNCSTORE_v4i16i8: - case AMDIL::GLOBALSTORE_v4i8: - case AMDIL::LOCALSTORE_v4i8: - case AMDIL::REGIONSTORE_v4i8: - case AMDIL::PRIVATESTORE_v4i8: - return PACK_V4I8; - case AMDIL::GLOBALTRUNCSTORE_v2i64i16: - case AMDIL::REGIONTRUNCSTORE_v2i64i16: - case AMDIL::LOCALTRUNCSTORE_v2i64i16: - case AMDIL::PRIVATETRUNCSTORE_v2i64i16: - case AMDIL::GLOBALTRUNCSTORE_v2i32i16: - case AMDIL::REGIONTRUNCSTORE_v2i32i16: - case AMDIL::LOCALTRUNCSTORE_v2i32i16: - case AMDIL::PRIVATETRUNCSTORE_v2i32i16: - case AMDIL::GLOBALSTORE_v2i16: - case AMDIL::LOCALSTORE_v2i16: - case AMDIL::REGIONSTORE_v2i16: - case AMDIL::PRIVATESTORE_v2i16: - return PACK_V2I16; - case AMDIL::GLOBALTRUNCSTORE_v4i32i16: - case AMDIL::REGIONTRUNCSTORE_v4i32i16: - case AMDIL::LOCALTRUNCSTORE_v4i32i16: - case AMDIL::PRIVATETRUNCSTORE_v4i32i16: - case AMDIL::GLOBALSTORE_v4i16: - case AMDIL::LOCALSTORE_v4i16: - case AMDIL::REGIONSTORE_v4i16: - case AMDIL::PRIVATESTORE_v4i16: - return PACK_V4I16; - case AMDIL::GLOBALLOAD_v2i8: - case AMDIL::GLOBALSEXTLOAD_v2i8: - case AMDIL::GLOBALAEXTLOAD_v2i8: - case AMDIL::GLOBALZEXTLOAD_v2i8: - case AMDIL::LOCALLOAD_v2i8: - case AMDIL::LOCALSEXTLOAD_v2i8: - case AMDIL::LOCALAEXTLOAD_v2i8: - case AMDIL::LOCALZEXTLOAD_v2i8: - case AMDIL::REGIONLOAD_v2i8: - case AMDIL::REGIONSEXTLOAD_v2i8: - case AMDIL::REGIONAEXTLOAD_v2i8: - case AMDIL::REGIONZEXTLOAD_v2i8: - case AMDIL::PRIVATELOAD_v2i8: - case AMDIL::PRIVATESEXTLOAD_v2i8: - case AMDIL::PRIVATEAEXTLOAD_v2i8: - case AMDIL::PRIVATEZEXTLOAD_v2i8: - case AMDIL::CONSTANTLOAD_v2i8: - case AMDIL::CONSTANTSEXTLOAD_v2i8: - case AMDIL::CONSTANTAEXTLOAD_v2i8: - case AMDIL::CONSTANTZEXTLOAD_v2i8: - return UNPACK_V2I8; - case AMDIL::GLOBALLOAD_v4i8: - case AMDIL::GLOBALSEXTLOAD_v4i8: - case AMDIL::GLOBALAEXTLOAD_v4i8: - case AMDIL::GLOBALZEXTLOAD_v4i8: - case AMDIL::LOCALLOAD_v4i8: - case AMDIL::LOCALSEXTLOAD_v4i8: - case AMDIL::LOCALAEXTLOAD_v4i8: - case AMDIL::LOCALZEXTLOAD_v4i8: - case AMDIL::REGIONLOAD_v4i8: - case AMDIL::REGIONSEXTLOAD_v4i8: - case AMDIL::REGIONAEXTLOAD_v4i8: - case AMDIL::REGIONZEXTLOAD_v4i8: - case AMDIL::PRIVATELOAD_v4i8: - case AMDIL::PRIVATESEXTLOAD_v4i8: - case AMDIL::PRIVATEAEXTLOAD_v4i8: - case AMDIL::PRIVATEZEXTLOAD_v4i8: - case AMDIL::CONSTANTLOAD_v4i8: - case AMDIL::CONSTANTSEXTLOAD_v4i8: - case AMDIL::CONSTANTAEXTLOAD_v4i8: - case AMDIL::CONSTANTZEXTLOAD_v4i8: - return UNPACK_V4I8; - case AMDIL::GLOBALLOAD_v2i16: - case AMDIL::GLOBALSEXTLOAD_v2i16: - case AMDIL::GLOBALAEXTLOAD_v2i16: - case AMDIL::GLOBALZEXTLOAD_v2i16: - case AMDIL::LOCALLOAD_v2i16: - case AMDIL::LOCALSEXTLOAD_v2i16: - case AMDIL::LOCALAEXTLOAD_v2i16: - case AMDIL::LOCALZEXTLOAD_v2i16: - case AMDIL::REGIONLOAD_v2i16: - case AMDIL::REGIONSEXTLOAD_v2i16: - case AMDIL::REGIONAEXTLOAD_v2i16: - case AMDIL::REGIONZEXTLOAD_v2i16: - case AMDIL::PRIVATELOAD_v2i16: - case AMDIL::PRIVATESEXTLOAD_v2i16: - case AMDIL::PRIVATEAEXTLOAD_v2i16: - case AMDIL::PRIVATEZEXTLOAD_v2i16: - case AMDIL::CONSTANTLOAD_v2i16: - case AMDIL::CONSTANTSEXTLOAD_v2i16: - case AMDIL::CONSTANTAEXTLOAD_v2i16: - case AMDIL::CONSTANTZEXTLOAD_v2i16: - return UNPACK_V2I16; - case AMDIL::GLOBALLOAD_v4i16: - case AMDIL::GLOBALSEXTLOAD_v4i16: - case AMDIL::GLOBALAEXTLOAD_v4i16: - case AMDIL::GLOBALZEXTLOAD_v4i16: - case AMDIL::LOCALLOAD_v4i16: - case AMDIL::LOCALSEXTLOAD_v4i16: - case AMDIL::LOCALAEXTLOAD_v4i16: - case AMDIL::LOCALZEXTLOAD_v4i16: - case AMDIL::REGIONLOAD_v4i16: - case AMDIL::REGIONSEXTLOAD_v4i16: - case AMDIL::REGIONAEXTLOAD_v4i16: - case AMDIL::REGIONZEXTLOAD_v4i16: - case AMDIL::PRIVATELOAD_v4i16: - case AMDIL::PRIVATESEXTLOAD_v4i16: - case AMDIL::PRIVATEAEXTLOAD_v4i16: - case AMDIL::PRIVATEZEXTLOAD_v4i16: - case AMDIL::CONSTANTLOAD_v4i16: - case AMDIL::CONSTANTSEXTLOAD_v4i16: - case AMDIL::CONSTANTAEXTLOAD_v4i16: - case AMDIL::CONSTANTZEXTLOAD_v4i16: - return UNPACK_V4I16; - }; - return NO_PACKING; -} - - uint32_t -AMDILIOExpansion::getPointerID(MachineInstr *MI) -{ - AMDILAS::InstrResEnc curInst; - getAsmPrinterFlags(MI, curInst); - return curInst.bits.ResourceID; -} - - uint32_t -AMDILIOExpansion::getShiftSize(MachineInstr *MI) -{ - switch(getPackedID(MI)) { - default: - return 0; - case PACK_V2I8: - case PACK_V4I8: - case UNPACK_V2I8: - case UNPACK_V4I8: - return 1; - case PACK_V2I16: - case PACK_V4I16: - case UNPACK_V2I16: - case UNPACK_V4I16: - return 2; - } - return 0; -} - uint32_t -AMDILIOExpansion::getMemorySize(MachineInstr *MI) -{ - if (MI->memoperands_empty()) { - return 4; - } - return (uint32_t)((*MI->memoperands_begin())->getSize()); -} - - void -AMDILIOExpansion::expandLongExtend(MachineInstr *MI, - uint32_t numComps, uint32_t size, bool signedShift) -{ - DebugLoc DL = MI->getDebugLoc(); - switch(size) { - default: - assert(0 && "Found a case we don't handle!"); - break; - case 8: - if (numComps == 1) { - expandLongExtendSub32(MI, AMDIL::SHL_i8, AMDIL::SHRVEC_v2i32, - AMDIL::USHRVEC_i8, - 24, (24ULL | (31ULL << 32)), 24, AMDIL::LCREATE, signedShift); - } else if (numComps == 2) { - expandLongExtendSub32(MI, AMDIL::SHL_v2i8, AMDIL::SHRVEC_v4i32, - AMDIL::USHRVEC_v2i8, - 24, (24ULL | (31ULL << 32)), 24, AMDIL::LCREATE_v2i64, signedShift); - } else { - assert(0 && "Found a case we don't handle!"); - } - break; - case 16: - if (numComps == 1) { - expandLongExtendSub32(MI, AMDIL::SHL_i16, AMDIL::SHRVEC_v2i32, - AMDIL::USHRVEC_i16, - 16, (16ULL | (31ULL << 32)), 16, AMDIL::LCREATE, signedShift); - } else if (numComps == 2) { - expandLongExtendSub32(MI, AMDIL::SHL_v2i16, AMDIL::SHRVEC_v4i32, - AMDIL::USHRVEC_v2i16, - 16, (16ULL | (31ULL << 32)), 16, AMDIL::LCREATE_v2i64, signedShift); - } else { - assert(0 && "Found a case we don't handle!"); - } - break; - case 32: - if (numComps == 1) { - if (signedShift) { - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHRVEC_i32), AMDIL::R1012) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(31)); - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LCREATE), AMDIL::R1011) - .addReg(AMDIL::R1011).addReg(AMDIL::R1012); - } else { - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LCREATE), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(0)); - } - } else if (numComps == 2) { - if (signedShift) { - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::SHRVEC_v2i32), AMDIL::R1012) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(31)); - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LCREATE_v2i64), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addReg(AMDIL::R1012); - } else { - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::LCREATE_v2i64), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(0)); - } - } else { - assert(0 && "Found a case we don't handle!"); - } - }; -} - void -AMDILIOExpansion::expandLongExtendSub32(MachineInstr *MI, - unsigned SHLop, unsigned SHRop, unsigned USHRop, - unsigned SHLimm, uint64_t SHRimm, unsigned USHRimm, - unsigned LCRop, bool signedShift) -{ - DebugLoc DL = MI->getDebugLoc(); - BuildMI(*mBB, MI, DL, mTII->get(SHLop), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(SHLimm)); - if (signedShift) { - BuildMI(*mBB, MI, DL, mTII->get(LCRop), AMDIL::R1011) - .addReg(AMDIL::R1011).addReg(AMDIL::R1011); - BuildMI(*mBB, MI, DL, mTII->get(SHRop), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi64Literal(SHRimm)); - } else { - BuildMI(*mBB, MI, DL, mTII->get(USHRop), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(USHRimm)); - BuildMI(*mBB, MI, MI->getDebugLoc(), mTII->get(LCRop), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(0)); - } -} - - void -AMDILIOExpansion::expandIntegerExtend(MachineInstr *MI, unsigned SHLop, - unsigned SHRop, unsigned offset) -{ - DebugLoc DL = MI->getDebugLoc(); - offset = mMFI->addi32Literal(offset); - BuildMI(*mBB, MI, DL, - mTII->get(SHLop), AMDIL::R1011) - .addReg(AMDIL::R1011).addImm(offset); - BuildMI(*mBB, MI, DL, - mTII->get(SHRop), AMDIL::R1011) - .addReg(AMDIL::R1011).addImm(offset); -} - void -AMDILIOExpansion::expandExtendLoad(MachineInstr *MI) -{ - if (!isExtendLoad(MI)) { - return; - } - Type *mType = NULL; - if (!MI->memoperands_empty()) { - MachineMemOperand *memOp = (*MI->memoperands_begin()); - const Value *moVal = (memOp) ? memOp->getValue() : NULL; - mType = (moVal) ? moVal->getType() : NULL; - } - unsigned opcode = 0; - DebugLoc DL = MI->getDebugLoc(); - if (isZExtLoadInst(TM.getInstrInfo(), MI) || isAExtLoadInst(TM.getInstrInfo(), MI) || isSExtLoadInst(TM.getInstrInfo(), MI)) { - switch(MI->getDesc().OpInfo[0].RegClass) { - default: - assert(0 && "Found an extending load that we don't handle!"); - break; - case AMDIL::GPRI16RegClassID: - if (!isHardwareLocal(MI) - || mSTM->device()->usesSoftware(AMDILDeviceInfo::ByteLDSOps)) { - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_i16 : AMDIL::USHRVEC_i16; - expandIntegerExtend(MI, AMDIL::SHL_i16, opcode, 24); - } - break; - case AMDIL::GPRV2I16RegClassID: - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_v2i16 : AMDIL::USHRVEC_v2i16; - expandIntegerExtend(MI, AMDIL::SHL_v2i16, opcode, 24); - break; - case AMDIL::GPRV4I8RegClassID: - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_v4i8 : AMDIL::USHRVEC_v4i8; - expandIntegerExtend(MI, AMDIL::SHL_v4i8, opcode, 24); - break; - case AMDIL::GPRV4I16RegClassID: - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_v4i16 : AMDIL::USHRVEC_v4i16; - expandIntegerExtend(MI, AMDIL::SHL_v4i16, opcode, 24); - break; - case AMDIL::GPRI32RegClassID: - // We can be a i8 or i16 bit sign extended value - if (isNbitType(mType, 8) || getMemorySize(MI) == 1) { - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_i32 : AMDIL::USHRVEC_i32; - expandIntegerExtend(MI, AMDIL::SHL_i32, opcode, 24); - } else if (isNbitType(mType, 16) || getMemorySize(MI) == 2) { - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_i32 : AMDIL::USHRVEC_i32; - expandIntegerExtend(MI, AMDIL::SHL_i32, opcode, 16); - } else { - assert(0 && "Found an extending load that we don't handle!"); - } - break; - case AMDIL::GPRV2I32RegClassID: - // We can be a v2i8 or v2i16 bit sign extended value - if (isNbitType(mType, 8, false) || getMemorySize(MI) == 2) { - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_v2i32 : AMDIL::USHRVEC_v2i32; - expandIntegerExtend(MI, AMDIL::SHL_v2i32, opcode, 24); - } else if (isNbitType(mType, 16, false) || getMemorySize(MI) == 4) { - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_v2i32 : AMDIL::USHRVEC_v2i32; - expandIntegerExtend(MI, AMDIL::SHL_v2i32, opcode, 16); - } else { - assert(0 && "Found an extending load that we don't handle!"); - } - break; - case AMDIL::GPRV4I32RegClassID: - // We can be a v4i8 or v4i16 bit sign extended value - if (isNbitType(mType, 8, false) || getMemorySize(MI) == 4) { - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_v4i32 : AMDIL::USHRVEC_v4i32; - expandIntegerExtend(MI, AMDIL::SHL_v4i32, opcode, 24); - } else if (isNbitType(mType, 16, false) || getMemorySize(MI) == 8) { - opcode = isSExtLoadInst(TM.getInstrInfo(), MI) ? AMDIL::SHRVEC_v4i32 : AMDIL::USHRVEC_v4i32; - expandIntegerExtend(MI, AMDIL::SHL_v4i32, opcode, 16); - } else { - assert(0 && "Found an extending load that we don't handle!"); - } - break; - case AMDIL::GPRI64RegClassID: - // We can be a i8, i16 or i32 bit sign extended value - if (isNbitType(mType, 8) || getMemorySize(MI) == 1) { - expandLongExtend(MI, 1, 8, isSExtLoadInst(TM.getInstrInfo(), MI)); - } else if (isNbitType(mType, 16) || getMemorySize(MI) == 2) { - expandLongExtend(MI, 1, 16, isSExtLoadInst(TM.getInstrInfo(), MI)); - } else if (isNbitType(mType, 32) || getMemorySize(MI) == 4) { - expandLongExtend(MI, 1, 32, isSExtLoadInst(TM.getInstrInfo(), MI)); - } else { - assert(0 && "Found an extending load that we don't handle!"); - } - break; - case AMDIL::GPRV2I64RegClassID: - // We can be a v2i8, v2i16 or v2i32 bit sign extended value - if (isNbitType(mType, 8, false) || getMemorySize(MI) == 2) { - expandLongExtend(MI, 2, 8, isSExtLoadInst(TM.getInstrInfo(), MI)); - } else if (isNbitType(mType, 16, false) || getMemorySize(MI) == 4) { - expandLongExtend(MI, 2, 16, isSExtLoadInst(TM.getInstrInfo(), MI)); - } else if (isNbitType(mType, 32, false) || getMemorySize(MI) == 8) { - expandLongExtend(MI, 2, 32, isSExtLoadInst(TM.getInstrInfo(), MI)); - } else { - assert(0 && "Found an extending load that we don't handle!"); - } - break; - case AMDIL::GPRF32RegClassID: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::HTOF_f32), AMDIL::R1011) - .addReg(AMDIL::R1011); - break; - case AMDIL::GPRV2F32RegClassID: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::HTOF_v2f32), AMDIL::R1011) - .addReg(AMDIL::R1011); - break; - case AMDIL::GPRV4F32RegClassID: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::HTOF_v4f32), AMDIL::R1011) - .addReg(AMDIL::R1011); - break; - case AMDIL::GPRF64RegClassID: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::FTOD), AMDIL::R1011) - .addReg(AMDIL::R1011); - break; - case AMDIL::GPRV2F64RegClassID: - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VEXTRACT_v2f32), - AMDIL::R1012).addReg(AMDIL::R1011).addImm(2); - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::FTOD), AMDIL::R1011) - .addReg(AMDIL::R1011); - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::FTOD), AMDIL::R1012) - .addReg(AMDIL::R1012); - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::VINSERT_v2f64), AMDIL::R1011) - .addReg(AMDIL::R1011).addReg(AMDIL::R1012) - .addImm(1 << 8).addImm(1 << 8); - break; - }; - } else if (isSWSExtLoadInst(MI)) { - switch(MI->getDesc().OpInfo[0].RegClass) { - case AMDIL::GPRI8RegClassID: - if (!isHardwareLocal(MI) - || mSTM->device()->usesSoftware(AMDILDeviceInfo::ByteLDSOps)) { - expandIntegerExtend(MI, AMDIL::SHL_i8, AMDIL::SHRVEC_i8, 24); - } - break; - case AMDIL::GPRV2I8RegClassID: - expandIntegerExtend(MI, AMDIL::SHL_v2i8, AMDIL::SHRVEC_v2i8, 24); - break; - case AMDIL::GPRV4I8RegClassID: - expandIntegerExtend(MI, AMDIL::SHL_v4i8, AMDIL::SHRVEC_v4i8, 24); - break; - case AMDIL::GPRI16RegClassID: - if (!isHardwareLocal(MI) - || mSTM->device()->usesSoftware(AMDILDeviceInfo::ByteLDSOps)) { - expandIntegerExtend(MI, AMDIL::SHL_i16, AMDIL::SHRVEC_i16, 16); - } - break; - case AMDIL::GPRV2I16RegClassID: - expandIntegerExtend(MI, AMDIL::SHL_v2i16, AMDIL::SHRVEC_v2i16, 16); - break; - case AMDIL::GPRV4I16RegClassID: - expandIntegerExtend(MI, AMDIL::SHL_v4i16, AMDIL::SHRVEC_v4i16, 16); - break; - - }; - } -} - - void -AMDILIOExpansion::expandTruncData(MachineInstr *MI) -{ - MachineBasicBlock::iterator I = *MI; - if (!isTruncStoreInst(TM.getInstrInfo(), MI)) { - return; - } - DebugLoc DL = MI->getDebugLoc(); - switch (MI->getOpcode()) { - default: - MI->dump(); - assert(!"Found a trunc store instructions we don't handle!"); - break; - case AMDIL::GLOBALTRUNCSTORE_i64i8: - case AMDIL::GLOBALTRUNCSTORE_v2i64i8: - case AMDIL::LOCALTRUNCSTORE_i64i8: - case AMDIL::LOCALTRUNCSTORE_v2i64i8: - case AMDIL::REGIONTRUNCSTORE_i64i8: - case AMDIL::REGIONTRUNCSTORE_v2i64i8: - case AMDIL::PRIVATETRUNCSTORE_i64i8: - case AMDIL::PRIVATETRUNCSTORE_v2i64i8: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::LLO_v2i64), AMDIL::R1011) - .addReg(AMDIL::R1011); - case AMDIL::GLOBALTRUNCSTORE_i16i8: - case AMDIL::GLOBALTRUNCSTORE_v2i16i8: - case AMDIL::GLOBALTRUNCSTORE_v4i16i8: - case AMDIL::LOCALTRUNCSTORE_i16i8: - case AMDIL::LOCALTRUNCSTORE_v2i16i8: - case AMDIL::LOCALTRUNCSTORE_v4i16i8: - case AMDIL::REGIONTRUNCSTORE_i16i8: - case AMDIL::REGIONTRUNCSTORE_v2i16i8: - case AMDIL::REGIONTRUNCSTORE_v4i16i8: - case AMDIL::PRIVATETRUNCSTORE_i16i8: - case AMDIL::PRIVATETRUNCSTORE_v2i16i8: - case AMDIL::PRIVATETRUNCSTORE_v4i16i8: - case AMDIL::GLOBALTRUNCSTORE_i32i8: - case AMDIL::GLOBALTRUNCSTORE_v2i32i8: - case AMDIL::GLOBALTRUNCSTORE_v4i32i8: - case AMDIL::LOCALTRUNCSTORE_i32i8: - case AMDIL::LOCALTRUNCSTORE_v2i32i8: - case AMDIL::LOCALTRUNCSTORE_v4i32i8: - case AMDIL::REGIONTRUNCSTORE_i32i8: - case AMDIL::REGIONTRUNCSTORE_v2i32i8: - case AMDIL::REGIONTRUNCSTORE_v4i32i8: - case AMDIL::PRIVATETRUNCSTORE_i32i8: - case AMDIL::PRIVATETRUNCSTORE_v2i32i8: - case AMDIL::PRIVATETRUNCSTORE_v4i32i8: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::BINARY_AND_v4i32), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(0xFF)); - break; - case AMDIL::GLOBALTRUNCSTORE_i64i16: - case AMDIL::GLOBALTRUNCSTORE_v2i64i16: - case AMDIL::LOCALTRUNCSTORE_i64i16: - case AMDIL::LOCALTRUNCSTORE_v2i64i16: - case AMDIL::REGIONTRUNCSTORE_i64i16: - case AMDIL::REGIONTRUNCSTORE_v2i64i16: - case AMDIL::PRIVATETRUNCSTORE_i64i16: - case AMDIL::PRIVATETRUNCSTORE_v2i64i16: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::LLO_v2i64), AMDIL::R1011) - .addReg(AMDIL::R1011); - case AMDIL::GLOBALTRUNCSTORE_i32i16: - case AMDIL::GLOBALTRUNCSTORE_v2i32i16: - case AMDIL::GLOBALTRUNCSTORE_v4i32i16: - case AMDIL::LOCALTRUNCSTORE_i32i16: - case AMDIL::LOCALTRUNCSTORE_v2i32i16: - case AMDIL::LOCALTRUNCSTORE_v4i32i16: - case AMDIL::REGIONTRUNCSTORE_i32i16: - case AMDIL::REGIONTRUNCSTORE_v2i32i16: - case AMDIL::REGIONTRUNCSTORE_v4i32i16: - case AMDIL::PRIVATETRUNCSTORE_i32i16: - case AMDIL::PRIVATETRUNCSTORE_v2i32i16: - case AMDIL::PRIVATETRUNCSTORE_v4i32i16: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::BINARY_AND_v4i32), AMDIL::R1011) - .addReg(AMDIL::R1011) - .addImm(mMFI->addi32Literal(0xFFFF)); - break; - case AMDIL::GLOBALTRUNCSTORE_i64i32: - case AMDIL::LOCALTRUNCSTORE_i64i32: - case AMDIL::REGIONTRUNCSTORE_i64i32: - case AMDIL::PRIVATETRUNCSTORE_i64i32: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::LLO), AMDIL::R1011) - .addReg(AMDIL::R1011); - break; - case AMDIL::GLOBALTRUNCSTORE_v2i64i32: - case AMDIL::LOCALTRUNCSTORE_v2i64i32: - case AMDIL::REGIONTRUNCSTORE_v2i64i32: - case AMDIL::PRIVATETRUNCSTORE_v2i64i32: - BuildMI(*mBB, MI, DL, - mTII->get(AMDIL::LLO_v2i64), AMDIL::R1011) - .addReg(AMDIL::R1011); - break; - case AMDIL::GLOBALTRUNCSTORE_f64f32: - case AMDIL::LOCALTRUNCSTORE_f64f32: - case AMDIL::REGIONTRUNCSTORE_f64f32: - case AMDIL::PRIVATETRUNCSTORE_f64f32: - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::DTOF), - AMDIL::R1011).addReg(AMDIL::R1011); - break; - case AMDIL::GLOBALTRUNCSTORE_v2f64f32: - case AMDIL::LOCALTRUNCSTORE_v2f64f32: - case AMDIL::REGIONTRUNCSTORE_v2f64f32: - case AMDIL::PRIVATETRUNCSTORE_v2f64f32: - BuildMI(*mBB, I, DL, mTII->get(AMDIL::VEXTRACT_v2f64), - AMDIL::R1012).addReg(AMDIL::R1011).addImm(2); - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::DTOF), - AMDIL::R1011).addReg(AMDIL::R1011); - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::DTOF), - AMDIL::R1012).addReg(AMDIL::R1012); - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VINSERT_v2f32), - AMDIL::R1011).addReg(AMDIL::R1011).addReg(AMDIL::R1012) - .addImm(1 << 8).addImm(1 << 8); - break; - } -} - void -AMDILIOExpansion::expandAddressCalc(MachineInstr *MI) -{ - if (!isAddrCalcInstr(MI)) { - return; - } - DebugLoc DL = MI->getDebugLoc(); - switch(MI->getOpcode()) { - ExpandCaseToAllTruncTypes(AMDIL::PRIVATETRUNCSTORE) - ExpandCaseToAllTypes(AMDIL::PRIVATESTORE) - ExpandCaseToAllTypes(AMDIL::PRIVATELOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATESEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATEZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::PRIVATEAEXTLOAD) - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_i32), - AMDIL::R1010).addReg(AMDIL::R1010).addReg(AMDIL::T1); - break; - ExpandCaseToAllTruncTypes(AMDIL::LOCALTRUNCSTORE) - ExpandCaseToAllTypes(AMDIL::LOCALLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALAEXTLOAD) - ExpandCaseToAllTypes(AMDIL::LOCALSTORE) - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_i32), - AMDIL::R1010).addReg(AMDIL::R1010).addReg(AMDIL::T2); - break; - ExpandCaseToAllTypes(AMDIL::CPOOLLOAD) - ExpandCaseToAllTypes(AMDIL::CPOOLSEXTLOAD) - ExpandCaseToAllTypes(AMDIL::CPOOLZEXTLOAD) - ExpandCaseToAllTypes(AMDIL::CPOOLAEXTLOAD) - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_i32), - AMDIL::R1010).addReg(AMDIL::R1010).addReg(AMDIL::SDP); - break; - default: - return; - } -} - void -AMDILIOExpansion::expandLoadStartCode(MachineInstr *MI) -{ - DebugLoc DL = MI->getDebugLoc(); - if (MI->getOperand(2).isReg()) { - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::ADD_i32), - AMDIL::R1010).addReg(MI->getOperand(1).getReg()) - .addReg(MI->getOperand(2).getReg()); - } else { - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::MOVE_i32), - AMDIL::R1010).addReg(MI->getOperand(1).getReg()); - } - MI->getOperand(1).setReg(AMDIL::R1010); - expandAddressCalc(MI); -} - void -AMDILIOExpansion::emitStaticCPLoad(MachineInstr* MI, int swizzle, - int id, bool ExtFPLoad) -{ - DebugLoc DL = MI->getDebugLoc(); - switch(swizzle) { - default: - BuildMI(*mBB, MI, DL, mTII->get(ExtFPLoad - ? AMDIL::DTOF : AMDIL::MOVE_i32), - MI->getOperand(0).getReg()) - .addImm(id); - break; - case 1: - case 2: - case 3: - BuildMI(*mBB, MI, DL, mTII->get(ExtFPLoad - ? AMDIL::DTOF : AMDIL::MOVE_i32), AMDIL::R1001) - .addImm(id); - BuildMI(*mBB, MI, DL, mTII->get(AMDIL::VINSERT_v4i32), - MI->getOperand(0).getReg()) - .addReg(MI->getOperand(0).getReg()) - .addReg(AMDIL::R1001) - .addImm(swizzle + 1); - break; - }; -} - void -AMDILIOExpansion::emitCPInst(MachineInstr* MI, - const Constant* C, AMDILKernelManager* KM, int swizzle, bool ExtFPLoad) -{ - if (const ConstantFP* CFP = dyn_cast<ConstantFP>(C)) { - if (CFP->getType()->isFloatTy()) { - uint32_t val = (uint32_t)(CFP->getValueAPF().bitcastToAPInt() - .getZExtValue()); - uint32_t id = mMFI->addi32Literal(val); - if (!id) { - const APFloat &APF = CFP->getValueAPF(); - union dtol_union { - double d; - uint64_t ul; - } conv; - if (&APF.getSemantics() - == (const llvm::fltSemantics*)&APFloat::IEEEsingle) { - float fval = APF.convertToFloat(); - conv.d = (double)fval; - } else { - conv.d = APF.convertToDouble(); - } - id = mMFI->addi64Literal(conv.ul); - } - emitStaticCPLoad(MI, swizzle, id, ExtFPLoad); - } else { - const APFloat &APF = CFP->getValueAPF(); - union ftol_union { - double d; - uint64_t ul; - } conv; - if (&APF.getSemantics() - == (const llvm::fltSemantics*)&APFloat::IEEEsingle) { - float fval = APF.convertToFloat(); - conv.d = (double)fval; - } else { - conv.d = APF.convertToDouble(); - } - uint32_t id = mMFI->getLongLits(conv.ul); - if (!id) { - id = mMFI->getIntLits((uint32_t)conv.ul); - } - emitStaticCPLoad(MI, swizzle, id, ExtFPLoad); - } - } else if (const ConstantInt* CI = dyn_cast<ConstantInt>(C)) { - int64_t val = 0; - if (CI) { - val = CI->getSExtValue(); - } - if (CI->getBitWidth() == 64) { - emitStaticCPLoad(MI, swizzle, mMFI->addi64Literal(val), ExtFPLoad); - } else { - emitStaticCPLoad(MI, swizzle, mMFI->addi32Literal(val), ExtFPLoad); - } - } else if (const ConstantArray* CA = dyn_cast<ConstantArray>(C)) { - uint32_t size = CA->getNumOperands(); - assert(size < 5 && "Cannot handle a constant array where size > 4"); - if (size > 4) { - size = 4; - } - for (uint32_t x = 0; x < size; ++x) { - emitCPInst(MI, CA->getOperand(0), KM, x, ExtFPLoad); - } - } else if (const ConstantAggregateZero* CAZ - = dyn_cast<ConstantAggregateZero>(C)) { - if (CAZ->isNullValue()) { - emitStaticCPLoad(MI, swizzle, mMFI->addi32Literal(0), ExtFPLoad); - } - } else if (const ConstantStruct* CS = dyn_cast<ConstantStruct>(C)) { - uint32_t size = CS->getNumOperands(); - assert(size < 5 && "Cannot handle a constant array where size > 4"); - if (size > 4) { - size = 4; - } - for (uint32_t x = 0; x < size; ++x) { - emitCPInst(MI, CS->getOperand(0), KM, x, ExtFPLoad); - } - } else if (const ConstantVector* CV = dyn_cast<ConstantVector>(C)) { - // TODO: Make this handle vectors natively up to the correct - // size - uint32_t size = CV->getNumOperands(); - assert(size < 5 && "Cannot handle a constant array where size > 4"); - if (size > 4) { - size = 4; - } - for (uint32_t x = 0; x < size; ++x) { - emitCPInst(MI, CV->getOperand(0), KM, x, ExtFPLoad); - } - } else { - // TODO: Do we really need to handle ConstantPointerNull? - // What about BlockAddress, ConstantExpr and Undef? - // How would these even be generated by a valid CL program? - assert(0 && "Found a constant type that I don't know how to handle"); - } -} - |