OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [ada/] [g-altive.ads] - Blame information for rev 281

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 281 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                         G N A T . A L T I V E C                          --
6
--                                                                          --
7
--                                 S p e c                                  --
8
--                                                                          --
9
--          Copyright (C) 2004-2009, 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.                                     --
17
--                                                                          --
18
-- As a special exception under Section 7 of GPL version 3, you are granted --
19
-- additional permissions described in the GCC Runtime Library Exception,   --
20
-- version 3.1, as published by the Free Software Foundation.               --
21
--                                                                          --
22
-- You should have received a copy of the GNU General Public License and    --
23
-- a copy of the GCC Runtime Library Exception along with this program;     --
24
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
25
-- <http://www.gnu.org/licenses/>.                                          --
26
--                                                                          --
27
-- GNAT was originally developed  by the GNAT team at  New York University. --
28
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
29
--                                                                          --
30
------------------------------------------------------------------------------
31
 
32
-------------------------
33
-- General description --
34
-------------------------
35
 
36
--  This is the root of a package hierarchy offering an Ada binding to the
37
--  PowerPC AltiVec extensions. These extensions basically consist in a set of
38
--  128bit vector types together with a set of subprograms operating on such
39
--  vectors. On a real Altivec capable target, vector objects map to hardware
40
--  vector registers and the subprograms map to a set of specific hardware
41
--  instructions.
42
 
43
--  Relevant documents are:
44
 
45
--  o AltiVec Technology, Programming Interface Manual (1999-06)
46
--    to which we will refer as [PIM], describes the data types, the
47
--    functional interface and the ABI conventions.
48
 
49
--  o AltiVec Technology, Programming Environments Manual (2002-02)
50
--    to which we will refer as [PEM], describes the hardware architecture
51
--    and instruction set.
52
 
53
--  These documents, as well as a number of others of general interest on the
54
--  AltiVec technology, are available from the Motorola/AltiVec Web site at
55
 
56
--  http://www.motorola.com/altivec
57
 
58
--  We offer two versions of this binding: one for real AltiVec capable
59
--  targets, and one for other targets. In the latter case, everything is
60
--  emulated in software. We will refer to the two bindings as:
61
 
62
--  o The Hard binding for AltiVec capable targets (with the appropriate
63
--    hardware support and corresponding instruction set)
64
 
65
--  o The Soft binding for other targets (with the low level primitives
66
--    emulated in software).
67
 
68
--  The two versions of the binding are expected to be equivalent from the
69
--  functional standpoint. The same client application code should observe no
70
--  difference in operation results, even if the Soft version is used on a
71
--  non-powerpc target. The Hard binding is naturally expected to run faster
72
--  than the Soft version on the same target.
73
 
74
--  We also offer interfaces not strictly part of the base AltiVec API, such
75
--  as vector conversions to/from array representations, which are of interest
76
--  for client applications (e.g. for vector initialization purposes) and may
77
--  also be used as implementation facilities.
78
 
79
-----------------------------------------
80
-- General package architecture survey --
81
-----------------------------------------
82
 
83
--  The various vector representations are all "containers" of elementary
84
--  values, the possible types of which are declared in this root package to
85
--  be generally accessible.
86
 
87
--  From the user standpoint, the two versions of the binding are available
88
--  through a consistent hierarchy of units providing identical services:
89
 
90
--                             GNAT.Altivec
91
--                           (component types)
92
--                                   |
93
--          o----------------o----------------o-------------o
94
--          |                |                |             |
95
--    Vector_Types   Vector_Operations   Vector_Views   Conversions
96
 
97
--  The user can manipulate vectors through two families of types: Vector
98
--  types and View types.
99
 
100
--  Vector types are defined in the GNAT.Altivec.Vector_Types package
101
 
102
--  On these types, the user can apply the Altivec operations defined in
103
--  GNAT.Altivec.Vector_Operations. Their layout is opaque and may vary across
104
--  configurations, for it is typically target-endianness dependant.
105
 
