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-2013, 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
28package 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   -- Digits_From_Size --
298   ----------------------
299
300   function Digits_From_Size (Size : Pos) return Pos is
301   begin
302      if    Size =  32 then
303         return  6;
304      elsif Size =  48 then
305         return  9;
306      elsif Size =  64 then
307         return 15;
308      elsif Size =  96 then
309         return 18;
310      elsif Size = 128 then
311         return 18;
312      else
313         raise Program_Error;
314      end if;
315   end Digits_From_Size;
316
317   -----------------------------
318   -- Get_Max_Unaligned_Field --
319   -----------------------------
320
321   function Get_Max_Unaligned_Field return Pos is
322   begin
323      return 64;  -- Can be different on some targets (e.g., AAMP)
324   end Get_Max_Unaligned_Field;
325
326   -----------------------------
327   -- Register_Back_End_Types --
328   -----------------------------
329
330   procedure Register_Back_End_Types (Call_Back : Register_Type_Proc) is
331      procedure Enumerate_Modes (Call_Back : Register_Type_Proc);
332      pragma Import (C, Enumerate_Modes, "enumerate_modes");
333   begin
334      Enumerate_Modes (Call_Back);
335   end Register_Back_End_Types;
336
337   ---------------------
338   -- Width_From_Size --
339   ---------------------
340
341   function Width_From_Size  (Size : Pos) return Pos is
342   begin
343      if    Size =  8 then
344         return  4;
345      elsif Size = 16 then
346         return  6;
347      elsif Size = 32 then
348         return 11;
349      elsif Size = 64 then
350         return 21;
351      else
352         raise Program_Error;
353      end if;
354   end Width_From_Size;
355
356end Get_Targ;
357