Subzero: Simplify the constant pools.
Internally, create a separate constant pool for each integer type, instead of a single i64 pool that uses the Ice::Type value as part of the key. This means each constant pool key can be a simple primitive value, rather than a tuple.
Represent the pools using std::unordered_map instead of std::map since we're using C++11 now.
Use signed integers instead of unsigned integers for the integer constant pools, to benefit from sign extension and to be more consistent.
Remove the SuppressMangling field from hash and comparison functions on RelocatableTuple, since we'll never have two symbols with the same name but different values of SuppressMangling.
BUG= none
R=jvoung@chromium.org
Review URL: https://codereview.chromium.org/737513008
diff --git a/src/IceConverter.cpp b/src/IceConverter.cpp
index 3c46496..4eb0343 100644
--- a/src/IceConverter.cpp
+++ b/src/IceConverter.cpp
@@ -116,16 +116,11 @@
if (const auto GV = dyn_cast<GlobalValue>(Const)) {
Ice::GlobalDeclaration *Decl = getConverter().getGlobalDeclaration(GV);
const Ice::RelocOffsetT Offset = 0;
- return Ctx->getConstantSym(TypeConverter.getIcePointerType(),
- Offset, Decl->getName(),
+ return Ctx->getConstantSym(Offset, Decl->getName(),
Decl->getSuppressMangling());
} else if (const auto CI = dyn_cast<ConstantInt>(Const)) {
Ice::Type Ty = convertToIceType(CI->getType());
- if (Ty == Ice::IceType_i64) {
- return Ctx->getConstantInt64(Ty, CI->getSExtValue());
- } else {
- return Ctx->getConstantInt32(Ty, CI->getSExtValue());
- }
+ return Ctx->getConstantInt(Ty, CI->getSExtValue());
} else if (const auto CFP = dyn_cast<ConstantFP>(Const)) {
Ice::Type Type = convertToIceType(CFP->getType());
if (Type == Ice::IceType_f32)
diff --git a/src/IceGlobalContext.cpp b/src/IceGlobalContext.cpp
index 95378ca..8b345d4 100644
--- a/src/IceGlobalContext.cpp
+++ b/src/IceGlobalContext.cpp
@@ -14,6 +14,7 @@
#include <ctype.h> // isdigit(), isupper()
#include <locale> // locale
+#include <unordered_map>
#include "IceCfg.h"
#include "IceClFlags.h"
@@ -25,29 +26,29 @@
#include "IceTimerTree.h"
#include "IceTypes.h"
+template <> struct std::hash<Ice::RelocatableTuple> {
+ std::size_t operator()(const Ice::RelocatableTuple &Key) const {
+ return std::hash<Ice::IceString>()(Key.Name) +
+ std::hash<Ice::RelocOffsetT>()(Key.Offset);
+ }
+};
+
namespace Ice {
// TypePool maps constants of type KeyType (e.g. float) to pointers to
-// type ValueType (e.g. ConstantFloat). KeyType values are compared
-// using memcmp() because of potential NaN values in KeyType values.
-// KeyTypeHasFP indicates whether KeyType is a floating-point type
-// whose values need to be compared using memcmp() for NaN
-// correctness. TODO: use std::is_floating_point<KeyType> instead of
-// KeyTypeHasFP with C++11.
-template <typename KeyType, typename ValueType, bool KeyTypeHasFP = false>
-class TypePool {
+// type ValueType (e.g. ConstantFloat).
+template <Type Ty, typename KeyType, typename ValueType> class TypePool {
TypePool(const TypePool &) = delete;
TypePool &operator=(const TypePool &) = delete;
public:
TypePool() : NextPoolID(0) {}
- ValueType *getOrAdd(GlobalContext *Ctx, Type Ty, KeyType Key) {
- TupleType TupleKey = std::make_pair(Ty, Key);
- auto Iter = Pool.find(TupleKey);
+ ValueType *getOrAdd(GlobalContext *Ctx, KeyType Key) {
+ auto Iter = Pool.find(Key);
if (Iter != Pool.end())
return Iter->second;
ValueType *Result = ValueType::create(Ctx, Ty, Key, NextPoolID++);
- Pool[TupleKey] = Result;
+ Pool[Key] = Result;
return Result;
}
ConstantList getConstantPool() const {
@@ -59,17 +60,7 @@
}
private:
- typedef std::pair<Type, KeyType> TupleType;
- struct TupleCompare {
- bool operator()(const TupleType &A, const TupleType &B) const {
- if (A.first != B.first)
- return A.first < B.first;
- if (KeyTypeHasFP)
- return memcmp(&A.second, &B.second, sizeof(KeyType)) < 0;
- return A.second < B.second;
- }
- };
- typedef std::map<const TupleType, ValueType *, TupleCompare> ContainerType;
+ typedef std::unordered_map<KeyType, ValueType *> ContainerType;
ContainerType Pool;
uint32_t NextPoolID;
};
@@ -80,21 +71,17 @@
UndefPool &operator=(const UndefPool &) = delete;
public:
- UndefPool() : NextPoolID(0) {}
+ UndefPool() : NextPoolID(0), Pool(IceType_NUM) {}
ConstantUndef *getOrAdd(GlobalContext *Ctx, Type Ty) {
- auto I = Pool.find(Ty);
- if (I != Pool.end())
- return I->second;
- ConstantUndef *Undef = ConstantUndef::create(Ctx, Ty, NextPoolID++);
- Pool[Ty] = Undef;
- return Undef;
+ if (Pool[Ty] == NULL)
+ Pool[Ty] = ConstantUndef::create(Ctx, Ty, NextPoolID++);
+ return Pool[Ty];
}
private:
uint32_t NextPoolID;
- typedef std::map<Type, ConstantUndef *> ContainerType;
- ContainerType Pool;
+ std::vector<ConstantUndef *> Pool;
};
// The global constant pool bundles individual pools of each type of
@@ -105,11 +92,14 @@
public:
ConstantPool() {}
- TypePool<float, ConstantFloat, true> Floats;
- TypePool<double, ConstantDouble, true> Doubles;
- TypePool<uint32_t, ConstantInteger32> Integers32;
- TypePool<uint64_t, ConstantInteger64> Integers64;
- TypePool<RelocatableTuple, ConstantRelocatable> Relocatables;
+ TypePool<IceType_f32, float, ConstantFloat> Floats;
+ TypePool<IceType_f64, double, ConstantDouble> Doubles;
+ TypePool<IceType_i1, int8_t, ConstantInteger32> Integers1;
+ TypePool<IceType_i8, int8_t, ConstantInteger32> Integers8;
+ TypePool<IceType_i16, int16_t, ConstantInteger32> Integers16;
+ TypePool<IceType_i32, int32_t, ConstantInteger32> Integers32;
+ TypePool<IceType_i64, int64_t, ConstantInteger64> Integers64;
+ TypePool<IceType_i32, RelocatableTuple, ConstantRelocatable> Relocatables;
UndefPool Undefs;
};
@@ -294,30 +284,58 @@
llvm::DeleteContainerPointers(GlobalDeclarations);
}
-Constant *GlobalContext::getConstantInt64(Type Ty, uint64_t ConstantInt64) {
- assert(Ty == IceType_i64);
- return ConstPool->Integers64.getOrAdd(this, Ty, ConstantInt64);
+Constant *GlobalContext::getConstantInt(Type Ty, int64_t Value) {
+ switch (Ty) {
+ case IceType_i1:
+ return getConstantInt1(Value);
+ case IceType_i8:
+ return getConstantInt8(Value);
+ case IceType_i16:
+ return getConstantInt16(Value);
+ case IceType_i32:
+ return getConstantInt32(Value);
+ case IceType_i64:
+ return getConstantInt64(Value);
+ default:
+ llvm_unreachable("Bad integer type for getConstant");
+ }
+ return NULL;
}
-Constant *GlobalContext::getConstantInt32(Type Ty, uint32_t ConstantInt32) {
- if (Ty == IceType_i1)
- ConstantInt32 &= UINT32_C(1);
- return ConstPool->Integers32.getOrAdd(this, Ty, ConstantInt32);
+Constant *GlobalContext::getConstantInt1(int8_t ConstantInt1) {
+ ConstantInt1 &= INT8_C(1);
+ return ConstPool->Integers1.getOrAdd(this, ConstantInt1);
+}
+
+Constant *GlobalContext::getConstantInt8(int8_t ConstantInt8) {
+ return ConstPool->Integers8.getOrAdd(this, ConstantInt8);
+}
+
+Constant *GlobalContext::getConstantInt16(int16_t ConstantInt16) {
+ return ConstPool->Integers16.getOrAdd(this, ConstantInt16);
+}
+
+Constant *GlobalContext::getConstantInt32(int32_t ConstantInt32) {
+ return ConstPool->Integers32.getOrAdd(this, ConstantInt32);
+}
+
+Constant *GlobalContext::getConstantInt64(int64_t ConstantInt64) {
+ return ConstPool->Integers64.getOrAdd(this, ConstantInt64);
}
Constant *GlobalContext::getConstantFloat(float ConstantFloat) {
- return ConstPool->Floats.getOrAdd(this, IceType_f32, ConstantFloat);
+ return ConstPool->Floats.getOrAdd(this, ConstantFloat);
}
Constant *GlobalContext::getConstantDouble(double ConstantDouble) {
- return ConstPool->Doubles.getOrAdd(this, IceType_f64, ConstantDouble);
+ return ConstPool->Doubles.getOrAdd(this, ConstantDouble);
}
-Constant *GlobalContext::getConstantSym(Type Ty, RelocOffsetT Offset,
+Constant *GlobalContext::getConstantSym(RelocOffsetT Offset,
const IceString &Name,
bool SuppressMangling) {
return ConstPool->Relocatables.getOrAdd(
- this, Ty, RelocatableTuple(Offset, Name, SuppressMangling));
+ this, RelocatableTuple(Offset, Name, SuppressMangling));
}
Constant *GlobalContext::getConstantUndef(Type Ty) {
@@ -327,12 +345,15 @@
Constant *GlobalContext::getConstantZero(Type Ty) {
switch (Ty) {
case IceType_i1:
+ return getConstantInt1(0);
case IceType_i8:
+ return getConstantInt8(0);
case IceType_i16:
+ return getConstantInt16(0);
case IceType_i32:
- return getConstantInt32(Ty, 0);
+ return getConstantInt32(0);
case IceType_i64:
- return getConstantInt64(Ty, 0);
+ return getConstantInt64(0);
case IceType_f32:
return getConstantFloat(0);
case IceType_f64:
diff --git a/src/IceGlobalContext.h b/src/IceGlobalContext.h
index 43f65ad..eeed6af 100644
--- a/src/IceGlobalContext.h
+++ b/src/IceGlobalContext.h
@@ -113,14 +113,17 @@
// Manage Constants.
// getConstant*() functions are not const because they might add
// something to the constant pool.
- Constant *getConstantInt32(Type Ty, uint32_t ConstantInt32);
- Constant *getConstantInt64(Type Ty, uint64_t ConstantInt64);
+ Constant *getConstantInt(Type Ty, int64_t Value);
+ Constant *getConstantInt1(int8_t ConstantInt1);
+ Constant *getConstantInt8(int8_t ConstantInt8);
+ Constant *getConstantInt16(int16_t ConstantInt16);
+ Constant *getConstantInt32(int32_t ConstantInt32);
+ Constant *getConstantInt64(int64_t ConstantInt64);
Constant *getConstantFloat(float Value);
Constant *getConstantDouble(double Value);
// Returns a symbolic constant.
- Constant *getConstantSym(Type Ty, RelocOffsetT Offset,
- const IceString &Name = "",
- bool SuppressMangling = false);
+ Constant *getConstantSym(RelocOffsetT Offset, const IceString &Name,
+ bool SuppressMangling);
// Returns an undef.
Constant *getConstantUndef(Type Ty);
// Returns a zero value.
diff --git a/src/IceOperand.cpp b/src/IceOperand.cpp
index 583a6bc..3aaecac 100644
--- a/src/IceOperand.cpp
+++ b/src/IceOperand.cpp
@@ -20,12 +20,8 @@
namespace Ice {
-bool operator<(const RelocatableTuple &A, const RelocatableTuple &B) {
- if (A.Offset != B.Offset)
- return A.Offset < B.Offset;
- if (A.SuppressMangling != B.SuppressMangling)
- return A.SuppressMangling < B.SuppressMangling;
- return A.Name < B.Name;
+bool operator==(const RelocatableTuple &A, const RelocatableTuple &B) {
+ return A.Offset == B.Offset && A.Name == B.Name;
}
bool operator<(const RegWeight &A, const RegWeight &B) {
diff --git a/src/IceOperand.h b/src/IceOperand.h
index 13e5324..d477ae0 100644
--- a/src/IceOperand.h
+++ b/src/IceOperand.h
@@ -169,8 +169,8 @@
const T Value;
};
-typedef ConstantPrimitive<uint32_t, Operand::kConstInteger32> ConstantInteger32;
-typedef ConstantPrimitive<uint64_t, Operand::kConstInteger64> ConstantInteger64;
+typedef ConstantPrimitive<int32_t, Operand::kConstInteger32> ConstantInteger32;
+typedef ConstantPrimitive<int64_t, Operand::kConstInteger64> ConstantInteger64;
typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
@@ -195,20 +195,20 @@
// ConstantRelocatable can fit into the global constant pool
// template mechanism.
class RelocatableTuple {
- // RelocatableTuple(const RelocatableTuple &) = delete;
RelocatableTuple &operator=(const RelocatableTuple &) = delete;
public:
RelocatableTuple(const RelocOffsetT Offset, const IceString &Name,
bool SuppressMangling)
: Offset(Offset), Name(Name), SuppressMangling(SuppressMangling) {}
+ RelocatableTuple(const RelocatableTuple &) = default;
const RelocOffsetT Offset;
const IceString Name;
bool SuppressMangling;
};
-bool operator<(const RelocatableTuple &A, const RelocatableTuple &B);
+bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
// ConstantRelocatable represents a symbolic constant combined with
// a fixed offset.
diff --git a/src/IceTargetLoweringX8632.cpp b/src/IceTargetLoweringX8632.cpp
index 82d20b4..b96023e 100644
--- a/src/IceTargetLoweringX8632.cpp
+++ b/src/IceTargetLoweringX8632.cpp
@@ -618,8 +618,7 @@
if (Arg->hasReg()) {
assert(Ty != IceType_i64);
OperandX8632Mem *Mem = OperandX8632Mem::create(
- Func, Ty, FramePtr,
- Ctx->getConstantInt32(IceType_i32, Arg->getStackOffset()));
+ Func, Ty, FramePtr, Ctx->getConstantInt32(Arg->getStackOffset()));
if (isVectorType(Arg->getType())) {
_movp(Arg, Mem);
} else {
@@ -839,7 +838,7 @@
// Generate "sub esp, SpillAreaSizeBytes"
if (SpillAreaSizeBytes)
_sub(getPhysicalRegister(RegX8632::Reg_esp),
- Ctx->getConstantInt32(IceType_i32, SpillAreaSizeBytes));
+ Ctx->getConstantInt32(SpillAreaSizeBytes));
Ctx->statsUpdateFrameBytes(SpillAreaSizeBytes);
resetStackAdjustment();
@@ -951,7 +950,7 @@
} else {
// add esp, SpillAreaSizeBytes
if (SpillAreaSizeBytes)
- _add(esp, Ctx->getConstantInt32(IceType_i32, SpillAreaSizeBytes));
+ _add(esp, Ctx->getConstantInt32(SpillAreaSizeBytes));
}
// Add pop instructions for preserved registers.
@@ -1069,8 +1068,7 @@
return Var->getLo();
}
if (ConstantInteger64 *Const = llvm::dyn_cast<ConstantInteger64>(Operand)) {
- return Ctx->getConstantInt32(IceType_i32,
- static_cast<uint32_t>(Const->getValue()));
+ return Ctx->getConstantInt32(static_cast<uint32_t>(Const->getValue()));
}
if (OperandX8632Mem *Mem = llvm::dyn_cast<OperandX8632Mem>(Operand)) {
return OperandX8632Mem::create(Func, IceType_i32, Mem->getBase(),
@@ -1091,20 +1089,21 @@
}
if (ConstantInteger64 *Const = llvm::dyn_cast<ConstantInteger64>(Operand)) {
return Ctx->getConstantInt32(
- IceType_i32, static_cast<uint32_t>(Const->getValue() >> 32));
+ static_cast<uint32_t>(Const->getValue() >> 32));
}
if (OperandX8632Mem *Mem = llvm::dyn_cast<OperandX8632Mem>(Operand)) {
Constant *Offset = Mem->getOffset();
- if (Offset == NULL)
- Offset = Ctx->getConstantInt32(IceType_i32, 4);
- else if (ConstantInteger32 *IntOffset =
- llvm::dyn_cast<ConstantInteger32>(Offset)) {
- Offset = Ctx->getConstantInt32(IceType_i32, 4 + IntOffset->getValue());
+ if (Offset == NULL) {
+ Offset = Ctx->getConstantInt32(4);
+ } else if (ConstantInteger32 *IntOffset =
+ llvm::dyn_cast<ConstantInteger32>(Offset)) {
+ Offset = Ctx->getConstantInt32(4 + IntOffset->getValue());
} else if (ConstantRelocatable *SymOffset =
llvm::dyn_cast<ConstantRelocatable>(Offset)) {
assert(!Utils::WouldOverflowAdd(SymOffset->getOffset(), 4));
- Offset = Ctx->getConstantSym(IceType_i32, 4 + SymOffset->getOffset(),
- SymOffset->getName());
+ Offset =
+ Ctx->getConstantSym(4 + SymOffset->getOffset(), SymOffset->getName(),
+ SymOffset->getSuppressMangling());
}
return OperandX8632Mem::create(Func, IceType_i32, Mem->getBase(), Offset,
Mem->getIndex(), Mem->getShift(),
@@ -1168,20 +1167,20 @@
uint32_t Alignment = std::max(AlignmentParam, X86_STACK_ALIGNMENT_BYTES);
if (Alignment > X86_STACK_ALIGNMENT_BYTES) {
- _and(esp, Ctx->getConstantInt32(IceType_i32, -Alignment));
+ _and(esp, Ctx->getConstantInt32(-Alignment));
}
if (ConstantInteger32 *ConstantTotalSize =
llvm::dyn_cast<ConstantInteger32>(TotalSize)) {
uint32_t Value = ConstantTotalSize->getValue();
Value = applyAlignment(Value, Alignment);
- _sub(esp, Ctx->getConstantInt32(IceType_i32, Value));
+ _sub(esp, Ctx->getConstantInt32(Value));
} else {
// Non-constant sizes need to be adjusted to the next highest
// multiple of the required alignment at runtime.
Variable *T = makeReg(IceType_i32);
_mov(T, TotalSize);
- _add(T, Ctx->getConstantInt32(IceType_i32, Alignment - 1));
- _and(T, Ctx->getConstantInt32(IceType_i32, -Alignment));
+ _add(T, Ctx->getConstantInt32(Alignment - 1));
+ _and(T, Ctx->getConstantInt32(-Alignment));
_sub(esp, T);
}
_mov(Dest, esp);
@@ -1291,7 +1290,7 @@
// a.lo = t2
// a.hi = t3
Variable *T_1 = NULL, *T_2 = NULL, *T_3 = NULL;
- Constant *BitTest = Ctx->getConstantInt32(IceType_i32, 0x20);
+ Constant *BitTest = Ctx->getConstantInt32(0x20);
Constant *Zero = Ctx->getConstantZero(IceType_i32);
InstX8632Label *Label = InstX8632Label::create(Func, this);
_mov(T_1, Src1Lo, RegX8632::Reg_ecx);
@@ -1326,7 +1325,7 @@
// a.lo = t2
// a.hi = t3
Variable *T_1 = NULL, *T_2 = NULL, *T_3 = NULL;
- Constant *BitTest = Ctx->getConstantInt32(IceType_i32, 0x20);
+ Constant *BitTest = Ctx->getConstantInt32(0x20);
Constant *Zero = Ctx->getConstantZero(IceType_i32);
InstX8632Label *Label = InstX8632Label::create(Func, this);
_mov(T_1, Src1Lo, RegX8632::Reg_ecx);
@@ -1361,8 +1360,8 @@
// a.lo = t2
// a.hi = t3
Variable *T_1 = NULL, *T_2 = NULL, *T_3 = NULL;
- Constant *BitTest = Ctx->getConstantInt32(IceType_i32, 0x20);
- Constant *SignExtend = Ctx->getConstantInt32(IceType_i32, 0x1f);
+ Constant *BitTest = Ctx->getConstantInt32(0x20);
+ Constant *SignExtend = Ctx->getConstantInt32(0x1f);
InstX8632Label *Label = InstX8632Label::create(Func, this);
_mov(T_1, Src1Lo, RegX8632::Reg_ecx);
_mov(T_2, Src0Lo);
@@ -1483,7 +1482,7 @@
// Mask that directs pshufd to create a vector with entries
// Src[1, 0, 3, 0]
const unsigned Constant1030 = 0x31;
- Constant *Mask1030 = Ctx->getConstantInt32(IceType_i8, Constant1030);
+ Constant *Mask1030 = Ctx->getConstantInt32(Constant1030);
// Mask that directs shufps to create a vector with entries
// Dest[0, 2], Src[0, 2]
const unsigned Mask0202 = 0x88;
@@ -1499,8 +1498,8 @@
_pshufd(T3, Src1, Mask1030);
_pmuludq(T1, Src1);
_pmuludq(T2, T3);
- _shufps(T1, T2, Ctx->getConstantInt32(IceType_i8, Mask0202));
- _pshufd(T4, T1, Ctx->getConstantInt32(IceType_i8, Mask0213));
+ _shufps(T1, T2, Ctx->getConstantInt32(Mask0202));
+ _pshufd(T4, T1, Ctx->getConstantInt32(Mask0213));
_movp(Dest, T4);
} else {
assert(Dest->getType() == IceType_v16i8);
@@ -1795,8 +1794,7 @@
ParameterAreaSizeBytes = applyStackAlignment(ParameterAreaSizeBytes);
}
Variable *esp = Func->getTarget()->getPhysicalRegister(RegX8632::Reg_esp);
- Constant *Loc =
- Ctx->getConstantInt32(IceType_i32, ParameterAreaSizeBytes);
+ Constant *Loc = Ctx->getConstantInt32(ParameterAreaSizeBytes);
StackArgLocations.push_back(OperandX8632Mem::create(Func, Ty, esp, Loc));
ParameterAreaSizeBytes += typeWidthInBytesOnStack(Arg->getType());
}
@@ -1888,7 +1886,7 @@
// of resetting the stack offset during emission.
if (ParameterAreaSizeBytes) {
Variable *esp = Func->getTarget()->getPhysicalRegister(RegX8632::Reg_esp);
- _add(esp, Ctx->getConstantInt32(IceType_i32, ParameterAreaSizeBytes));
+ _add(esp, Ctx->getConstantInt32(ParameterAreaSizeBytes));
}
// Insert a register-kill pseudo instruction.
@@ -1965,8 +1963,7 @@
// width = width(elty) - 1; dest = (src << width) >> width
SizeT ShiftAmount =
X86_CHAR_BIT * typeWidthInBytes(typeElementType(DestTy)) - 1;
- Constant *ShiftConstant =
- Ctx->getConstantInt32(IceType_i8, ShiftAmount);
+ Constant *ShiftConstant = Ctx->getConstantInt8(ShiftAmount);
Variable *T = makeReg(DestTy);
_movp(T, Src0RM);
_psll(T, ShiftConstant);
@@ -1975,7 +1972,7 @@
}
} else if (Dest->getType() == IceType_i64) {
// t1=movsx src; t2=t1; t2=sar t2, 31; dst.lo=t1; dst.hi=t2
- Constant *Shift = Ctx->getConstantInt32(IceType_i32, 31);
+ Constant *Shift = Ctx->getConstantInt32(31);
Variable *DestLo = llvm::cast<Variable>(loOperand(Dest));
Variable *DestHi = llvm::cast<Variable>(hiOperand(Dest));
Variable *T_Lo = makeReg(DestLo->getType());
@@ -2001,7 +1998,7 @@
// sar t1, dst_bitwidth - 1
// dst = t1
size_t DestBits = X86_CHAR_BIT * typeWidthInBytes(Dest->getType());
- Constant *ShiftAmount = Ctx->getConstantInt32(IceType_i32, DestBits - 1);
+ Constant *ShiftAmount = Ctx->getConstantInt32(DestBits - 1);
Variable *T = makeReg(Dest->getType());
if (typeWidthInBytes(Dest->getType()) <=
typeWidthInBytes(Src0RM->getType())) {
@@ -2044,14 +2041,14 @@
_movzx(Tmp, Src0RM);
}
if (Src0RM->getType() == IceType_i1) {
- Constant *One = Ctx->getConstantInt32(IceType_i32, 1);
+ Constant *One = Ctx->getConstantInt32(1);
_and(Tmp, One);
}
_mov(DestLo, Tmp);
_mov(DestHi, Zero);
} else if (Src0RM->getType() == IceType_i1) {
// t = Src0RM; t &= 1; Dest = t
- Constant *One = Ctx->getConstantInt32(IceType_i32, 1);
+ Constant *One = Ctx->getConstantInt32(1);
Type DestTy = Dest->getType();
Variable *T;
if (DestTy == IceType_i8) {
@@ -2091,7 +2088,7 @@
Variable *T = NULL;
_mov(T, Src0RM);
if (Dest->getType() == IceType_i1)
- _and(T, Ctx->getConstantInt32(IceType_i1, 1));
+ _and(T, Ctx->getConstantInt1(1));
_mov(Dest, T);
}
break;
@@ -2137,7 +2134,7 @@
_cvt(T_1, Src0RM, InstX8632Cvt::Tss2si);
_mov(T_2, T_1); // T_1 and T_2 may have different integer types
if (Dest->getType() == IceType_i1)
- _and(T_2, Ctx->getConstantInt32(IceType_i1, 1));
+ _and(T_2, Ctx->getConstantInt1(1));
_mov(Dest, T_2);
}
break;
@@ -2173,7 +2170,7 @@
_cvt(T_1, Src0RM, InstX8632Cvt::Tss2si);
_mov(T_2, T_1); // T_1 and T_2 may have different integer types
if (Dest->getType() == IceType_i1)
- _and(T_2, Ctx->getConstantInt32(IceType_i1, 1));
+ _and(T_2, Ctx->getConstantInt1(1));
_mov(Dest, T_2);
}
break;
@@ -2402,7 +2399,7 @@
Ty == IceType_v8i16 || Ty == IceType_v8i1 || InstructionSet >= SSE4_1;
if (CanUsePextr && Ty != IceType_v4f32) {
// Use pextrb, pextrw, or pextrd.
- Constant *Mask = Ctx->getConstantInt32(IceType_i8, Index);
+ Constant *Mask = Ctx->getConstantInt32(Index);
Variable *SourceVectR = legalizeToVar(SourceVectNotLegalized);
_pextr(ExtractedElementR, SourceVectR, Mask);
} else if (Ty == IceType_v4i32 || Ty == IceType_v4f32 || Ty == IceType_v4i1) {
@@ -2411,7 +2408,7 @@
if (Index) {
// The shuffle only needs to occur if the element to be extracted
// is not at the lowest index.
- Constant *Mask = Ctx->getConstantInt32(IceType_i8, Index);
+ Constant *Mask = Ctx->getConstantInt32(Index);
T = makeReg(Ty);
_pshufd(T, legalize(SourceVectNotLegalized, Legal_Reg | Legal_Mem), Mask);
} else {
@@ -2549,8 +2546,7 @@
_mov(T, Src0);
_ucomiss(T, Src1RM);
}
- Constant *Default =
- Ctx->getConstantInt32(IceType_i32, TableFcmp[Index].Default);
+ Constant *Default = Ctx->getConstantInt32(TableFcmp[Index].Default);
_mov(Dest, Default);
if (HasC1) {
InstX8632Label *Label = InstX8632Label::create(Func, this);
@@ -2558,8 +2554,7 @@
if (HasC2) {
_br(TableFcmp[Index].C2, Label);
}
- Constant *NonDefault =
- Ctx->getConstantInt32(IceType_i32, !TableFcmp[Index].Default);
+ Constant *NonDefault = Ctx->getConstantInt32(!TableFcmp[Index].Default);
_mov_nonkillable(Dest, NonDefault);
Context.insert(Label);
}
@@ -2700,7 +2695,7 @@
// a=icmp cond, b, c ==> cmp b,c; a=1; br cond,L1; FakeUse(a); a=0; L1:
Constant *Zero = Ctx->getConstantZero(IceType_i32);
- Constant *One = Ctx->getConstantInt32(IceType_i32, 1);
+ Constant *One = Ctx->getConstantInt32(1);
if (Src0->getType() == IceType_i64) {
InstIcmp::ICond Condition = Inst->getCondition();
size_t Index = static_cast<size_t>(Condition);
@@ -2778,9 +2773,9 @@
Variable *T = makeReg(Ty);
_movp(T, SourceVectRM);
if (Ty == IceType_v4f32)
- _insertps(T, ElementRM, Ctx->getConstantInt32(IceType_i8, Index << 4));
+ _insertps(T, ElementRM, Ctx->getConstantInt32(Index << 4));
else
- _pinsr(T, ElementRM, Ctx->getConstantInt32(IceType_i8, Index));
+ _pinsr(T, ElementRM, Ctx->getConstantInt32(Index));
_movp(Inst->getDest(), T);
} else if (Ty == IceType_v4i32 || Ty == IceType_v4f32 || Ty == IceType_v4i1) {
// Use shufps or movss.
@@ -2831,10 +2826,8 @@
const unsigned char Mask1[3] = { 0, 192, 128 };
const unsigned char Mask2[3] = { 227, 196, 52 };
- Constant *Mask1Constant =
- Ctx->getConstantInt32(IceType_i8, Mask1[Index - 1]);
- Constant *Mask2Constant =
- Ctx->getConstantInt32(IceType_i8, Mask2[Index - 1]);
+ Constant *Mask1Constant = Ctx->getConstantInt32(Mask1[Index - 1]);
+ Constant *Mask2Constant = Ctx->getConstantInt32(Mask2[Index - 1]);
if (Index == 1) {
_shufps(ElementR, SourceVectRM, Mask1Constant);
@@ -2926,7 +2919,7 @@
case 2:
case 4:
case 8:
- Result = Ctx->getConstantInt32(IceType_i32, 1);
+ Result = Ctx->getConstantInt32(1);
break;
}
_mov(Dest, Result);
@@ -3032,7 +3025,7 @@
} else {
assert(Val->getType() == IceType_i16);
Val = legalize(Val);
- Constant *Eight = Ctx->getConstantInt32(IceType_i16, 8);
+ Constant *Eight = Ctx->getConstantInt16(8);
Variable *T = NULL;
_mov(T, Val);
_rol(T, Eight);
@@ -3516,12 +3509,12 @@
_bsr(T, FirstValRM);
}
Variable *T_Dest = makeReg(IceType_i32);
- Constant *ThirtyTwo = Ctx->getConstantInt32(IceType_i32, 32);
- Constant *ThirtyOne = Ctx->getConstantInt32(IceType_i32, 31);
+ Constant *ThirtyTwo = Ctx->getConstantInt32(32);
+ Constant *ThirtyOne = Ctx->getConstantInt32(31);
if (Cttz) {
_mov(T_Dest, ThirtyTwo);
} else {
- Constant *SixtyThree = Ctx->getConstantInt32(IceType_i32, 63);
+ Constant *SixtyThree = Ctx->getConstantInt32(63);
_mov(T_Dest, SixtyThree);
}
_cmov(T_Dest, T, CondX86::Br_ne);
@@ -3860,7 +3853,7 @@
computeAddressOpt(Func, Inst, Base, Index, Shift, Offset);
if (Base && Addr != Base) {
Inst->setDeleted();
- Constant *OffsetOp = Ctx->getConstantInt32(IceType_i32, Offset);
+ Constant *OffsetOp = Ctx->getConstantInt32(Offset);
Addr = OperandX8632Mem::create(Func, Dest->getType(), Base, OffsetOp, Index,
Shift, SegmentReg);
Context.insert(InstLoad::create(Func, Dest, Addr));
@@ -3926,7 +3919,7 @@
Operand *ConditionRM = legalize(Condition, Legal_Reg | Legal_Mem);
Variable *xmm0 = makeReg(IceType_v4i32, RegX8632::Reg_xmm0);
_movp(xmm0, ConditionRM);
- _psll(xmm0, Ctx->getConstantInt32(IceType_i8, 31));
+ _psll(xmm0, Ctx->getConstantInt8(31));
_movp(T, SrcFRM);
_blendvps(T, SrcTRM, xmm0);
_movp(Dest, T);
@@ -4038,7 +4031,7 @@
computeAddressOpt(Func, Inst, Base, Index, Shift, Offset);
if (Base && Addr != Base) {
Inst->setDeleted();
- Constant *OffsetOp = Ctx->getConstantInt32(IceType_i32, Offset);
+ Constant *OffsetOp = Ctx->getConstantInt32(Offset);
Addr = OperandX8632Mem::create(Func, Data->getType(), Base, OffsetOp, Index,
Shift, SegmentReg);
Context.insert(InstStore::create(Func, Data, Addr));
@@ -4062,9 +4055,8 @@
Src0Hi = legalize(Src0Hi, Legal_Reg | Legal_Mem);
}
for (SizeT I = 0; I < NumCases; ++I) {
- Constant *ValueLo = Ctx->getConstantInt32(IceType_i32, Inst->getValue(I));
- Constant *ValueHi =
- Ctx->getConstantInt32(IceType_i32, Inst->getValue(I) >> 32);
+ Constant *ValueLo = Ctx->getConstantInt32(Inst->getValue(I));
+ Constant *ValueHi = Ctx->getConstantInt32(Inst->getValue(I) >> 32);
InstX8632Label *Label = InstX8632Label::create(Func, this);
_cmp(Src0Lo, ValueLo);
_br(CondX86::Br_ne, Label);
@@ -4082,7 +4074,7 @@
else
Src0 = legalize(Src0, Legal_Reg | Legal_Mem);
for (SizeT I = 0; I < NumCases; ++I) {
- Constant *Value = Ctx->getConstantInt32(IceType_i32, Inst->getValue(I));
+ Constant *Value = Ctx->getConstantInt32(Inst->getValue(I));
_cmp(Src0, Value);
_br(CondX86::Br_e, Inst->getLabel(I));
}
@@ -4100,7 +4092,7 @@
Operand *T = Ctx->getConstantUndef(Ty);
for (SizeT I = 0; I < NumElements; ++I) {
- Constant *Index = Ctx->getConstantInt32(IceType_i32, I);
+ Constant *Index = Ctx->getConstantInt32(I);
// Extract the next two inputs.
Variable *Op0 = Func->makeVariable(ElementTy);
@@ -4348,13 +4340,12 @@
if (Ty == IceType_v4f32 || Ty == IceType_v4i32 || Ty == IceType_v8i16) {
Variable *Reg = makeVectorOfOnes(Ty, RegNum);
SizeT Shift = typeWidthInBytes(typeElementType(Ty)) * X86_CHAR_BIT - 1;
- _psll(Reg, Ctx->getConstantInt32(IceType_i8, Shift));
+ _psll(Reg, Ctx->getConstantInt8(Shift));
return Reg;
} else {
// SSE has no left shift operation for vectors of 8 bit integers.
const uint32_t HIGH_ORDER_BITS_MASK = 0x80808080;
- Constant *ConstantMask =
- Ctx->getConstantInt32(IceType_i32, HIGH_ORDER_BITS_MASK);
+ Constant *ConstantMask = Ctx->getConstantInt32(HIGH_ORDER_BITS_MASK);
Variable *Reg = makeReg(Ty, RegNum);
_movd(Reg, legalize(ConstantMask, Legal_Reg | Legal_Mem));
_pshufd(Reg, Reg, Ctx->getConstantZero(IceType_i8));
@@ -4375,7 +4366,7 @@
const Type PointerType = IceType_i32;
Variable *Loc = makeReg(PointerType);
_lea(Loc, Slot);
- Constant *ConstantOffset = Ctx->getConstantInt32(IceType_i32, Offset);
+ Constant *ConstantOffset = Ctx->getConstantInt32(Offset);
return OperandX8632Mem::create(Func, Ty, Loc, ConstantOffset);
}
diff --git a/src/IceTargetLoweringX8632.h b/src/IceTargetLoweringX8632.h
index 74ba287..920d4cd 100644
--- a/src/IceTargetLoweringX8632.h
+++ b/src/IceTargetLoweringX8632.h
@@ -161,11 +161,12 @@
Variable *makeReg(Type Ty, int32_t RegNum = Variable::NoRegister);
InstCall *makeHelperCall(const IceString &Name, Variable *Dest,
SizeT MaxSrcs) {
- bool SuppressMangling = true;
- const Type FunctionPointerType = IceType_i32;
- Constant *CallTarget =
- Ctx->getConstantSym(FunctionPointerType, 0, Name, SuppressMangling);
- InstCall *Call = InstCall::create(Func, MaxSrcs, Dest, CallTarget, false);
+ const bool SuppressMangling = true;
+ const bool HasTailCall = false;
+ const RelocOffsetT Offset = 0;
+ Constant *CallTarget = Ctx->getConstantSym(Offset, Name, SuppressMangling);
+ InstCall *Call =
+ InstCall::create(Func, MaxSrcs, Dest, CallTarget, HasTailCall);
return Call;
}
static Type stackSlotType();
diff --git a/src/PNaClTranslator.cpp b/src/PNaClTranslator.cpp
index 0f4feac..042b7fe 100644
--- a/src/PNaClTranslator.cpp
+++ b/src/PNaClTranslator.cpp
@@ -325,8 +325,8 @@
SuppressMangling = false;
}
const Ice::RelocOffsetT Offset = 0;
- C = getTranslator().getContext()->getConstantSym(
- getIcePointerType(), Offset, Name, SuppressMangling);
+ C = getTranslator().getContext()->getConstantSym(Offset, Name,
+ SuppressMangling);
ValueIDConstants[ID] = C;
return C;
}
@@ -1440,7 +1440,7 @@
const auto *C = dyn_cast<Ice::ConstantInteger32>(Index);
if (C == nullptr)
return VectorIndexNotConstant;
- if (C->getValue() >= typeNumElements(VecType))
+ if (static_cast<size_t>(C->getValue()) >= typeNumElements(VecType))
return VectorIndexNotInRange;
if (Index->getType() != Ice::IceType_i32)
return VectorIndexNotI32;
@@ -2496,16 +2496,14 @@
FuncParser->setNextConstantID(nullptr);
return;
}
- if (IntegerType *IType = dyn_cast<IntegerType>(
+ if (auto IType = dyn_cast<IntegerType>(
Context->convertToLLVMType(NextConstantType))) {
APInt Value(IType->getBitWidth(), NaClDecodeSignRotatedValue(Values[0]));
- Ice::Constant *C = (NextConstantType == Ice::IceType_i64)
- ? getContext()->getConstantInt64(
- NextConstantType, Value.getSExtValue())
- : getContext()->getConstantInt32(
- NextConstantType, Value.getSExtValue());
- FuncParser->setNextConstantID(C);
- return;
+ if (Ice::Constant *C = getContext()->getConstantInt(
+ NextConstantType, Value.getSExtValue())) {
+ FuncParser->setNextConstantID(C);
+ return;
+ }
}
std::string Buffer;
raw_string_ostream StrBuf(Buffer);
diff --git a/src/assembler_ia32.cpp b/src/assembler_ia32.cpp
index 8857a57..94263e8 100644
--- a/src/assembler_ia32.cpp
+++ b/src/assembler_ia32.cpp
@@ -60,8 +60,7 @@
StrBuf << ".L$" << Ty << "$" << Imm->getPoolEntryID();
const RelocOffsetT Offset = 0;
const bool SuppressMangling = true;
- Constant *Sym =
- Ctx->getConstantSym(Ty, Offset, StrBuf.str(), SuppressMangling);
+ Constant *Sym = Ctx->getConstantSym(Offset, StrBuf.str(), SuppressMangling);
AssemblerFixup *Fixup = x86::DisplacementRelocation::create(
Asm, FK_Abs_4, llvm::cast<ConstantRelocatable>(Sym));
return x86::Address::Absolute(Fixup);