106
--  Vector_Types and Vector_Operations implement the core binding to the
107
--  AltiVec API, as described in [PIM-2.1 data types] and [PIM-4 AltiVec
108
--  operations and predicates].
109
 
110
--  View types are defined in the GNAT.Altivec.Vector_Views package
111
 
112
--  These types do not represent Altivec vectors per se, in the sense that the
113
--  Altivec_Operations are not available for them. They are intended to allow
114
--  Vector initializations as well as access to the Vector component values.
115
 
116
--  The GNAT.Altivec.Conversions package is provided to convert a View to the
117
--  corresponding Vector and vice-versa.
118
 
119
--  The two versions of the binding rely on a low level internal interface,
120
--  and switching from one version to the other amounts to select one low
121
--  level implementation instead of the other.
122
 
123
--  The bindings are provided as a set of sources together with a project file
124
--  (altivec.gpr). The hard/soft binding selection is controlled by a project
125
--  variable on targets where switching makes sense. See the example usage
126
--  section below.
127
 
128
---------------------------
129
-- Underlying principles --
130
---------------------------
131
 
132
--  The general organization sketched above has been devised from a number
133
--  of driving ideas:
134
 
135
--  o From the clients standpoint, the two versions of the binding should be
136
--    as easily exchangeable as possible,
137
 
138
--  o From the maintenance standpoint, we want to avoid as much code
139
--    duplication as possible.
140
 
141
--  o From both standpoints above, we want to maintain a clear interface
142
--    separation between the base bindings to the Motorola API and the
143
--    additional facilities.
144
 
145
--  The identification of the low level interface is directly inspired by the
146
--  the base API organization, basically consisting of a rich set of functions
147
--  around a core of low level primitives mapping to AltiVec instructions.
148
 
149
--  See for instance "vec_add" in [PIM-4.4 Generic and Specific AltiVec
150
--  operations]: no less than six result/arguments combinations of byte vector
151
--  types map to "vaddubm".
152
 
153
--  The "hard" version of the low level primitives map to real AltiVec
154
--  instructions via the corresponding GCC builtins. The "soft" version is
155
--  a software emulation of those.
156
 
157
-------------------
158
-- Example usage --
159
-------------------
160
 
161
--  Here is a sample program declaring and initializing two vectors, 'add'ing
162
--  them and displaying the result components:
163
 
164
--  with GNAT.Altivec.Vector_Types;      use GNAT.Altivec.Vector_Types;
165
--  with GNAT.Altivec.Vector_Operations; use GNAT.Altivec.Vector_Operations;
166
--  with GNAT.Altivec.Vector_Views;      use GNAT.Altivec.Vector_Views;
167
--  with GNAT.Altivec.Conversions;       use GNAT.Altivec.Conversions;
168
 
169
--  use GNAT.Altivec;
170
 
171
--  procedure Sample is
172
--     Va : Vector_Unsigned_Int := To_Vector ((Values => (1, 2, 3, 4)));
173
--     Vb : Vector_Unsigned_Int := To_Vector ((Values => (1, 2, 3, 4)));
174
 
175
--     Vs : Vector_Unsigned_Int;
176
--     Vs_View : VUI_View;
177
--  begin
178
--     Vs := Vec_Add (Va, Vb);
179
--     Vs_View := To_View (Vs);
180
 
