compiler/optimizing/data_type.h - platform/art - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef ART_COMPILER_OPTIMIZING_DATA_TYPE_H_
 #define ART_COMPILER_OPTIMIZING_DATA_TYPE_H_

 #include <iosfwd>

 #include <android-base/logging.h>

 #include "base/bit_utils.h"

 namespace art {

 class DataType {
  public:
   enum class Type : uint8_t {
     kReference = 0,
     kBool,
     kUint8,
     kInt8,
     kUint16,
     kInt16,
     kUint32,
     kInt32,
     kUint64,
     kInt64,
     kFloat32,
     kFloat64,
     kVoid,
     kLast = kVoid
   };

   static constexpr Type FromShorty(char type);
   static constexpr char TypeId(DataType::Type type);

   static constexpr size_t SizeShift(Type type) {
     switch (type) {
       case Type::kVoid:
       case Type::kBool:
       case Type::kUint8:
       case Type::kInt8:
         return 0;
       case Type::kUint16:
       case Type::kInt16:
         return 1;
       case Type::kUint32:
       case Type::kInt32:
       case Type::kFloat32:
         return 2;
       case Type::kUint64:
       case Type::kInt64:
       case Type::kFloat64:
         return 3;
       case Type::kReference:
         return WhichPowerOf2(kObjectReferenceSize);
       default:
         LOG(FATAL) << "Invalid type " << static_cast<int>(type);
         return 0;
     }
   }

   static constexpr size_t Size(Type type) {
     switch (type) {
       case Type::kVoid:
         return 0;
       case Type::kBool:
       case Type::kUint8:
       case Type::kInt8:
         return 1;
       case Type::kUint16:
       case Type::kInt16:
         return 2;
       case Type::kUint32:
       case Type::kInt32:
       case Type::kFloat32:
         return 4;
       case Type::kUint64:
       case Type::kInt64:
       case Type::kFloat64:
         return 8;
       case Type::kReference:
         return kObjectReferenceSize;
       default:
         LOG(FATAL) << "Invalid type " << static_cast<int>(type);
         return 0;
     }
   }

   static bool IsFloatingPointType(Type type) {
     return type == Type::kFloat32 || type == Type::kFloat64;
   }

   static bool IsIntegralType(Type type) {
     // The Java language does not allow treating boolean as an integral type but
     // our bit representation makes it safe.
     switch (type) {
       case Type::kBool:
       case Type::kUint8:
       case Type::kInt8:
       case Type::kUint16:
       case Type::kInt16:
       case Type::kUint32:
       case Type::kInt32:
       case Type::kUint64:
       case Type::kInt64:
         return true;
       default:
         return false;
     }
   }

   static bool IsIntOrLongType(Type type) {
     return type == Type::kInt32 || type == Type::kInt64;
   }

   static bool Is64BitType(Type type) {
     return type == Type::kUint64 || type == Type::kInt64 || type == Type::kFloat64;
   }

   static bool IsUnsignedType(Type type) {
     return type == Type::kBool || type == Type::kUint8 || type == Type::kUint16 ||
         type == Type::kUint32 || type == Type::kUint64;
   }

   // Return the general kind of `type`, fusing integer-like types as Type::kInt.
   static Type Kind(Type type) {
     switch (type) {
       case Type::kBool:
       case Type::kUint8:
       case Type::kInt8:
       case Type::kUint16:
       case Type::kInt16:
       case Type::kUint32:
       case Type::kInt32:
         return Type::kInt32;
       case Type::kUint64:
       case Type::kInt64:
         return Type::kInt64;
       default:
         return type;
     }
   }

   static int64_t MinValueOfIntegralType(Type type) {
     switch (type) {
       case Type::kBool:
         return std::numeric_limits<bool>::min();
       case Type::kUint8:
         return std::numeric_limits<uint8_t>::min();
       case Type::kInt8:
         return std::numeric_limits<int8_t>::min();
       case Type::kUint16:
         return std::numeric_limits<uint16_t>::min();
       case Type::kInt16:
         return std::numeric_limits<int16_t>::min();
       case Type::kUint32:
         return std::numeric_limits<uint32_t>::min();
       case Type::kInt32:
         return std::numeric_limits<int32_t>::min();
       case Type::kUint64:
         return std::numeric_limits<uint64_t>::min();
       case Type::kInt64:
         return std::numeric_limits<int64_t>::min();
       default:
         LOG(FATAL) << "non integral type";
     }
     return 0;
   }

   static int64_t MaxValueOfIntegralType(Type type) {
     switch (type) {
       case Type::kBool:
         return std::numeric_limits<bool>::max();
       case Type::kUint8:
         return std::numeric_limits<uint8_t>::max();
       case Type::kInt8:
         return std::numeric_limits<int8_t>::max();
       case Type::kUint16:
         return std::numeric_limits<uint16_t>::max();
       case Type::kInt16:
         return std::numeric_limits<int16_t>::max();
       case Type::kUint32:
         return std::numeric_limits<uint32_t>::max();
       case Type::kInt32:
         return std::numeric_limits<int32_t>::max();
       case Type::kUint64:
         return std::numeric_limits<uint64_t>::max();
       case Type::kInt64:
         return std::numeric_limits<int64_t>::max();
       default:
         LOG(FATAL) << "non integral type";
     }
     return 0;
   }

   static bool IsTypeConversionImplicit(Type input_type, Type result_type);
   static bool IsTypeConversionImplicit(int64_t value, Type result_type);

   static bool IsZeroExtension(Type input_type, Type result_type) {
     return IsIntOrLongType(result_type) &&
         IsUnsignedType(input_type) &&
         Size(result_type) > Size(input_type);
   }

   static Type ToSigned(Type type) {
     switch (type) {
       case Type::kUint8:
         return Type::kInt8;
       case Type::kUint16:
         return Type::kInt16;
       case Type::kUint32:
         return Type::kInt32;
       case Type::kUint64:
         return Type::kInt64;
       default:
         return type;
     }
   }

   static Type ToUnsigned(Type type) {
     switch (type) {
       case Type::kInt8:
         return Type::kUint8;
       case Type::kInt16:
         return Type::kUint16;
       case Type::kInt32:
         return Type::kUint32;
       case Type::kInt64:
         return Type::kUint64;
       default:
         return type;
     }
   }

   static const char* PrettyDescriptor(Type type);

  private:
   static constexpr size_t kObjectReferenceSize = 4u;
 };
 std::ostream& operator<<(std::ostream& os, DataType::Type data_type);

 // Defined outside DataType to have the operator<< available for DCHECK_NE().
 inline bool DataType::IsTypeConversionImplicit(Type input_type, Type result_type) {
   DCHECK_NE(DataType::Type::kVoid, result_type);
   DCHECK_NE(DataType::Type::kVoid, input_type);

   // Invariant: We should never generate a conversion to a Boolean value.
   DCHECK_NE(DataType::Type::kBool, result_type);

   // Besides conversion to the same type, integral conversions to non-Int64 types
   // are implicit if the result value range covers the input value range, i.e.
   // widening conversions that do not need to trim the sign bits.
   return result_type == input_type ||
          (result_type != Type::kInt64 &&
           IsIntegralType(input_type) &&
           IsIntegralType(result_type) &&
           MinValueOfIntegralType(input_type) >= MinValueOfIntegralType(result_type) &&
           MaxValueOfIntegralType(input_type) <= MaxValueOfIntegralType(result_type));
 }

 inline bool DataType::IsTypeConversionImplicit(int64_t value, Type result_type) {
   if (IsIntegralType(result_type) && result_type != Type::kInt64) {
     // If the constant value falls in the range of the result_type, type
     // conversion isn't needed.
     return value >= MinValueOfIntegralType(result_type) &&
            value <= MaxValueOfIntegralType(result_type);
   }
   // Conversion isn't implicit if it's into non-integer types, or 64-bit int
   // which may have different number of registers.
   return false;
 }

 }  // namespace art

 #endif  // ART_COMPILER_OPTIMIZING_DATA_TYPE_H_
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef ART_COMPILER_OPTIMIZING_DATA_TYPE_H_
	#define ART_COMPILER_OPTIMIZING_DATA_TYPE_H_

	#include <iosfwd>

	#include <android-base/logging.h>

	#include "base/bit_utils.h"

	namespace art {

	class DataType {
	public:
	enum class Type : uint8_t {
	kReference = 0,
	kBool,
	kUint8,
	kInt8,
	kUint16,
	kInt16,
	kUint32,
	kInt32,
	kUint64,
	kInt64,
	kFloat32,
	kFloat64,
	kVoid,
	kLast = kVoid
	};

	static constexpr Type FromShorty(char type);
	static constexpr char TypeId(DataType::Type type);

	static constexpr size_t SizeShift(Type type) {
	switch (type) {
	case Type::kVoid:
	case Type::kBool:
	case Type::kUint8:
	case Type::kInt8:
	return 0;
	case Type::kUint16:
	case Type::kInt16:
	return 1;
	case Type::kUint32:
	case Type::kInt32:
	case Type::kFloat32:
	return 2;
	case Type::kUint64:
	case Type::kInt64:
	case Type::kFloat64:
	return 3;
	case Type::kReference:
	return WhichPowerOf2(kObjectReferenceSize);
	default:
	LOG(FATAL) << "Invalid type " << static_cast<int>(type);
	return 0;
	}
	}

	static constexpr size_t Size(Type type) {
	switch (type) {
	case Type::kVoid:
	return 0;
	case Type::kBool:
	case Type::kUint8:
	case Type::kInt8:
	return 1;
	case Type::kUint16:
	case Type::kInt16:
	return 2;
	case Type::kUint32:
	case Type::kInt32:
	case Type::kFloat32:
	return 4;
	case Type::kUint64:
	case Type::kInt64:
	case Type::kFloat64:
	return 8;
	case Type::kReference:
	return kObjectReferenceSize;
	default:
	LOG(FATAL) << "Invalid type " << static_cast<int>(type);
	return 0;
	}
	}

	static bool IsFloatingPointType(Type type) {
	return type == Type::kFloat32 \|\| type == Type::kFloat64;
	}

	static bool IsIntegralType(Type type) {
	// The Java language does not allow treating boolean as an integral type but
	// our bit representation makes it safe.
	switch (type) {
	case Type::kBool:
	case Type::kUint8:
	case Type::kInt8:
	case Type::kUint16:
	case Type::kInt16:
	case Type::kUint32:
	case Type::kInt32:
	case Type::kUint64:
	case Type::kInt64:
	return true;
	default:
	return false;
	}
	}

	static bool IsIntOrLongType(Type type) {
	return type == Type::kInt32 \|\| type == Type::kInt64;
	}

	static bool Is64BitType(Type type) {
	return type == Type::kUint64 \|\| type == Type::kInt64 \|\| type == Type::kFloat64;
	}

	static bool IsUnsignedType(Type type) {
	return type == Type::kBool \|\| type == Type::kUint8 \|\| type == Type::kUint16 \|\|
	type == Type::kUint32 \|\| type == Type::kUint64;
	}

	// Return the general kind of `type`, fusing integer-like types as Type::kInt.
	static Type Kind(Type type) {
	switch (type) {
	case Type::kBool:
	case Type::kUint8:
	case Type::kInt8:
	case Type::kUint16:
	case Type::kInt16:
	case Type::kUint32:
	case Type::kInt32:
	return Type::kInt32;
	case Type::kUint64:
	case Type::kInt64:
	return Type::kInt64;
	default:
	return type;
	}
	}

	static int64_t MinValueOfIntegralType(Type type) {
	switch (type) {
	case Type::kBool:
	return std::numeric_limits<bool>::min();
	case Type::kUint8:
	return std::numeric_limits<uint8_t>::min();
	case Type::kInt8:
	return std::numeric_limits<int8_t>::min();
	case Type::kUint16:
	return std::numeric_limits<uint16_t>::min();
	case Type::kInt16:
	return std::numeric_limits<int16_t>::min();
	case Type::kUint32:
	return std::numeric_limits<uint32_t>::min();
	case Type::kInt32:
	return std::numeric_limits<int32_t>::min();
	case Type::kUint64:
	return std::numeric_limits<uint64_t>::min();
	case Type::kInt64:
	return std::numeric_limits<int64_t>::min();
	default:
	LOG(FATAL) << "non integral type";
	}
	return 0;
	}

	static int64_t MaxValueOfIntegralType(Type type) {
	switch (type) {
	case Type::kBool:
	return std::numeric_limits<bool>::max();
	case Type::kUint8:
	return std::numeric_limits<uint8_t>::max();
	case Type::kInt8:
	return std::numeric_limits<int8_t>::max();
	case Type::kUint16:
	return std::numeric_limits<uint16_t>::max();
	case Type::kInt16:
	return std::numeric_limits<int16_t>::max();
	case Type::kUint32:
	return std::numeric_limits<uint32_t>::max();
	case Type::kInt32:
	return std::numeric_limits<int32_t>::max();
	case Type::kUint64:
	return std::numeric_limits<uint64_t>::max();
	case Type::kInt64:
	return std::numeric_limits<int64_t>::max();
	default:
	LOG(FATAL) << "non integral type";
	}
	return 0;
	}

	static bool IsTypeConversionImplicit(Type input_type, Type result_type);
	static bool IsTypeConversionImplicit(int64_t value, Type result_type);

	static bool IsZeroExtension(Type input_type, Type result_type) {
	return IsIntOrLongType(result_type) &&
	IsUnsignedType(input_type) &&
	Size(result_type) > Size(input_type);
	}

	static Type ToSigned(Type type) {
	switch (type) {
	case Type::kUint8:
	return Type::kInt8;
	case Type::kUint16:
	return Type::kInt16;
	case Type::kUint32:
	return Type::kInt32;
	case Type::kUint64:
	return Type::kInt64;
	default:
	return type;
	}
	}

	static Type ToUnsigned(Type type) {
	switch (type) {
	case Type::kInt8:
	return Type::kUint8;
	case Type::kInt16:
	return Type::kUint16;
	case Type::kInt32:
	return Type::kUint32;
	case Type::kInt64:
	return Type::kUint64;
	default:
	return type;
	}
	}

	static const char* PrettyDescriptor(Type type);

	private:
	static constexpr size_t kObjectReferenceSize = 4u;
	};
	std::ostream& operator<<(std::ostream& os, DataType::Type data_type);

	// Defined outside DataType to have the operator<< available for DCHECK_NE().
	inline bool DataType::IsTypeConversionImplicit(Type input_type, Type result_type) {
	DCHECK_NE(DataType::Type::kVoid, result_type);
	DCHECK_NE(DataType::Type::kVoid, input_type);

	// Invariant: We should never generate a conversion to a Boolean value.
	DCHECK_NE(DataType::Type::kBool, result_type);

	// Besides conversion to the same type, integral conversions to non-Int64 types
	// are implicit if the result value range covers the input value range, i.e.
	// widening conversions that do not need to trim the sign bits.
	return result_type == input_type \|\|
	(result_type != Type::kInt64 &&
	IsIntegralType(input_type) &&
	IsIntegralType(result_type) &&
	MinValueOfIntegralType(input_type) >= MinValueOfIntegralType(result_type) &&
	MaxValueOfIntegralType(input_type) <= MaxValueOfIntegralType(result_type));
	}

	inline bool DataType::IsTypeConversionImplicit(int64_t value, Type result_type) {
	if (IsIntegralType(result_type) && result_type != Type::kInt64) {
	// If the constant value falls in the range of the result_type, type
	// conversion isn't needed.
	return value >= MinValueOfIntegralType(result_type) &&
	value <= MaxValueOfIntegralType(result_type);
	}
	// Conversion isn't implicit if it's into non-integer types, or 64-bit int
	// which may have different number of registers.
	return false;
	}

	} // namespace art

	#endif // ART_COMPILER_OPTIMIZING_DATA_TYPE_H_