+ int (*type_quals) (tree);
+};
+
+/* Hooks related to types. */
+
+struct lang_hooks_for_types
+{
+ /* Return a new type (with the indicated CODE), doing whatever
+ language-specific processing is required. */
+ tree (*make_type) (enum tree_code);
+
+ /* Given MODE and UNSIGNEDP, return a suitable type-tree with that
+ mode. */
+ tree (*type_for_mode) (enum machine_mode, int);
+
+ /* Given PRECISION and UNSIGNEDP, return a suitable type-tree for an
+ integer type with at least that precision. */
+ tree (*type_for_size) (unsigned, int);
+
+ /* Given an integer type T, return a type like T but unsigned.
+ If T is unsigned, the value is T. */
+ tree (*unsigned_type) (tree);
+
+ /* Given an integer type T, return a type like T but signed.
+ If T is signed, the value is T. */
+ tree (*signed_type) (tree);
+
+ /* Return a type the same as TYPE except unsigned or signed
+ according to UNSIGNEDP. */
+ tree (*signed_or_unsigned_type) (int, tree);
+
+ /* Given a type, apply default promotions to unnamed function
+ arguments and return the new type. Return the same type if no
+ change. Required by any language that supports variadic
+ arguments. The default hook dies. */
+ tree (*type_promotes_to) (tree);
+
+ /* Register TYPE as a builtin type with the indicated NAME. The
+ TYPE is placed in the outermost lexical scope. The semantics
+ should be analogous to:
+
+ typedef TYPE NAME;
+
+ in C. The default hook ignores the declaration. */
+ void (*register_builtin_type) (tree, const char *);
+
+ /* This routine is called in tree.c to print an error message for
+ invalid use of an incomplete type. VALUE is the expression that
+ was used (or 0 if that isn't known) and TYPE is the type that was
+ invalid. */
+ void (*incomplete_type_error) (tree value, tree type);
+
+ /* Called from assign_temp to return the maximum size, if there is one,
+ for a type. */
+ tree (*max_size) (tree);
+
+ /* Register language specific type size variables as potentially OpenMP
+ firstprivate variables. */
+ void (*omp_firstprivatize_type_sizes) (struct gimplify_omp_ctx *, tree);
+
+ /* Nonzero if types that are identical are to be hashed so that only
+ one copy is kept. If a language requires unique types for each
+ user-specified type, such as Ada, this should be set to TRUE. */
+ bool hash_types;