//===- 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.
///
//===----------------------------------------------------------------------===//

#ifndef SUBZERO_SRC_ICETYPES_H
#define SUBZERO_SRC_ICETYPES_H

#include "IceDefs.h"
#include "IceTypes.def"

namespace Ice {

enum Type {
#define X(tag, sizeLog2, align, elts, elty, str, rcstr) IceType_##tag,
  ICETYPE_TABLE
#undef X
      IceType_NUM
};

/// 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,
  ICETYPE_TABLE
#undef X
      RC_Target,
  // 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,
  TARGETARCH_TABLE
#undef X
      TargetArch_NUM
};

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").
  BaseInstructionSet,
  X86InstructionSet_Begin,
  X86InstructionSet_SSE2 = X86InstructionSet_Begin,
  X86InstructionSet_SSE4_1,
  X86InstructionSet_End,
  ARM32InstructionSet_Begin,
  ARM32InstructionSet_Neon = ARM32InstructionSet_Begin,
  ARM32InstructionSet_HWDivArm,
  ARM32InstructionSet_End,
};

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;

public:
  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;

private:
  /// The return type.
  Type ReturnType = IceType_void;
  /// The list of parameters.
  ArgListType ArgList;
};

inline Ostream &operator<<(Ostream &Stream, const FuncSigType &Sig) {
  Sig.dump(Stream);
  return Stream;
}

} // end of namespace Ice

#endif // SUBZERO_SRC_ICETYPES_H