RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-19 18:10:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[ConstantHoisting][X86] Improve the cost model for small constants with large types (i64 and above).

Browse Source 
This improves the X86 cost model for small constants with large types. Before
this commit we would even hoist trivial constants such as i96 2.

This is related to <rdar://problem/17070936>

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210504 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Juergen Ributzka 2014-06-10 00:32:29 +00:00
parent 9de6eef6d0
commit 8b9e31c6e2
3 changed files with 47 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
lib/Target/X86/X86TargetTransformInfo.cpp
View File

@ -102,6 +102,8 @@ public:
unsigned getReductionCost(unsigned Opcode, Type *Ty,
bool IsPairwiseForm) const override;
unsigned getIntImmCost(int64_t) const;
unsigned getIntImmCost(const APInt &Imm, Type *Ty) const override;
unsigned getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
@ -808,6 +810,19 @@ unsigned X86TTI::getReductionCost(unsigned Opcode, Type *ValTy,
return TargetTransformInfo::getReductionCost(Opcode, ValTy, IsPairwise);
}
/// \brief Calculate the cost of materializing a 64-bit value. This helper
/// method might only calculate a fraction of a larger immediate. Therefore it
/// is valid to return a cost of ZERO.
unsigned X86TTI::getIntImmCost(int64_t Val) const {
if (Val == 0)
return TCC_Free;
if (isInt<32>(Val))
return TCC_Basic;
return 2 * TCC_Basic;
}
unsigned X86TTI::getIntImmCost(const APInt &Imm, Type *Ty) const {
assert(Ty->isIntegerTy());
@ -825,11 +840,21 @@ unsigned X86TTI::getIntImmCost(const APInt &Imm, Type *Ty) const {
if (Imm == 0)
return TCC_Free;
if (Imm.getBitWidth() <= 64 &&
(isInt<32>(Imm.getSExtValue()) || isUInt<32>(Imm.getZExtValue())))
return TCC_Basic;
else
return 2 * TCC_Basic;
// Sign-extend all constants to a multiple of 64-bit.
APInt ImmVal = Imm;
if (BitSize & 0x3f)
ImmVal = Imm.sext((BitSize + 63) & ~0x3fU);
// Split the constant into 64-bit chunks and calculate the cost for each
// chunk.
unsigned Cost = 0;
for (unsigned ShiftVal = 0; ShiftVal < BitSize; ShiftVal += 64) {
APInt Tmp = ImmVal.ashr(ShiftVal).sextOrTrunc(64);
int64_t Val = Tmp.getSExtValue();
Cost += getIntImmCost(Val);
}
// We need at least one instruction to materialze the constant.
return std::max(1U, Cost);
}
unsigned X86TTI::getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
@ -889,9 +914,11 @@ unsigned X86TTI::getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm,
break;
}
if ((Idx == ImmIdx) &&
Imm.getBitWidth() <= 64 && isInt<32>(Imm.getSExtValue()))
return TCC_Free;
if (Idx == ImmIdx) {
unsigned NumConstants = (BitSize + 63) / 64;
unsigned Cost = X86TTI::getIntImmCost(Imm, Ty);
return (Cost <= NumConstants * TCC_Basic) ? TCC_Free : Cost;
}
return X86TTI::getIntImmCost(Imm, Ty);
}

9
test/Transforms/ConstantHoisting/X86/large-immediate.ll
View File

@ -25,3 +25,12 @@ define i196 @test3(i196 %a) nounwind {
%2 = mul i196 %1, 2
ret i196 %2
}
; Check that we don't hoist immediates with small values.
define i96 @test4(i96 %a) nounwind {
; CHECK-LABEL: test4
; CHECK-NOT: %const = bitcast i96 2 to i96
%1 = mul i96 %a, 2
%2 = add i96 %1, 2
ret i96 %2
}

6
test/Transforms/ConstantHoisting/X86/stackmap.ll
View File

@ -6,11 +6,11 @@ target triple = "x86_64-apple-macosx10.9.0"
; Test if the 3rd argument of a stackmap is hoisted.
define i128 @test1(i128 %a) {
; CHECK-LABEL: @test1
; CHECK: %const = bitcast i128 13464618275673403322 to i128
; CHECK: %const = bitcast i128 134646182756734033220 to i128
; CHECK: tail call void (i64, i32, ...)* @llvm.experimental.stackmap(i64 1, i32 24, i128 %const)
entry:
%0 = add i128 %a, 13464618275673403322
tail call void (i64, i32, ...)* @llvm.experimental.stackmap(i64 1, i32 24, i128 13464618275673403322)
%0 = add i128 %a, 134646182756734033220
tail call void (i64, i32, ...)* @llvm.experimental.stackmap(i64 1, i32 24, i128 134646182756734033220)
ret i128 %0
}