gcc/ada/get_targ.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                             G E T _ T A R G                              --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2014, Free Software Foundation, Inc.         --
  10 --                                                                          --
  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  distributed with GNAT; see file COPYING3.  If not, go to --
  19 -- http://www.gnu.org/licenses for a complete copy of the license.          --
  20 --                                                                          --
  21 -- GNAT was originally developed  by the GNAT team at  New York University. --
  22 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  23 --                                                                          --
  24 ------------------------------------------------------------------------------
  25
  26 --  Version for use with gcc
  27
  28 package body Get_Targ is
  29
  30    --  Functions returning individual runtime. For the standard (GCC) back
  31    --  end these come from C interface functions (one for each value).
  32
  33    -----------------------
  34    -- Get_Bits_Per_Unit --
  35    -----------------------
  36
  37    function Get_Bits_Per_Unit return Pos is
  38       function C_Get_Bits_Per_Unit return Pos;
  39       pragma Import (C, C_Get_Bits_Per_Unit,
  40                         "get_target_bits_per_unit");
  41    begin
  42       return C_Get_Bits_Per_Unit;
  43    end Get_Bits_Per_Unit;
  44
  45    -----------------------
  46    -- Get_Bits_Per_Word --
  47    -----------------------
  48
  49    function Get_Bits_Per_Word return Pos is
  50       function C_Get_Bits_Per_Word return Pos;
  51       pragma Import (C, C_Get_Bits_Per_Word,
  52                         "get_target_bits_per_word");
  53    begin
  54       return C_Get_Bits_Per_Word;
  55    end Get_Bits_Per_Word;
  56
  57    -------------------
  58    -- Get_Char_Size --
  59    -------------------
  60
  61    function Get_Char_Size return Pos is
  62       function C_Get_Char_Size return Pos;
  63       pragma Import (C, C_Get_Char_Size,
  64                         "get_target_char_size");
  65    begin
  66       return C_Get_Char_Size;
  67    end Get_Char_Size;
  68
  69    ----------------------
  70    -- Get_Wchar_T_Size --
  71    ----------------------
  72
  73    function Get_Wchar_T_Size return Pos is
  74       function C_Get_Wchar_T_Size return Pos;
  75       pragma Import (C, C_Get_Wchar_T_Size,
  76                         "get_target_wchar_t_size");
  77    begin
  78       return C_Get_Wchar_T_Size;
  79    end Get_Wchar_T_Size;
  80
  81    --------------------
  82    -- Get_Short_Size --
  83    --------------------
  84
  85    function Get_Short_Size return Pos is
  86       function C_Get_Short_Size return Pos;
  87       pragma Import (C, C_Get_Short_Size,
  88                         "get_target_short_size");
  89    begin
  90       return C_Get_Short_Size;
  91    end Get_Short_Size;
  92
  93    ------------------
  94    -- Get_Int_Size --
  95    ------------------
  96
  97    function Get_Int_Size return Pos is
  98       function C_Get_Int_Size return Pos;
  99       pragma Import (C, C_Get_Int_Size,
 100                         "get_target_int_size");
 101    begin
 102       return C_Get_Int_Size;
 103    end Get_Int_Size;
 104
 105    -------------------
 106    -- Get_Long_Size --
 107    -------------------
 108
 109    function Get_Long_Size return Pos is
 110       function C_Get_Long_Size return Pos;
 111       pragma Import (C, C_Get_Long_Size,
 112                         "get_target_long_size");
 113    begin
 114       return C_Get_Long_Size;
 115    end Get_Long_Size;
 116
 117    ------------------------
 118    -- Get_Long_Long_Size --
 119    ------------------------
 120
 121    function Get_Long_Long_Size return Pos is
 122       function C_Get_Long_Long_Size return Pos;
 123       pragma Import (C, C_Get_Long_Long_Size,
 124                         "get_target_long_long_size");
 125    begin
 126       return C_Get_Long_Long_Size;
 127    end Get_Long_Long_Size;
 128
 129    --------------------
 130    -- Get_Float_Size --
 131    --------------------
 132
 133    function Get_Float_Size return Pos is
 134       function C_Get_Float_Size return Pos;
 135       pragma Import (C, C_Get_Float_Size,
 136                         "get_target_float_size");
 137    begin
 138       return C_Get_Float_Size;
 139    end Get_Float_Size;
 140
 141    ---------------------
 142    -- Get_Double_Size --
 143    ---------------------
 144
 145    function Get_Double_Size return Pos is
 146       function C_Get_Double_Size return Pos;
 147       pragma Import (C, C_Get_Double_Size,
 148                         "get_target_double_size");
 149    begin
 150       return C_Get_Double_Size;
 151    end Get_Double_Size;
 152
 153    --------------------------
 154    -- Get_Long_Double_Size --
 155    --------------------------
 156
 157    function Get_Long_Double_Size return Pos is
 158       function C_Get_Long_Double_Size return Pos;
 159       pragma Import (C, C_Get_Long_Double_Size,
 160                         "get_target_long_double_size");
 161    begin
 162       return C_Get_Long_Double_Size;
 163    end Get_Long_Double_Size;
 164
 165    ----------------------
 166    -- Get_Pointer_Size --
 167    ----------------------
 168
 169    function Get_Pointer_Size return Pos is
 170       function C_Get_Pointer_Size return Pos;
 171       pragma Import (C, C_Get_Pointer_Size,
 172                         "get_target_pointer_size");
 173    begin
 174       return C_Get_Pointer_Size;
 175    end Get_Pointer_Size;
 176
 177    ---------------------------
 178    -- Get_Maximum_Alignment --
 179    ---------------------------
 180
 181    function Get_Maximum_Alignment return Pos is
 182       function C_Get_Maximum_Alignment return Pos;
 183       pragma Import (C, C_Get_Maximum_Alignment,
 184                         "get_target_maximum_alignment");
 185    begin
 186       return C_Get_Maximum_Alignment;
 187    end Get_Maximum_Alignment;
 188
 189    ------------------------
 190    -- Get_Float_Words_BE --
 191    ------------------------
 192
 193    function Get_Float_Words_BE return Nat is
 194       function C_Get_Float_Words_BE return Nat;
 195       pragma Import (C, C_Get_Float_Words_BE,
 196                         "get_float_words_be");
 197    begin
 198       return C_Get_Float_Words_BE;
 199    end Get_Float_Words_BE;
 200
 201    ------------------
 202    -- Get_Words_BE --
 203    ------------------
 204
 205    function Get_Words_BE return Nat is
 206       function C_Get_Words_BE return Nat;
 207       pragma Import (C, C_Get_Words_BE,
 208                         "get_words_be");
 209    begin
 210       return C_Get_Words_BE;
 211    end Get_Words_BE;
 212
 213    ------------------
 214    -- Get_Bytes_BE --
 215    ------------------
 216
 217    function Get_Bytes_BE return Nat is
 218       function C_Get_Bytes_BE return Nat;
 219       pragma Import (C, C_Get_Bytes_BE,
 220                         "get_bytes_be");
 221    begin
 222       return C_Get_Bytes_BE;
 223    end Get_Bytes_BE;
 224
 225    -----------------
 226    -- Get_Bits_BE --
 227    -----------------
 228
 229    function Get_Bits_BE return Nat is
 230       function C_Get_Bits_BE return Nat;
 231       pragma Import (C, C_Get_Bits_BE,
 232                         "get_bits_be");
 233    begin
 234       return C_Get_Bits_BE;
 235    end Get_Bits_BE;
 236
 237    ---------------------
 238    -- Get_Short_Enums --
 239    ---------------------
 240
 241    function Get_Short_Enums return Int is
 242       flag_short_enums : Int;
 243       pragma Import (C, flag_short_enums);
 244    begin
 245       return flag_short_enums;
 246    end Get_Short_Enums;
 247
 248    --------------------------
 249    -- Get_Strict_Alignment --
 250    --------------------------
 251
 252    function Get_Strict_Alignment return Nat is
 253       function C_Get_Strict_Alignment return Nat;
 254       pragma Import (C, C_Get_Strict_Alignment,
 255                         "get_target_strict_alignment");
 256    begin
 257       return C_Get_Strict_Alignment;
 258    end Get_Strict_Alignment;
 259
 260    ------------------------------------
 261    -- Get_System_Allocator_Alignment --
 262    ------------------------------------
 263
 264    function Get_System_Allocator_Alignment return Nat is
 265       function C_Get_System_Allocator_Alignment return Nat;
 266       pragma Import (C, C_Get_System_Allocator_Alignment,
 267                         "get_target_system_allocator_alignment");
 268    begin
 269       return C_Get_System_Allocator_Alignment;
 270    end Get_System_Allocator_Alignment;
 271
 272    --------------------------------
 273    -- Get_Double_Float_Alignment --
 274    --------------------------------
 275
 276    function Get_Double_Float_Alignment return Nat is
 277       function C_Get_Double_Float_Alignment return Nat;
 278       pragma Import (C, C_Get_Double_Float_Alignment,
 279                         "get_target_double_float_alignment");
 280    begin
 281       return C_Get_Double_Float_Alignment;
 282    end Get_Double_Float_Alignment;
 283
 284    ---------------------------------
 285    -- Get_Double_Scalar_Alignment --
 286    ---------------------------------
 287
 288    function Get_Double_Scalar_Alignment return Nat is
 289       function C_Get_Double_Scalar_Alignment return Nat;
 290       pragma Import (C, C_Get_Double_Scalar_Alignment,
 291                         "get_target_double_scalar_alignment");
 292    begin
 293       return C_Get_Double_Scalar_Alignment;
 294    end Get_Double_Scalar_Alignment;
 295
 296    ------------------------------
 297    -- Get_Back_End_Config_File --
 298    ------------------------------
 299
 300    function Get_Back_End_Config_File return String_Ptr is
 301    begin
 302       return null;
 303    end Get_Back_End_Config_File;
 304
 305    ----------------------
 306    -- Digits_From_Size --
 307    ----------------------
 308
 309    function Digits_From_Size (Size : Pos) return Pos is
 310    begin
 311       case Size is
 312          when  32    => return  6;
 313          when  48    => return  9;
 314          when  64    => return 15;
 315          when  96    => return 18;
 316          when 128    => return 18;
 317          when others => raise Program_Error;
 318       end case;
 319    end Digits_From_Size;
 320
 321    -----------------------------
 322    -- Get_Max_Unaligned_Field --
 323    -----------------------------
 324
 325    function Get_Max_Unaligned_Field return Pos is
 326    begin
 327       return 64;  -- Can be different on some targets (e.g., AAMP)
 328    end Get_Max_Unaligned_Field;
 329
 330    -----------------------------
 331    -- Register_Back_End_Types --
 332    -----------------------------
 333
 334    procedure Register_Back_End_Types (Call_Back : Register_Type_Proc) is
 335       procedure Enumerate_Modes (Call_Back : Register_Type_Proc);
 336       pragma Import (C, Enumerate_Modes, "enumerate_modes");
 337    begin
 338       Enumerate_Modes (Call_Back);
 339    end Register_Back_End_Types;
 340
 341    ---------------------
 342    -- Width_From_Size --
 343    ---------------------
 344
 345    function Width_From_Size  (Size : Pos) return Pos is
 346    begin
 347       case Size is
 348          when  8     => return  4;
 349          when 16     => return  6;
 350          when 32     => return 11;
 351          when 64     => return 21;
 352          when others => raise Program_Error;
 353       end case;
 354    end Width_From_Size;
 355
 356 end Get_Targ;