aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.7/gcc/ada/gcc-interface/cuintp.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.7/gcc/ada/gcc-interface/cuintp.c')
-rw-r--r--gcc-4.7/gcc/ada/gcc-interface/cuintp.c202
1 files changed, 0 insertions, 202 deletions
diff --git a/gcc-4.7/gcc/ada/gcc-interface/cuintp.c b/gcc-4.7/gcc/ada/gcc-interface/cuintp.c
deleted file mode 100644
index 31ed801e6..000000000
--- a/gcc-4.7/gcc/ada/gcc-interface/cuintp.c
+++ /dev/null
@@ -1,202 +0,0 @@
-/****************************************************************************
- * *
- * GNAT COMPILER COMPONENTS *
- * *
- * C U I N T P *
- * *
- * C Implementation File *
- * *
- * Copyright (C) 1992-2010, Free Software Foundation, Inc. *
- * *
- * GNAT is free software; you can redistribute it and/or modify it under *
- * terms of the GNU General Public License as published by the Free Soft- *
- * ware Foundation; either version 3, or (at your option) any later ver- *
- * sion. GNAT is distributed in the hope that it will be useful, but WITH- *
- * OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
- * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
- * for more details. You should have received a copy of the GNU General *
- * Public License along with GCC; see the file COPYING3. If not see *
- * <http://www.gnu.org/licenses/>. *
- * *
- * GNAT was originally developed by the GNAT team at New York University. *
- * Extensive contributions were provided by Ada Core Technologies Inc. *
- * *
- ****************************************************************************/
-
-/* This file corresponds to the Ada package body Uintp. It was created
- manually from the files uintp.ads and uintp.adb. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "tm.h"
-#include "tree.h"
-
-#include "ada.h"
-#include "types.h"
-#include "uintp.h"
-#include "atree.h"
-#include "elists.h"
-#include "nlists.h"
-#include "stringt.h"
-#include "fe.h"
-#include "ada-tree.h"
-#include "gigi.h"
-
-/* Universal integers are represented by the Uint type which is an index into
- the Uints_Ptr table containing Uint_Entry values. A Uint_Entry contains an
- index and length for getting the "digits" of the universal integer from the
- Udigits_Ptr table.
-
- For efficiency, this method is used only for integer values larger than the
- constant Uint_Bias. If a Uint is less than this constant, then it contains
- the integer value itself. The origin of the Uints_Ptr table is adjusted so
- that a Uint value of Uint_Bias indexes the first element.
-
- First define a utility function that operates like build_int_cst for
- integral types and does a conversion to floating-point for real types. */
-
-static tree
-build_cst_from_int (tree type, HOST_WIDE_INT low)
-{
- if (TREE_CODE (type) == REAL_TYPE)
- return convert (type, build_int_cst (NULL_TREE, low));
- else
- return build_int_cst_type (type, low);
-}
-
-/* Similar to UI_To_Int, but return a GCC INTEGER_CST or REAL_CST node,
- depending on whether TYPE is an integral or real type. Overflow is tested
- by the constant-folding used to build the node. TYPE is the GCC type of
- the resulting node. */
-
-tree
-UI_To_gnu (Uint Input, tree type)
-{
- tree gnu_ret;
-
- /* We might have a TYPE with biased representation and be passed an
- unbiased value that doesn't fit. We always use an unbiased type able
- to hold any such possible value for intermediate computations, and
- then rely on a conversion back to TYPE to perform the bias adjustment
- when need be. */
-
- int biased_type_p
- = (TREE_CODE (type) == INTEGER_TYPE
- && TYPE_BIASED_REPRESENTATION_P (type));
-
- tree comp_type = biased_type_p ? get_base_type (type) : type;
-
- if (Input <= Uint_Direct_Last)
- gnu_ret = build_cst_from_int (comp_type, Input - Uint_Direct_Bias);
- else
- {
- Int Idx = Uints_Ptr[Input].Loc;
- Pos Length = Uints_Ptr[Input].Length;
- Int First = Udigits_Ptr[Idx];
- tree gnu_base;
-
- gcc_assert (Length > 0);
-
- /* The computations we perform below always require a type at least as
- large as an integer not to overflow. REAL types are always fine, but
- INTEGER or ENUMERAL types we are handed may be too short. We use a
- base integer type node for the computations in this case and will
- convert the final result back to the incoming type later on.
- The base integer precision must be superior than 16. */
-
- if (TREE_CODE (comp_type) != REAL_TYPE
- && TYPE_PRECISION (comp_type)
- < TYPE_PRECISION (long_integer_type_node))
- {
- comp_type = long_integer_type_node;
- gcc_assert (TYPE_PRECISION (comp_type) > 16);
- }
-
- gnu_base = build_cst_from_int (comp_type, Base);
-
- gnu_ret = build_cst_from_int (comp_type, First);
- if (First < 0)
- for (Idx++, Length--; Length; Idx++, Length--)
- gnu_ret = fold_build2 (MINUS_EXPR, comp_type,
- fold_build2 (MULT_EXPR, comp_type,
- gnu_ret, gnu_base),
- build_cst_from_int (comp_type,
- Udigits_Ptr[Idx]));
- else
- for (Idx++, Length--; Length; Idx++, Length--)
- gnu_ret = fold_build2 (PLUS_EXPR, comp_type,
- fold_build2 (MULT_EXPR, comp_type,
- gnu_ret, gnu_base),
- build_cst_from_int (comp_type,
- Udigits_Ptr[Idx]));
- }
-
- gnu_ret = convert (type, gnu_ret);
-
- /* We don't need any NOP_EXPR or NON_LVALUE_EXPR on GNU_RET. */
- while ((TREE_CODE (gnu_ret) == NOP_EXPR
- || TREE_CODE (gnu_ret) == NON_LVALUE_EXPR)
- && TREE_TYPE (TREE_OPERAND (gnu_ret, 0)) == TREE_TYPE (gnu_ret))
- gnu_ret = TREE_OPERAND (gnu_ret, 0);
-
- return gnu_ret;
-}
-
-/* Similar to UI_From_Int, but take a GCC INTEGER_CST. We use UI_From_Int
- when possible, i.e. for a 32-bit signed value, to take advantage of its
- built-in caching mechanism. For values of larger magnitude, we compute
- digits into a vector and call Vector_To_Uint. */
-
-Uint
-UI_From_gnu (tree Input)
-{
- tree gnu_type = TREE_TYPE (Input), gnu_base, gnu_temp;
- /* UI_Base is defined so that 5 Uint digits is sufficient to hold the
- largest possible signed 64-bit value. */
- const int Max_For_Dint = 5;
- int v[Max_For_Dint], i;
- Vector_Template temp;
- Int_Vector vec;
-
-#if HOST_BITS_PER_WIDE_INT == 64
- /* On 64-bit hosts, host_integerp tells whether the input fits in a
- signed 64-bit integer. Then a truncation tells whether it fits
- in a signed 32-bit integer. */
- if (host_integerp (Input, 0))
- {
- HOST_WIDE_INT hw_input = TREE_INT_CST_LOW (Input);
- if (hw_input == (int) hw_input)
- return UI_From_Int (hw_input);
- }
- else
- return No_Uint;
-#else
- /* On 32-bit hosts, host_integerp tells whether the input fits in a
- signed 32-bit integer. Then a sign test tells whether it fits
- in a signed 64-bit integer. */
- if (host_integerp (Input, 0))
- return UI_From_Int (TREE_INT_CST_LOW (Input));
- else if (TREE_INT_CST_HIGH (Input) < 0
- && TYPE_UNSIGNED (gnu_type)
- && !(TREE_CODE (gnu_type) == INTEGER_TYPE
- && TYPE_IS_SIZETYPE (gnu_type)))
- return No_Uint;
-#endif
-
- gnu_base = build_int_cst (gnu_type, UI_Base);
- gnu_temp = Input;
-
- for (i = Max_For_Dint - 1; i >= 0; i--)
- {
- v[i] = tree_low_cst (fold_build1 (ABS_EXPR, gnu_type,
- fold_build2 (TRUNC_MOD_EXPR, gnu_type,
- gnu_temp, gnu_base)),
- 0);
- gnu_temp = fold_build2 (TRUNC_DIV_EXPR, gnu_type, gnu_temp, gnu_base);
- }
-
- temp.Low_Bound = 1, temp.High_Bound = Max_For_Dint;
- vec.Array = v, vec.Bounds = &temp;
- return Vector_To_Uint (vec, tree_int_cst_sgn (Input) < 0);
-}