1 /****************************************************************************
3 * GNAT COMPILER COMPONENTS *
7 * C Implementation File *
9 * Copyright (C) 1992-2014, 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"
41 /* Universal integers are represented by the Uint type which is an index into
42 the Uints_Ptr table containing Uint_Entry values. A Uint_Entry contains an
43 index and length for getting the "digits" of the universal integer from the
46 For efficiency, this method is used only for integer values larger than the
47 constant Uint_Bias. If a Uint is less than this constant, then it contains
48 the integer value itself. The origin of the Uints_Ptr table is adjusted so
49 that a Uint value of Uint_Bias indexes the first element.
51 First define a utility function that operates like build_int_cst_type for
52 integral types and does a conversion for floating-point types. */
55 build_cst_from_int (tree type
, HOST_WIDE_INT low
)
57 if (SCALAR_FLOAT_TYPE_P (type
))
58 return convert (type
, build_int_cst (gnat_type_for_size (32, 0), low
));
60 return build_int_cst_type (type
, low
);
63 /* Similar to UI_To_Int, but return a GCC INTEGER_CST or REAL_CST node,
64 depending on whether TYPE is an integral or real type. Overflow is tested
65 by the constant-folding used to build the node. TYPE is the GCC type of
66 the resulting node. */
69 UI_To_gnu (Uint Input
, tree type
)
71 /* We might have a TYPE with biased representation and be passed an unbiased
72 value that doesn't fit. We always use an unbiased type to be able to hold
73 any such possible value for intermediate computations and then rely on a
74 conversion back to TYPE to perform the bias adjustment when need be. */
76 = TREE_CODE (type
) == INTEGER_TYPE
&& TYPE_BIASED_REPRESENTATION_P (type
)
77 ? get_base_type (type
) : type
;
80 if (Input
<= Uint_Direct_Last
)
81 gnu_ret
= build_cst_from_int (comp_type
, Input
- Uint_Direct_Bias
);
84 Int Idx
= Uints_Ptr
[Input
].Loc
;
85 Pos Length
= Uints_Ptr
[Input
].Length
;
86 Int First
= Udigits_Ptr
[Idx
];
89 gcc_assert (Length
> 0);
91 /* The computations we perform below always require a type at least as
92 large as an integer not to overflow. FP types are always fine, but
93 INTEGER or ENUMERAL types we are handed may be too short. We use a
94 base integer type node for the computations in this case and will
95 convert the final result back to the incoming type later on. */
96 if (!SCALAR_FLOAT_TYPE_P (comp_type
) && TYPE_PRECISION (comp_type
) < 32)
97 comp_type
= gnat_type_for_size (32, 0);
99 gnu_base
= build_cst_from_int (comp_type
, Base
);
101 gnu_ret
= build_cst_from_int (comp_type
, First
);
103 for (Idx
++, Length
--; Length
; Idx
++, Length
--)
104 gnu_ret
= fold_build2 (MINUS_EXPR
, comp_type
,
105 fold_build2 (MULT_EXPR
, comp_type
,
107 build_cst_from_int (comp_type
,
110 for (Idx
++, Length
--; Length
; Idx
++, Length
--)
111 gnu_ret
= fold_build2 (PLUS_EXPR
, comp_type
,
112 fold_build2 (MULT_EXPR
, comp_type
,
114 build_cst_from_int (comp_type
,
118 gnu_ret
= convert (type
, gnu_ret
);
120 /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RET. */
121 while ((TREE_CODE (gnu_ret
) == NOP_EXPR
122 || TREE_CODE (gnu_ret
) == NON_LVALUE_EXPR
)
123 && TREE_TYPE (TREE_OPERAND (gnu_ret
, 0)) == TREE_TYPE (gnu_ret
))
124 gnu_ret
= TREE_OPERAND (gnu_ret
, 0);
129 /* Similar to UI_From_Int, but take a GCC INTEGER_CST. We use UI_From_Int
130 when possible, i.e. for a 32-bit signed value, to take advantage of its
131 built-in caching mechanism. For values of larger magnitude, we compute
132 digits into a vector and call Vector_To_Uint. */
135 UI_From_gnu (tree Input
)
137 tree gnu_type
= TREE_TYPE (Input
), gnu_base
, gnu_temp
;
138 /* UI_Base is defined so that 5 Uint digits is sufficient to hold the
139 largest possible signed 64-bit value. */
140 const int Max_For_Dint
= 5;
141 int v
[Max_For_Dint
], i
;
142 Vector_Template temp
;
145 #if HOST_BITS_PER_WIDE_INT == 64
146 /* On 64-bit hosts, tree_fits_shwi_p tells whether the input fits in a
147 signed 64-bit integer. Then a truncation tells whether it fits
148 in a signed 32-bit integer. */
149 if (tree_fits_shwi_p (Input
))
151 HOST_WIDE_INT hw_input
= tree_to_shwi (Input
);
152 if (hw_input
== (int) hw_input
)
153 return UI_From_Int (hw_input
);
158 /* On 32-bit hosts, tree_fits_shwi_p tells whether the input fits in a
159 signed 32-bit integer. Then a sign test tells whether it fits
160 in a signed 64-bit integer. */
161 if (tree_fits_shwi_p (Input
))
162 return UI_From_Int (tree_to_shwi (Input
));
164 gcc_assert (TYPE_PRECISION (gnu_type
) <= 64);
165 if (TYPE_UNSIGNED (gnu_type
)
166 && TYPE_PRECISION (gnu_type
) == 64
167 && wi::neg_p (Input
, SIGNED
))
171 gnu_base
= build_int_cst (gnu_type
, UI_Base
);
174 for (i
= Max_For_Dint
- 1; i
>= 0; i
--)
176 v
[i
] = tree_to_shwi (fold_build1 (ABS_EXPR
, gnu_type
,
177 fold_build2 (TRUNC_MOD_EXPR
, gnu_type
,
178 gnu_temp
, gnu_base
)));
179 gnu_temp
= fold_build2 (TRUNC_DIV_EXPR
, gnu_type
, gnu_temp
, gnu_base
);
183 temp
.High_Bound
= Max_For_Dint
;
186 return Vector_To_Uint (vec
, tree_int_cst_sgn (Input
) < 0);