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