181
--     for I in Vs_View.Values'Range loop
182
--        Put_Line (Unsigned_Int'Image (Vs_View.Values (I)));
183
--     end loop;
184
--  end;
185
 
186
--  This currently requires the GNAT project management facilities to compile,
187
--  to automatically retrieve the set of necessary sources and switches
188
--  depending on your configuration. For the example above, customizing the
189
--  switches to include -g also, this would be something like:
190
 
191
--  sample.gpr
192
--
193
--  with "altivec.gpr";
194
--
195
--  project Sample is
196
 
197
--    for Source_Dirs use (".");
198
--    for Main use ("sample");
199
 
200
--    package Compiler is
201
--       for Default_Switches ("Ada") use
202
--           Altivec.Compiler'Default_Switches ("Ada") & "-g";
203
--    end Compiler;
204
 
205
--  end Sample;
206
 
207
--  $ gnatmake -Psample
208
--  [...]
209
--  $ ./sample
210
--  2
211
--  4
212
--  6
213
--  8
214
 
215
------------------------------------------------------------------------------
216
 
217
with System;
218
 
219
package GNAT.Altivec is
220
 
221
   --  Definitions of constants and vector/array component types common to all
222
   --  the versions of the binding.
223
 
224
   --  All the vector types are 128bits
225
 
226
   VECTOR_BIT : constant := 128;
227
 
228
   -------------------------------------------
229
   -- [PIM-2.3.1 Alignment of vector types] --
230
   -------------------------------------------
231
 
232
   --  "A defined data item of any vector data type in memory is always
233
   --  aligned on a 16-byte boundary. A pointer to any vector data type always
234
   --  points to a 16-byte boundary. The compiler is responsible for aligning
235
   --  vector data types on 16-byte boundaries."
236
 
237
   VECTOR_ALIGNMENT : constant := Natural'Min (16, Standard'Maximum_Alignment);
238
   --  This value is used to set the alignment of vector datatypes in both the
239
   --  hard and the soft binding implementations.
240
   --
241
   --  We want this value to never be greater than 16, because none of the
242
   --  binding implementations requires larger alignments and such a value
243
   --  would cause useless space to be allocated/wasted for vector objects.
244
   --  Furthermore, the alignment of 16 matches the hard binding leading to
245
   --  a more faithful emulation.
246
   --
247
   --  It needs to be exactly 16 for the hard binding, and the initializing
248
   --  expression is just right for this purpose since Maximum_Alignment is
249
   --  expected to be 16 for the real Altivec ABI.
250
   --
251
   --  The soft binding doesn't rely on strict 16byte alignment, and we want
252
   --  the value to be no greater than Standard'Maximum_Alignment in this case
253
   --  to ensure it is supported on every possible target.
254
 
255
   -------------------------------------------------------
256
   -- [PIM-2.1] Data Types - Interpretation of contents --
257
   -------------------------------------------------------
258
 
259
   ---------------------
260
   -- char components --
261
   ---------------------
262
 
263
   CHAR_BIT    : constant := 8;
264
   SCHAR_MIN   : constant := -2 ** (CHAR_BIT - 1);
265
   SCHAR_MAX   : constant := 2 ** (CHAR_BIT - 1) - 1;
266
   UCHAR_MAX   : constant := 2 ** CHAR_BIT - 1;
267
 
268
   type unsigned_char is mod UCHAR_MAX + 1;
269
   for unsigned_char'Size use CHAR_BIT;
270
 
271
   type signed_char is range SCHAR_MIN .. SCHAR_MAX;
272
   for signed_char'Size use CHAR_BIT;
273
 
274
   subtype bool_char is unsigned_char;
275
   --  ??? There is a difference here between what the Altivec Technology
276
   --  Programming Interface Manual says and what GCC says. In the manual,
277
   --  vector_bool_char is a vector_unsigned_char, while in altivec.h it
278
   --  is a vector_signed_char.
279
 
280
   bool_char_True  : constant bool_char := bool_char'Last;
281
   bool_char_False : constant bool_char := 0;
282
 
283
   ----------------------
284
   -- short components --
285
   ----------------------
286
 
287
   SHORT_BIT   : constant := 16;
288
   SSHORT_MIN  : constant := -2 ** (SHORT_BIT - 1);
289
   SSHORT_MAX  : constant := 2 ** (SHORT_BIT - 1) - 1;
290
   USHORT_MAX  : constant := 2 ** SHORT_BIT - 1;
