+int smaller_mode(const ir_mode *sm, const ir_mode *lm)
+{
+ int sm_bits, lm_bits;
+
+ assert(sm);
+ assert(lm);
+
+ if (sm == lm) return 1;
+
+ sm_bits = get_mode_size_bits(sm);
+ lm_bits = get_mode_size_bits(lm);
+
+ switch (get_mode_sort(sm)) {
+ case irms_int_number:
+ switch (get_mode_sort(lm)) {
+ case irms_int_number:
+ if (get_mode_arithmetic(sm) != get_mode_arithmetic(lm))
+ return 0;
+
+ /* only two complement implemented */
+ assert(get_mode_arithmetic(sm) == irma_twos_complement);
+
+ /* integers are convertable if
+ * - both have the same sign and lm is the larger one
+ * - lm is the signed one and is at least two bits larger
+ * (one for the sign, one for the highest bit of sm)
+ * - sm & lm are two_complement and lm has greater or equal number of bits
+ */
+ if (mode_is_signed(sm)) {
+ if (!mode_is_signed(lm))
+ return 0;
+ return sm_bits <= lm_bits;
+ } else {
+ if (mode_is_signed(lm)) {
+ return sm_bits < lm_bits;
+ }
+ return sm_bits <= lm_bits;
+ }
+
+ case irms_float_number:
+ /* int to float works if the float is large enough */
+ return 0;
+
+ default:
+ break;
+ }
+ break;
+
+ case irms_float_number:
+ if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
+ if ( (get_mode_sort(lm) == irms_float_number)
+ && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
+ return 1;
+ }
+ break;
+
+ case irms_reference:
+ /* do exist machines out there with different pointer lengths ?*/
+ return 0;
+
+ case irms_internal_boolean:
+ return mode_is_int(lm);
+
+ default:
+ break;
+ }
+
+ /* else */
+ return 0;
+}
+
+int values_in_mode(const ir_mode *sm, const ir_mode *lm)
+{
+ if (sm == lm)
+ return true;
+
+ if (sm == mode_b)
+ return mode_is_int(lm) || mode_is_float(lm);
+
+ ir_mode_arithmetic larith = get_mode_arithmetic(lm);
+ ir_mode_arithmetic sarith = get_mode_arithmetic(sm);
+ switch (larith) {
+ case irma_x86_extended_float:
+ case irma_ieee754:
+ if (sarith == irma_ieee754 || sarith == irma_x86_extended_float) {
+ return get_mode_size_bits(sm) <= get_mode_size_bits(lm);
+ } else if (sarith == irma_twos_complement) {
+ unsigned int_mantissa = get_mode_size_bits(sm) - (mode_is_signed(sm) ? 1 : 0);
+ unsigned float_mantissa = get_mode_mantissa_size(lm) + 1;
+ return int_mantissa <= float_mantissa;
+ }
+ break;
+ case irma_twos_complement:
+ if (sarith == irma_twos_complement) {
+ return get_mode_size_bits(sm) <= get_mode_size_bits(lm);
+ }
+ break;
+ case irma_none:
+ break;
+ }
+ return false;
+}
+
+ir_mode *get_reference_mode_signed_eq(ir_mode *mode)
+{
+ assert(mode_is_reference(mode));
+ return mode->eq_signed;
+}
+
+void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode)
+{
+ assert(mode_is_reference(ref_mode));
+ assert(mode_is_int(int_mode));
+ ref_mode->eq_signed = int_mode;
+}
+
+ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode)
+{
+ assert(mode_is_reference(mode));
+ return mode->eq_unsigned;