blob: 05580361d92dd6830c4506b3f2afd88cc39bb26d [file] [log] [blame]
//===- subzero/src/IceTypes.h - Primitive ICE types -------------*- C++ -*-===//
// The Subzero Code Generator
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
/// \file
/// \brief Declares a few properties of the primitive types allowed in Subzero.
/// Every Subzero source file is expected to include IceTypes.h.
#include "IceDefs.h"
#include "IceTypes.def"
namespace Ice {
enum Type {
#define X(tag, sizeLog2, align, elts, elty, str, rcstr) IceType_##tag,
#undef X
/// RegClass indicates the physical register class that a Variable may be
/// register-allocated from. By default, a variable's register class is
/// directly associated with its type. However, the target lowering may define
/// additional target-specific register classes by extending the set of enum
/// values.
enum RegClass : uint8_t {
// Define RC_void, RC_i1, RC_i8, etc.
#define X(tag, sizeLog2, align, elts, elty, str, rcstr) \
RC_##tag = IceType_##tag,
#undef X
// Leave plenty of space for target-specific values.
RC_Max = std::numeric_limits<uint8_t>::max()
static_assert(RC_Target == static_cast<RegClass>(IceType_NUM),
"Expected RC_Target and IceType_NUM to be the same");
enum TargetArch {
#define X(tag, str, is_elf64, e_machine, e_flags) tag,
#undef X
const char *targetArchString(TargetArch Arch);
inline Ostream &operator<<(Ostream &Stream, TargetArch Arch) {
return Stream << targetArchString(Arch);
/// The list of all target instruction sets. Individual targets will map this to
/// include only what is valid for the target.
enum TargetInstructionSet {
// Represents baseline that can be assumed for a target (usually "Begin").
X86InstructionSet_SSE2 = X86InstructionSet_Begin,
ARM32InstructionSet_Neon = ARM32InstructionSet_Begin,
enum OptLevel { Opt_m1, Opt_0, Opt_1, Opt_2 };
size_t typeWidthInBytes(Type Ty);
int8_t typeWidthInBytesLog2(Type Ty);
size_t typeAlignInBytes(Type Ty);
size_t typeNumElements(Type Ty);
Type typeElementType(Type Ty);
const char *typeString(Type Ty);
inline std::string typeStdString(Type Ty) { return typeString(Ty); }
const char *regClassString(RegClass C);
Type getPointerType();
bool isVectorType(Type Ty);
bool isBooleanType(Type Ty); // scalar or vector
bool isIntegerType(Type Ty); // scalar or vector
bool isScalarIntegerType(Type Ty);
bool isVectorIntegerType(Type Ty);
bool isIntegerArithmeticType(Type Ty);
bool isFloatingType(Type Ty); // scalar or vector
bool isScalarFloatingType(Type Ty);
bool isVectorFloatingType(Type Ty);
/// Returns true if the given type can be used in a load instruction.
bool isLoadStoreType(Type Ty);
/// Returns true if the given type can be used as a parameter type in a call.
bool isCallParameterType(Type Ty);
/// Returns true if the given type can be used as the return type of a call.
inline bool isCallReturnType(Type Ty) {
return Ty == IceType_void || isCallParameterType(Ty);
/// Returns type generated by applying the compare instructions (icmp and fcmp)
/// to arguments of the given type. Returns IceType_void if compare is not
/// allowed.
Type getCompareResultType(Type Ty);
/// Returns the number of bits in a scalar integer type.
SizeT getScalarIntBitWidth(Type Ty);
/// Check if a type is byte sized (slight optimization over typeWidthInBytes).
inline bool isByteSizedType(Type Ty) {
bool result = Ty == IceType_i8 || Ty == IceType_i1;
assert(result == (1 == typeWidthInBytes(Ty)));
return result;
/// Check if Ty is byte sized and specifically i8. Assert that it's not byte
/// sized due to being an i1.
inline bool isByteSizedArithType(Type Ty) {
assert(Ty != IceType_i1);
return Ty == IceType_i8;
/// Return true if Ty is i32. This asserts that Ty is either i32 or i64.
inline bool isInt32Asserting32Or64(Type Ty) {
bool result = Ty == IceType_i32;
assert(result || Ty == IceType_i64);
return result;
/// Return true if Ty is f32. This asserts that Ty is either f32 or f64.
inline bool isFloat32Asserting32Or64(Type Ty) {
bool result = Ty == IceType_f32;
assert(result || Ty == IceType_f64);
return result;
template <typename StreamType>
inline StreamType &operator<<(StreamType &Str, const Type &Ty) {
Str << typeString(Ty);
return Str;
/// Models a type signature for a function.
class FuncSigType {
FuncSigType &operator=(const FuncSigType &Ty) = delete;
using ArgListType = std::vector<Type>;
/// Creates a function signature type with the given return type. Parameter
/// types should be added using calls to appendArgType.
FuncSigType() = default;
FuncSigType(const FuncSigType &Ty) = default;
void appendArgType(Type ArgType) { ArgList.push_back(ArgType); }
Type getReturnType() const { return ReturnType; }
void setReturnType(Type NewType) { ReturnType = NewType; }
SizeT getNumArgs() const { return ArgList.size(); }
Type getArgType(SizeT Index) const {
assert(Index < ArgList.size());
return ArgList[Index];
const ArgListType &getArgList() const { return ArgList; }
void dump(Ostream &Stream) const;
/// The return type.
Type ReturnType = IceType_void;
/// The list of parameters.
ArgListType ArgList;
inline Ostream &operator<<(Ostream &Stream, const FuncSigType &Sig) {
return Stream;
} // end of namespace Ice