291
 
292
   type unsigned_short is mod USHORT_MAX + 1;
293
   for unsigned_short'Size use SHORT_BIT;
294
 
295
   subtype unsigned_short_int is unsigned_short;
296
 
297
   type signed_short is range SSHORT_MIN .. SSHORT_MAX;
298
   for signed_short'Size use SHORT_BIT;
299
 
300
   subtype signed_short_int is signed_short;
301
 
302
   subtype bool_short is unsigned_short;
303
   --  ??? See bool_char
304
 
305
   bool_short_True  : constant bool_short := bool_short'Last;
306
   bool_short_False : constant bool_short := 0;
307
 
308
   subtype bool_short_int is bool_short;
309
 
310
   --------------------
311
   -- int components --
312
   --------------------
313
 
314
   INT_BIT     : constant := 32;
315
   SINT_MIN    : constant := -2 ** (INT_BIT - 1);
316
   SINT_MAX    : constant := 2 ** (INT_BIT - 1) - 1;
317
   UINT_MAX    : constant := 2 ** INT_BIT - 1;
318
 
319
   type unsigned_int is mod UINT_MAX + 1;
320
   for unsigned_int'Size use INT_BIT;
321
 
322
   type signed_int is range SINT_MIN .. SINT_MAX;
323
   for signed_int'Size use INT_BIT;
324
 
325
   subtype bool_int is unsigned_int;
326
   --  ??? See bool_char
327
 
328
   bool_int_True  : constant bool_int := bool_int'Last;
329
   bool_int_False : constant bool_int := 0;
330
 
331
   ----------------------
332
   -- float components --
333
   ----------------------
334
 
335
   FLOAT_BIT   : constant := 32;
336
   FLOAT_DIGIT : constant := 6;
337
   FLOAT_MIN   : constant := -16#0.FFFF_FF#E+32;
338
   FLOAT_MAX   : constant := 16#0.FFFF_FF#E+32;
339
 
340
   type C_float is digits FLOAT_DIGIT range FLOAT_MIN .. FLOAT_MAX;
341
   for C_float'Size use FLOAT_BIT;
342
   --  Altivec operations always use the standard native floating-point
343
   --  support of the target. Note that this means that there may be
344
   --  minor differences in results between targets when the floating-
345
   --  point implementations are slightly different, as would happen
346
   --  with normal non-Altivec floating-point operations. In particular
347
   --  the Altivec simulations may yield slightly different results
348
   --  from those obtained on a true hardware Altivec target if the
349
   --  floating-point implementation is not 100% compatible.
350
 
351
   ----------------------
352
   -- pixel components --
353
   ----------------------
354
 
355
   subtype pixel is unsigned_short;
356
 
357
   -----------------------------------------------------------
358
   -- Subtypes for variants found in the GCC implementation --
359
   -----------------------------------------------------------
360
 
361
   subtype c_int is signed_int;
362
   subtype c_short is c_int;
363
 
364
   LONG_BIT  : constant := 32;
365
   --  Some of the GCC builtins are built with "long" arguments and
366
   --  expect SImode to come in.
367
 
368
   SLONG_MIN : constant := -2 ** (LONG_BIT - 1);
369
   SLONG_MAX : constant :=  2 ** (LONG_BIT - 1) - 1;
370
   ULONG_MAX : constant :=  2 ** LONG_BIT - 1;
371
 
372
   type signed_long   is range SLONG_MIN .. SLONG_MAX;
373
   type unsigned_long is mod ULONG_MAX + 1;
374
 
375
   subtype c_long is signed_long;
376
 
377
   subtype c_ptr is System.Address;
378
 
379
   ---------------------------------------------------------
380
   -- Access types, for the sake of some argument passing --
381
   ---------------------------------------------------------
382
 
383
   type signed_char_ptr    is access all signed_char;
384
   type unsigned_char_ptr  is access all unsigned_char;
385
 
