1 /****************************************************************************
3 * GNAT COMPILER COMPONENTS *
7 * C Implementation File *
9 * Copyright (C) 1992-2009, Free Software Foundation, Inc. *
11 * GNAT is free software; you can redistribute it and/or modify it under *
12 * terms of the GNU General Public License as published by the Free Soft- *
13 * ware Foundation; either version 3, or (at your option) any later ver- *
14 * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
15 * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
16 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
17 * for more details. You should have received a copy of the GNU General *
18 * Public License along with GCC; see the file COPYING3. If not see *
19 * <http://www.gnu.org/licenses/>. *
21 * GNAT was originally developed by the GNAT team at New York University. *
22 * Extensive contributions were provided by Ada Core Technologies Inc. *
24 ****************************************************************************/
26 /* This file corresponds to the Ada package body Uintp. It was created
27 manually from the files uintp.ads and uintp.adb. */
31 #include "coretypes.h"
46 /* Universal integers are represented by the Uint type which is an index into
47 the Uints_Ptr table containing Uint_Entry values. A Uint_Entry contains an
48 index and length for getting the "digits" of the universal integer from the
51 For efficiency, this method is used only for integer values larger than the
52 constant Uint_Bias. If a Uint is less than this constant, then it contains
53 the integer value itself. The origin of the Uints_Ptr table is adjusted so
54 that a Uint value of Uint_Bias indexes the first element.
56 First define a utility function that operates like build_int_cst for
57 integral types and does a conversion to floating-point for real types. */
60 build_cst_from_int (tree type, HOST_WIDE_INT low)
62 if (TREE_CODE (type) == REAL_TYPE)
63 return convert (type, build_int_cst (NULL_TREE, low));
65 return build_int_cst_type (type, low);
68 /* Similar to UI_To_Int, but return a GCC INTEGER_CST or REAL_CST node,
69 depending on whether TYPE is an integral or real type. Overflow is tested
70 by the constant-folding used to build the node. TYPE is the GCC type of
71 the resulting node. */
74 UI_To_gnu (Uint Input, tree type)
78 /* We might have a TYPE with biased representation and be passed an
79 unbiased value that doesn't fit. We always use an unbiased type able
80 to hold any such possible value for intermediate computations, and
81 then rely on a conversion back to TYPE to perform the bias adjustment
85 = (TREE_CODE (type) == INTEGER_TYPE
86 && TYPE_BIASED_REPRESENTATION_P (type));
88 tree comp_type = biased_type_p ? get_base_type (type) : type;
90 if (Input <= Uint_Direct_Last)
91 gnu_ret = build_cst_from_int (comp_type, Input - Uint_Direct_Bias);
94 Int Idx = Uints_Ptr[Input].Loc;
95 Pos Length = Uints_Ptr[Input].Length;
96 Int First = Udigits_Ptr[Idx];
99 gcc_assert (Length > 0);
101 /* The computations we perform below always require a type at least as
102 large as an integer not to overflow. REAL types are always fine, but
103 INTEGER or ENUMERAL types we are handed may be too short. We use a
104 base integer type node for the computations in this case and will
105 convert the final result back to the incoming type later on.
106 The base integer precision must be superior than 16. */
108 if (TREE_CODE (comp_type) != REAL_TYPE
109 && TYPE_PRECISION (comp_type) < TYPE_PRECISION (long_integer_type_node))
111 comp_type = long_integer_type_node;
112 gcc_assert (TYPE_PRECISION (comp_type) > 16);
115 gnu_base = build_cst_from_int (comp_type, Base);
117 gnu_ret = build_cst_from_int (comp_type, First);
119 for (Idx++, Length--; Length; Idx++, Length--)
120 gnu_ret = fold_build2 (MINUS_EXPR, comp_type,
121 fold_build2 (MULT_EXPR, comp_type,
123 build_cst_from_int (comp_type,
126 for (Idx++, Length--; Length; Idx++, Length--)
127 gnu_ret = fold_build2 (PLUS_EXPR, comp_type,
128 fold_build2 (MULT_EXPR, comp_type,
130 build_cst_from_int (comp_type,
134 gnu_ret = convert (type, gnu_ret);
136 /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RET. */
137 while ((TREE_CODE (gnu_ret) == NOP_EXPR
138 || TREE_CODE (gnu_ret) == NON_LVALUE_EXPR)
139 && TREE_TYPE (TREE_OPERAND (gnu_ret, 0)) == TREE_TYPE (gnu_ret))
140 gnu_ret = TREE_OPERAND (gnu_ret, 0);