+/* This function is called by the front-end to enumerate all the supported
+ modes for the machine, as well as some predefined C types. F is a function
+ which is called back with the parameters as listed below, first a string,
+ then seven ints. The name is any arbitrary null-terminated string and has
+ no particular significance, except for the case of predefined C types, where
+ it should be the name of the C type. For integer types, only signed types
+ should be listed, unsigned versions are assumed. The order of types should
+ be in order of preference, with the smallest/cheapest types first.
+
+ In particular, C predefined types should be listed before other types,
+ binary floating point types before decimal ones, and narrower/cheaper
+ type versions before more expensive ones. In type selection the first
+ matching variant will be used.
+
+ NAME pointer to first char of type name
+ DIGS number of decimal digits for floating-point modes, else 0
+ COMPLEX_P nonzero is this represents a complex mode
+ COUNT count of number of items, nonzero for vector mode
+ FLOAT_REP Float_Rep_Kind for FP, otherwise undefined
+ PRECISION number of bits used to store data
+ SIZE number of bits occupied by the mode
+ ALIGN number of bits to which mode is aligned. */
+
+void
+enumerate_modes (void (*f) (const char *, int, int, int, int, int, int, int))
+{
+ const tree c_types[]
+ = { float_type_node, double_type_node, long_double_type_node };
+ const char *const c_names[]
+ = { "float", "double", "long double" };
+ int iloop;
+
+ for (iloop = 0; iloop < NUM_MACHINE_MODES; iloop++)
+ {
+ enum machine_mode i = (enum machine_mode) iloop;
+ enum machine_mode inner_mode = i;
+ bool float_p = false;
+ bool complex_p = false;
+ bool vector_p = false;
+ bool skip_p = false;
+ int digs = 0;
+ unsigned int nameloop;
+ Float_Rep_Kind float_rep = IEEE_Binary; /* Until proven otherwise */
+
+ switch (GET_MODE_CLASS (i))
+ {
+ case MODE_INT:
+ break;
+ case MODE_FLOAT:
+ float_p = true;
+ break;
+ case MODE_COMPLEX_INT:
+ complex_p = true;
+ inner_mode = GET_MODE_INNER (i);
+ break;
+ case MODE_COMPLEX_FLOAT:
+ float_p = true;
+ complex_p = true;
+ inner_mode = GET_MODE_INNER (i);
+ break;
+ case MODE_VECTOR_INT:
+ vector_p = true;
+ inner_mode = GET_MODE_INNER (i);
+ break;
+ case MODE_VECTOR_FLOAT:
+ float_p = true;
+ vector_p = true;
+ inner_mode = GET_MODE_INNER (i);
+ break;
+ default:
+ skip_p = true;
+ }
+
+ if (float_p)
+ {
+ const struct real_format *fmt = REAL_MODE_FORMAT (inner_mode);
+
+ /* ??? Cope with the ghost XFmode of the ARM port. */
+ if (!fmt)
+ continue;
+
+ if (fmt->b == 2)
+ digs = (fmt->p - 1) * 1233 / 4096; /* scale by log (2) */
+
+ else if (fmt->b == 10)
+ digs = fmt->p;
+
+ else
+ gcc_unreachable();
+
+ if (fmt == &vax_f_format
+ || fmt == &vax_d_format
+ || fmt == &vax_g_format)
+ float_rep = VAX_Native;
+ }
+
+ /* First register any C types for this mode that the front end
+ may need to know about, unless the mode should be skipped. */
+ if (!skip_p && !vector_p)
+ for (nameloop = 0; nameloop < ARRAY_SIZE (c_types); nameloop++)
+ {
+ tree type = c_types[nameloop];
+ const char *name = c_names[nameloop];
+
+ if (TYPE_MODE (type) == i)
+ {
+ f (name, digs, complex_p, 0, float_rep, TYPE_PRECISION (type),
+ TREE_INT_CST_LOW (TYPE_SIZE (type)), TYPE_ALIGN (type));
+ skip_p = true;
+ }
+ }
+
+ /* If no predefined C types were found, register the mode itself. */
+ if (!skip_p)
+ f (GET_MODE_NAME (i), digs, complex_p,
+ vector_p ? GET_MODE_NUNITS (i) : 0, float_rep,
+ GET_MODE_PRECISION (i), GET_MODE_BITSIZE (i),
+ GET_MODE_ALIGNMENT (i));
+ }
+}
+