386
   type short_ptr          is access all c_short;
387
   type signed_short_ptr   is access all signed_short;
388
   type unsigned_short_ptr is access all unsigned_short;
389
 
390
   type int_ptr            is access all c_int;
391
   type signed_int_ptr     is access all signed_int;
392
   type unsigned_int_ptr   is access all unsigned_int;
393
 
394
   type long_ptr           is access all c_long;
395
   type signed_long_ptr    is access all signed_long;
396
   type unsigned_long_ptr  is access all unsigned_long;
397
 
398
   type float_ptr          is access all Float;
399
 
400
   --
401
 
402
   type const_signed_char_ptr    is access constant signed_char;
403
   type const_unsigned_char_ptr  is access constant unsigned_char;
404
 
405
   type const_short_ptr          is access constant c_short;
406
   type const_signed_short_ptr   is access constant signed_short;
407
   type const_unsigned_short_ptr is access constant unsigned_short;
408
 
409
   type const_int_ptr            is access constant c_int;
410
   type const_signed_int_ptr     is access constant signed_int;
411
   type const_unsigned_int_ptr   is access constant unsigned_int;
412
 
413
   type const_long_ptr           is access constant c_long;
414
   type const_signed_long_ptr    is access constant signed_long;
415
   type const_unsigned_long_ptr  is access constant unsigned_long;
416
 
417
   type const_float_ptr          is access constant Float;
418
 
419
   --  Access to const volatile arguments need specialized types
420
 
421
   type volatile_float is new Float;
422
   pragma Volatile (volatile_float);
423
 
424
   type volatile_signed_char is new signed_char;
425
   pragma Volatile (volatile_signed_char);
426
 
427
   type volatile_unsigned_char is new unsigned_char;
428
   pragma Volatile (volatile_unsigned_char);
429
 
430
   type volatile_signed_short is new signed_short;
431
   pragma Volatile (volatile_signed_short);
432
 
433
   type volatile_unsigned_short is new unsigned_short;
434
   pragma Volatile (volatile_unsigned_short);
435
 
436
   type volatile_signed_int is new signed_int;
437
   pragma Volatile (volatile_signed_int);
438
 
439
   type volatile_unsigned_int is new unsigned_int;
440
   pragma Volatile (volatile_unsigned_int);
441
 
442
   type volatile_signed_long is new signed_long;
443
   pragma Volatile (volatile_signed_long);
444
 
445
   type volatile_unsigned_long is new unsigned_long;
446
   pragma Volatile (volatile_unsigned_long);
447
 
448
   type constv_char_ptr           is access constant volatile_signed_char;
449
   type constv_signed_char_ptr    is access constant volatile_signed_char;
450
   type constv_unsigned_char_ptr  is access constant volatile_unsigned_char;
451
 
452
   type constv_short_ptr          is access constant volatile_signed_short;
453
   type constv_signed_short_ptr   is access constant volatile_signed_short;
454
   type constv_unsigned_short_ptr is access constant volatile_unsigned_short;
455
 
456
   type constv_int_ptr            is access constant volatile_signed_int;
457
   type constv_signed_int_ptr     is access constant volatile_signed_int;
458
   type constv_unsigned_int_ptr   is access constant volatile_unsigned_int;
459
 
460
   type constv_long_ptr           is access constant volatile_signed_long;
461
   type constv_signed_long_ptr    is access constant volatile_signed_long;
462
   type constv_unsigned_long_ptr  is access constant volatile_unsigned_long;
463
 
464
   type constv_float_ptr  is access constant volatile_float;
465
 
466
private
467
 
468
   -----------------------
469
   -- Various constants --
470
   -----------------------
471
 
472
   CR6_EQ     : constant := 0;
473
   CR6_EQ_REV : constant := 1;
474
   CR6_LT     : constant := 2;
475
   CR6_LT_REV : constant := 3;
476
 
477
end GNAT.Altivec;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.