RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 11:13:28 +01:00
Code Issues Projects Releases Wiki Activity

CodeGen: Handle ConstantVector and undef in WinCOFF constant pools

Browse Source 
The constant pool entry code for WinCOFF assumed that vector constants
would be formed using ConstantDataVector, it did not expect to see a
ConstantVector.  Furthermore, it did not expect undef as one of the
elements of the vector.

ConstantVectors should be handled like ConstantDataVectors, treat Undef
as zero.

llvm-svn: 213038
This commit is contained in:
David Majnemer 2014-07-15 02:34:12 +00:00
parent a13b19d75f
commit 7f4b6696c1
2 changed files with 38 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
lib/Target/X86/X86TargetObjectFile.cpp
View File

@ -109,7 +109,8 @@ const MCExpr *X86WindowsTargetObjectFile::getExecutableRelativeSymbol(
getContext());
}
static std::string APIntToHexString(const APInt &AI, unsigned Width) {
static std::string APIntToHexString(const APInt &AI) {
unsigned Width = (AI.getBitWidth() / 8) * 2;
std::string HexString = utohexstr(AI.getLimitedValue(), /*LowerCase=*/true);
unsigned Size = HexString.size();
assert(Width >= Size && "hex string is too large!");
@ -121,17 +122,19 @@ static std::string APIntToHexString(const APInt &AI, unsigned Width) {
static std::string scalarConstantToHexString(const Constant *C) {
Type *Ty = C->getType();
if (Ty->isFloatTy()) {
APInt AI;
if (isa<UndefValue>(C)) {
AI = APInt(Ty->getPrimitiveSizeInBits(), /*val=*/0);
} else if (Ty->isFloatTy() || Ty->isDoubleTy()) {
const auto *CFP = cast<ConstantFP>(C);
return APIntToHexString(CFP->getValueAPF().bitcastToAPInt(), /*Width=*/8);
} else if (Ty->isDoubleTy()) {
const auto *CFP = cast<ConstantFP>(C);
return APIntToHexString(CFP->getValueAPF().bitcastToAPInt(), /*Width=*/16);
} else if (const auto *ITy = dyn_cast<IntegerType>(Ty)) {
AI = CFP->getValueAPF().bitcastToAPInt();
} else if (Ty->isIntegerTy()) {
const auto *CI = cast<ConstantInt>(C);
return APIntToHexString(CI->getValue(), (ITy->getBitWidth() / 8) * 2);
AI = CI->getValue();
} else {
llvm_unreachable("unexpected constant pool element type!");
}
llvm_unreachable("unexpected constant pool element type!");
return APIntToHexString(AI);
}
const MCSection *
@ -147,11 +150,16 @@ X86WindowsTargetObjectFile::getSectionForConstant(SectionKind Kind,
} else if (const auto *VTy = dyn_cast<VectorType>(Ty)) {
uint64_t NumBits = VTy->getBitWidth();
if (NumBits == 128 || NumBits == 256) {
const auto *CDV = cast<ConstantDataVector>(C);
COMDATSymName = NumBits == 128 ? "__xmm@" : "__ymm@";
for (int I = CDV->getNumElements() - 1, E = -1; I != E; --I)
COMDATSymName +=
scalarConstantToHexString(CDV->getElementAsConstant(I));
if (const auto *CDV = dyn_cast<ConstantDataVector>(C)) {
for (int I = CDV->getNumElements() - 1, E = -1; I != E; --I)
COMDATSymName +=
scalarConstantToHexString(CDV->getElementAsConstant(I));
} else {
const auto *CV = cast<ConstantVector>(C);
for (int I = CV->getNumOperands() - 1, E = -1; I != E; --I)
COMDATSymName += scalarConstantToHexString(CV->getOperand(I));
}
}
}
if (!COMDATSymName.empty()) {

17
test/CodeGen/X86/win_cst_pool.ll
View File

@ -47,3 +47,20 @@ define <8 x i16> @vec2() {
; CHECK: vec2:
; CHECK: movaps __xmm@00000001000200030004000500060007(%rip), %xmm0
; CHECK-NEXT: ret
define <4 x float> @undef1() {
ret <4 x float> <float 1.0, float 1.0, float undef, float undef>
; CHECK: .globl __xmm@00000000000000003f8000003f800000
; CHECK-NEXT: .section .rdata,"rd",discard,__xmm@00000000000000003f8000003f800000
; CHECK-NEXT: .align 16
; CHECK-NEXT: __xmm@00000000000000003f8000003f800000:
; CHECK-NEXT: .long 1065353216 # float 1
; CHECK-NEXT: .long 1065353216 # float 1
; CHECK-NEXT: .zero 4
; CHECK-NEXT: .zero 4
; CHECK: undef1:
; CHECK: movaps __xmm@00000000000000003f8000003f800000(%rip), %xmm0
; CHECK-NEXT: ret
}