1------------------------------------------------------------------------------ 2-- -- 3-- GNAT COMPILER COMPONENTS -- 4-- -- 5-- E X P _ P A K D -- 6-- -- 7-- S p e c -- 8-- -- 9-- Copyright (C) 1992-2020, 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-- Expand routines for manipulation of packed arrays 27 28with Rtsfind; use Rtsfind; 29with Types; use Types; 30 31package Exp_Pakd is 32 33 ------------------------------------- 34 -- Implementation of Packed Arrays -- 35 ------------------------------------- 36 37 -- When a packed array (sub)type is frozen, we create a corresponding 38 -- type that will be used to hold the bits of the packed value, and store 39 -- the entity for this type in the Packed_Array_Impl_Type field of the 40 -- E_Array_Type or E_Array_Subtype entity for the packed array. 41 42 -- This packed array type has the name xxxPn, where xxx is the name 43 -- of the packed type, and n is the component size. The expanded 44 -- declaration declares a type that is one of the following: 45 46 -- For an unconstrained array with component size 1,2,4 or any other 47 -- odd component size. These are the cases in which we do not need 48 -- to align the underlying array. 49 50 -- type xxxPn is new Packed_Bytes1; 51 52 -- For an unconstrained array with component size that is divisible 53 -- by 2, but not divisible by 4 (other than 2 itself). These are the 54 -- cases in which we can generate better code if the underlying array 55 -- is 2-byte aligned (see System.Pack_14 in file s-pack14 for example). 56 57 -- type xxxPn is new Packed_Bytes2; 58 59 -- For an unconstrained array with component size that is divisible 60 -- by 4, other than powers of 2 (which either come under the 1,2,4 61 -- exception above, or are not packed at all). These are cases where 62 -- we can generate better code if the underlying array is 4-byte 63 -- aligned (see System.Pack_20 in file s-pack20 for example). 64 65 -- type xxxPn is new Packed_Bytes4; 66 67 -- For a constrained array with a static index type where the number 68 -- of bits does not exceed the size of Unsigned: 69 70 -- type xxxPn is new Unsigned range 0 .. 2 ** nbits - 1; 71 72 -- For a constrained array with a static index type where the number 73 -- of bits is greater than the size of Unsigned, but does not exceed 74 -- the size of Long_Long_Unsigned: 75 76 -- type xxxPn is new Long_Long_Unsigned range 0 .. 2 ** nbits - 1; 77 78 -- For all other constrained arrays, we use one of 79 80 -- type xxxPn is new Packed_Bytes1 (0 .. m); 81 -- type xxxPn is new Packed_Bytes2 (0 .. m); 82 -- type xxxPn is new Packed_Bytes4 (0 .. m); 83 84 -- where m is calculated (from the length of the original packed array) 85 -- to hold the required number of bits, and the choice of the particular 86 -- Packed_Bytes{1,2,4} type is made on the basis of alignment needs as 87 -- described above for the unconstrained case. 88 89 -- When the packed array (sub)type is specified to have the reverse scalar 90 -- storage order, the Packed_Bytes{1,2,4} references above are replaced 91 -- with Rev_Packed_Bytes{1,2,4}. This is necessary because, although the 92 -- component type is Packed_Byte and therefore endian neutral, the scalar 93 -- storage order of the new type must be compatible with that of an outer 94 -- composite type, if this composite type contains a component whose type 95 -- is the packed array (sub)type and which does not start or does not end 96 -- on a storage unit boundary. 97 98 -- When a variable of packed array type is allocated, gigi will allocate 99 -- the amount of space indicated by the corresponding packed array type. 100 -- However, we do NOT attempt to rewrite the types of any references or 101 -- to retype the variable itself, since this would cause all kinds of 102 -- semantic problems in the front end (remember that expansion proceeds 103 -- at the same time as analysis). 104 105 -- For an indexed reference to a packed array, we simply convert the 106 -- reference to the appropriate equivalent reference to the object 107 -- of the packed array type (using unchecked conversion). 108 109 -- In some cases (for internally generated types, and for the subtypes 110 -- for record fields that depend on a discriminant), the corresponding 111 -- packed type cannot be easily generated in advance. In these cases, 112 -- we generate the required subtype on the fly at the reference point. 113 114 -- For the modular case, any unused bits are initialized to zero, and 115 -- all operations maintain these bits as zero (where necessary all 116 -- unchecked conversions from corresponding array values require 117 -- these bits to be clear, which is done automatically by gigi). 118 119 -- For the array cases, there can be unused bits in the last byte, and 120 -- these are neither initialized, nor treated specially in operations 121 -- (i.e. it is allowable for these bits to be clobbered, e.g. by not). 122 123 --------------------------- 124 -- Endian Considerations -- 125 --------------------------- 126 127 -- The standard does not specify the way in which bits are numbered in 128 -- a packed array. There are two reasonable rules for deciding this: 129 130 -- Store the first bit at right end (low order) word. This means 131 -- that the scaled subscript can be used directly as a left shift 132 -- count (if we put bit 0 at the left end, then we need an extra 133 -- subtract to compute the shift count). 134 135 -- Layout the bits so that if the packed boolean array is overlaid on 136 -- a record, using unchecked conversion, then bit 0 of the array is 137 -- the same as the bit numbered bit 0 in a record representation 138 -- clause applying to the record. For example: 139 140 -- type Rec is record 141 -- C : Bits4; 142 -- D : Bits7; 143 -- E : Bits5; 144 -- end record; 145 146 -- for Rec use record 147 -- C at 0 range 0 .. 3; 148 -- D at 0 range 4 .. 10; 149 -- E at 0 range 11 .. 15; 150 -- end record; 151 152 -- type P16 is array (0 .. 15) of Boolean; 153 -- pragma Pack (P16); 154 155 -- Now if we use unchecked conversion to convert a value of the record 156 -- type to the packed array type, according to this second criterion, 157 -- we would expect field D to occupy bits 4..10 of the Boolean array. 158 159 -- Although not required, this correspondence seems a highly desirable 160 -- property, and is one that GNAT decides to guarantee. For a little 161 -- endian machine, we can also meet the first requirement, but for a 162 -- big endian machine, it will be necessary to store the first bit of 163 -- a Boolean array in the left end (most significant) bit of the word. 164 -- This may cost an extra instruction on some machines, but we consider 165 -- that a worthwhile price to pay for the consistency. 166 167 -- One more important point arises in the case where we have a constrained 168 -- subtype of an unconstrained array. Take the case of 20 bits. For the 169 -- unconstrained representation, we would use an array of bytes: 170 171 -- Little-endian case 172 -- 8-7-6-5-4-3-2-1 16-15-14-13-12-11-10-9 x-x-x-x-20-19-18-17 173 174 -- Big-endian case 175 -- 1-2-3-4-5-6-7-8 9-10-11-12-13-14-15-16 17-18-19-20-x-x-x-x 176 177 -- For the constrained case, we use a 20-bit modular value, but in 178 -- general this value may well be stored in 32 bits. Let's look at 179 -- what it looks like: 180 181 -- Little-endian case 182 183 -- x-x-x-x-x-x-x-x-x-x-x-x-20-19-18-17-...-10-9-8-7-6-5-4-3-2-1 184 185 -- which stored in memory looks like 186 187 -- 8-7-...-2-1 16-15-...-10-9 x-x-x-x-20-19-18-17 x-x-x-x-x-x-x 188 189 -- An important rule is that the constrained and unconstrained cases 190 -- must have the same bit representation in memory, since we will often 191 -- convert from one to the other (e.g. when calling a procedure whose 192 -- formal is unconstrained). As we see, that criterion is met for the 193 -- little-endian case above. Now let's look at the big-endian case: 194 195 -- Big-endian case 196 197 -- x-x-x-x-x-x-x-x-x-x-x-x-1-2-3-4-5-6-7-8-9-10-...-17-18-19-20 198 199 -- which stored in memory looks like 200 201 -- x-x-x-x-x-x-x-x x-x-x-x-1-2-3-4 5-6-...11-12 13-14-...-19-20 202 203 -- That won't do, the representation value in memory is NOT the same in 204 -- the constrained and unconstrained case. The solution is to store the 205 -- modular value left-justified: 206 207 -- 1-2-3-4-5-6-7-8-9-10-...-17-18-19-20-x-x-x-x-x-x-x-x-x-x-x 208 209 -- which stored in memory looks like 210 211 -- 1-2-...-7-8 9-10-...15-16 17-18-19-20-x-x-x-x x-x-x-x-x-x-x-x 212 213 -- and now, we do indeed have the same representation for the memory 214 -- version in the constrained and unconstrained cases. 215 216 ---------------------------------------------- 217 -- Entity Tables for Packed Access Routines -- 218 ---------------------------------------------- 219 220 -- For the cases of component size = 3,5-7,9-15,17-31,33-63,65-127 we call 221 -- library routines. These tables provide the entity for the right routine. 222 -- They are exposed in the spec to allow checking for the presence of the 223 -- needed routine when an array is subject to pragma Pack. 224 225 type E_Array is array (Int range 1 .. 127) of RE_Id; 226 227 -- Array of Bits_nn entities. Note that we do not use library routines 228 -- for the 8-bit and 16-bit cases, but we still fill in the table, using 229 -- entries from System.Unsigned, because we also use this table for 230 -- certain special unchecked conversions in the big-endian case. 231 232 Bits_Id : constant E_Array := 233 (01 => RE_Bits_1, 234 02 => RE_Bits_2, 235 03 => RE_Bits_03, 236 04 => RE_Bits_4, 237 05 => RE_Bits_05, 238 06 => RE_Bits_06, 239 07 => RE_Bits_07, 240 08 => RE_Unsigned_8, 241 09 => RE_Bits_09, 242 10 => RE_Bits_10, 243 11 => RE_Bits_11, 244 12 => RE_Bits_12, 245 13 => RE_Bits_13, 246 14 => RE_Bits_14, 247 15 => RE_Bits_15, 248 16 => RE_Unsigned_16, 249 17 => RE_Bits_17, 250 18 => RE_Bits_18, 251 19 => RE_Bits_19, 252 20 => RE_Bits_20, 253 21 => RE_Bits_21, 254 22 => RE_Bits_22, 255 23 => RE_Bits_23, 256 24 => RE_Bits_24, 257 25 => RE_Bits_25, 258 26 => RE_Bits_26, 259 27 => RE_Bits_27, 260 28 => RE_Bits_28, 261 29 => RE_Bits_29, 262 30 => RE_Bits_30, 263 31 => RE_Bits_31, 264 32 => RE_Unsigned_32, 265 33 => RE_Bits_33, 266 34 => RE_Bits_34, 267 35 => RE_Bits_35, 268 36 => RE_Bits_36, 269 37 => RE_Bits_37, 270 38 => RE_Bits_38, 271 39 => RE_Bits_39, 272 40 => RE_Bits_40, 273 41 => RE_Bits_41, 274 42 => RE_Bits_42, 275 43 => RE_Bits_43, 276 44 => RE_Bits_44, 277 45 => RE_Bits_45, 278 46 => RE_Bits_46, 279 47 => RE_Bits_47, 280 48 => RE_Bits_48, 281 49 => RE_Bits_49, 282 50 => RE_Bits_50, 283 51 => RE_Bits_51, 284 52 => RE_Bits_52, 285 53 => RE_Bits_53, 286 54 => RE_Bits_54, 287 55 => RE_Bits_55, 288 56 => RE_Bits_56, 289 57 => RE_Bits_57, 290 58 => RE_Bits_58, 291 59 => RE_Bits_59, 292 60 => RE_Bits_60, 293 61 => RE_Bits_61, 294 62 => RE_Bits_62, 295 63 => RE_Bits_63, 296 64 => RE_Unsigned_64, 297 65 => RE_Bits_65, 298 66 => RE_Bits_66, 299 67 => RE_Bits_67, 300 68 => RE_Bits_68, 301 69 => RE_Bits_69, 302 70 => RE_Bits_70, 303 71 => RE_Bits_71, 304 72 => RE_Bits_72, 305 73 => RE_Bits_73, 306 74 => RE_Bits_74, 307 75 => RE_Bits_75, 308 76 => RE_Bits_76, 309 77 => RE_Bits_77, 310 78 => RE_Bits_78, 311 79 => RE_Bits_79, 312 80 => RE_Bits_80, 313 81 => RE_Bits_81, 314 82 => RE_Bits_82, 315 83 => RE_Bits_83, 316 84 => RE_Bits_84, 317 85 => RE_Bits_85, 318 86 => RE_Bits_86, 319 87 => RE_Bits_87, 320 88 => RE_Bits_88, 321 89 => RE_Bits_89, 322 90 => RE_Bits_90, 323 91 => RE_Bits_91, 324 92 => RE_Bits_92, 325 93 => RE_Bits_93, 326 94 => RE_Bits_94, 327 95 => RE_Bits_95, 328 96 => RE_Bits_96, 329 97 => RE_Bits_97, 330 98 => RE_Bits_98, 331 99 => RE_Bits_99, 332 100 => RE_Bits_100, 333 101 => RE_Bits_101, 334 102 => RE_Bits_102, 335 103 => RE_Bits_103, 336 104 => RE_Bits_104, 337 105 => RE_Bits_105, 338 106 => RE_Bits_106, 339 107 => RE_Bits_107, 340 108 => RE_Bits_108, 341 109 => RE_Bits_109, 342 110 => RE_Bits_110, 343 111 => RE_Bits_111, 344 112 => RE_Bits_112, 345 113 => RE_Bits_113, 346 114 => RE_Bits_114, 347 115 => RE_Bits_115, 348 116 => RE_Bits_116, 349 117 => RE_Bits_117, 350 118 => RE_Bits_118, 351 119 => RE_Bits_119, 352 120 => RE_Bits_120, 353 121 => RE_Bits_121, 354 122 => RE_Bits_122, 355 123 => RE_Bits_123, 356 124 => RE_Bits_124, 357 125 => RE_Bits_125, 358 126 => RE_Bits_126, 359 127 => RE_Bits_127); 360 361 -- Array of Get routine entities. These are used to obtain an element from 362 -- a packed array. The N'th entry is used to obtain elements from a packed 363 -- array whose component size is N. RE_Null is used as a null entry, for 364 -- the cases where a library routine is not used. 365 366 Get_Id : constant E_Array := 367 (01 => RE_Null, 368 02 => RE_Null, 369 03 => RE_Get_03, 370 04 => RE_Null, 371 05 => RE_Get_05, 372 06 => RE_Get_06, 373 07 => RE_Get_07, 374 08 => RE_Null, 375 09 => RE_Get_09, 376 10 => RE_Get_10, 377 11 => RE_Get_11, 378 12 => RE_Get_12, 379 13 => RE_Get_13, 380 14 => RE_Get_14, 381 15 => RE_Get_15, 382 16 => RE_Null, 383 17 => RE_Get_17, 384 18 => RE_Get_18, 385 19 => RE_Get_19, 386 20 => RE_Get_20, 387 21 => RE_Get_21, 388 22 => RE_Get_22, 389 23 => RE_Get_23, 390 24 => RE_Get_24, 391 25 => RE_Get_25, 392 26 => RE_Get_26, 393 27 => RE_Get_27, 394 28 => RE_Get_28, 395 29 => RE_Get_29, 396 30 => RE_Get_30, 397 31 => RE_Get_31, 398 32 => RE_Null, 399 33 => RE_Get_33, 400 34 => RE_Get_34, 401 35 => RE_Get_35, 402 36 => RE_Get_36, 403 37 => RE_Get_37, 404 38 => RE_Get_38, 405 39 => RE_Get_39, 406 40 => RE_Get_40, 407 41 => RE_Get_41, 408 42 => RE_Get_42, 409 43 => RE_Get_43, 410 44 => RE_Get_44, 411 45 => RE_Get_45, 412 46 => RE_Get_46, 413 47 => RE_Get_47, 414 48 => RE_Get_48, 415 49 => RE_Get_49, 416 50 => RE_Get_50, 417 51 => RE_Get_51, 418 52 => RE_Get_52, 419 53 => RE_Get_53, 420 54 => RE_Get_54, 421 55 => RE_Get_55, 422 56 => RE_Get_56, 423 57 => RE_Get_57, 424 58 => RE_Get_58, 425 59 => RE_Get_59, 426 60 => RE_Get_60, 427 61 => RE_Get_61, 428 62 => RE_Get_62, 429 63 => RE_Get_63, 430 64 => RE_Null, 431 65 => RE_Get_65, 432 66 => RE_Get_66, 433 67 => RE_Get_67, 434 68 => RE_Get_68, 435 69 => RE_Get_69, 436 70 => RE_Get_70, 437 71 => RE_Get_71, 438 72 => RE_Get_72, 439 73 => RE_Get_73, 440 74 => RE_Get_74, 441 75 => RE_Get_75, 442 76 => RE_Get_76, 443 77 => RE_Get_77, 444 78 => RE_Get_78, 445 79 => RE_Get_79, 446 80 => RE_Get_80, 447 81 => RE_Get_81, 448 82 => RE_Get_82, 449 83 => RE_Get_83, 450 84 => RE_Get_84, 451 85 => RE_Get_85, 452 86 => RE_Get_86, 453 87 => RE_Get_87, 454 88 => RE_Get_88, 455 89 => RE_Get_89, 456 90 => RE_Get_90, 457 91 => RE_Get_91, 458 92 => RE_Get_92, 459 93 => RE_Get_93, 460 94 => RE_Get_94, 461 95 => RE_Get_95, 462 96 => RE_Get_96, 463 97 => RE_Get_97, 464 98 => RE_Get_98, 465 99 => RE_Get_99, 466 100 => RE_Get_100, 467 101 => RE_Get_101, 468 102 => RE_Get_102, 469 103 => RE_Get_103, 470 104 => RE_Get_104, 471 105 => RE_Get_105, 472 106 => RE_Get_106, 473 107 => RE_Get_107, 474 108 => RE_Get_108, 475 109 => RE_Get_109, 476 110 => RE_Get_110, 477 111 => RE_Get_111, 478 112 => RE_Get_112, 479 113 => RE_Get_113, 480 114 => RE_Get_114, 481 115 => RE_Get_115, 482 116 => RE_Get_116, 483 117 => RE_Get_117, 484 118 => RE_Get_118, 485 119 => RE_Get_119, 486 120 => RE_Get_120, 487 121 => RE_Get_121, 488 122 => RE_Get_122, 489 123 => RE_Get_123, 490 124 => RE_Get_124, 491 125 => RE_Get_125, 492 126 => RE_Get_126, 493 127 => RE_Get_127); 494 495 -- Array of Get routine entities to be used in the case where the packed 496 -- array is itself a component of a packed structure, and therefore may not 497 -- be fully aligned. This only affects the even sizes, since for the odd 498 -- sizes, we do not get any fixed alignment in any case. 499 500 GetU_Id : constant E_Array := 501 (01 => RE_Null, 502 02 => RE_Null, 503 03 => RE_Get_03, 504 04 => RE_Null, 505 05 => RE_Get_05, 506 06 => RE_GetU_06, 507 07 => RE_Get_07, 508 08 => RE_Null, 509 09 => RE_Get_09, 510 10 => RE_GetU_10, 511 11 => RE_Get_11, 512 12 => RE_GetU_12, 513 13 => RE_Get_13, 514 14 => RE_GetU_14, 515 15 => RE_Get_15, 516 16 => RE_Null, 517 17 => RE_Get_17, 518 18 => RE_GetU_18, 519 19 => RE_Get_19, 520 20 => RE_GetU_20, 521 21 => RE_Get_21, 522 22 => RE_GetU_22, 523 23 => RE_Get_23, 524 24 => RE_GetU_24, 525 25 => RE_Get_25, 526 26 => RE_GetU_26, 527 27 => RE_Get_27, 528 28 => RE_GetU_28, 529 29 => RE_Get_29, 530 30 => RE_GetU_30, 531 31 => RE_Get_31, 532 32 => RE_Null, 533 33 => RE_Get_33, 534 34 => RE_GetU_34, 535 35 => RE_Get_35, 536 36 => RE_GetU_36, 537 37 => RE_Get_37, 538 38 => RE_GetU_38, 539 39 => RE_Get_39, 540 40 => RE_GetU_40, 541 41 => RE_Get_41, 542 42 => RE_GetU_42, 543 43 => RE_Get_43, 544 44 => RE_GetU_44, 545 45 => RE_Get_45, 546 46 => RE_GetU_46, 547 47 => RE_Get_47, 548 48 => RE_GetU_48, 549 49 => RE_Get_49, 550 50 => RE_GetU_50, 551 51 => RE_Get_51, 552 52 => RE_GetU_52, 553 53 => RE_Get_53, 554 54 => RE_GetU_54, 555 55 => RE_Get_55, 556 56 => RE_GetU_56, 557 57 => RE_Get_57, 558 58 => RE_GetU_58, 559 59 => RE_Get_59, 560 60 => RE_GetU_60, 561 61 => RE_Get_61, 562 62 => RE_GetU_62, 563 63 => RE_Get_63, 564 64 => RE_Null, 565 65 => RE_Get_65, 566 66 => RE_GetU_66, 567 67 => RE_Get_67, 568 68 => RE_GetU_68, 569 69 => RE_Get_69, 570 70 => RE_GetU_70, 571 71 => RE_Get_71, 572 72 => RE_GetU_72, 573 73 => RE_Get_73, 574 74 => RE_GetU_74, 575 75 => RE_Get_75, 576 76 => RE_GetU_76, 577 77 => RE_Get_77, 578 78 => RE_GetU_78, 579 79 => RE_Get_79, 580 80 => RE_GetU_80, 581 81 => RE_Get_81, 582 82 => RE_GetU_82, 583 83 => RE_Get_83, 584 84 => RE_GetU_84, 585 85 => RE_Get_85, 586 86 => RE_GetU_86, 587 87 => RE_Get_87, 588 88 => RE_GetU_88, 589 89 => RE_Get_89, 590 90 => RE_GetU_90, 591 91 => RE_Get_91, 592 92 => RE_GetU_92, 593 93 => RE_Get_93, 594 94 => RE_GetU_94, 595 95 => RE_Get_95, 596 96 => RE_GetU_96, 597 97 => RE_Get_97, 598 98 => RE_GetU_98, 599 99 => RE_Get_99, 600 100 => RE_GetU_100, 601 101 => RE_Get_101, 602 102 => RE_GetU_102, 603 103 => RE_Get_103, 604 104 => RE_GetU_104, 605 105 => RE_Get_105, 606 106 => RE_GetU_106, 607 107 => RE_Get_107, 608 108 => RE_GetU_108, 609 109 => RE_Get_109, 610 110 => RE_GetU_110, 611 111 => RE_Get_111, 612 112 => RE_GetU_112, 613 113 => RE_Get_113, 614 114 => RE_GetU_114, 615 115 => RE_Get_115, 616 116 => RE_GetU_116, 617 117 => RE_Get_117, 618 118 => RE_GetU_118, 619 119 => RE_Get_119, 620 120 => RE_GetU_120, 621 121 => RE_Get_121, 622 122 => RE_GetU_122, 623 123 => RE_Get_123, 624 124 => RE_GetU_124, 625 125 => RE_Get_125, 626 126 => RE_GetU_126, 627 127 => RE_Get_127); 628 629 -- Array of Set routine entities. These are used to assign an element of a 630 -- packed array. The N'th entry is used to assign elements for a packed 631 -- array whose component size is N. RE_Null is used as a null entry, for 632 -- the cases where a library routine is not used. 633 634 Set_Id : constant E_Array := 635 (01 => RE_Null, 636 02 => RE_Null, 637 03 => RE_Set_03, 638 04 => RE_Null, 639 05 => RE_Set_05, 640 06 => RE_Set_06, 641 07 => RE_Set_07, 642 08 => RE_Null, 643 09 => RE_Set_09, 644 10 => RE_Set_10, 645 11 => RE_Set_11, 646 12 => RE_Set_12, 647 13 => RE_Set_13, 648 14 => RE_Set_14, 649 15 => RE_Set_15, 650 16 => RE_Null, 651 17 => RE_Set_17, 652 18 => RE_Set_18, 653 19 => RE_Set_19, 654 20 => RE_Set_20, 655 21 => RE_Set_21, 656 22 => RE_Set_22, 657 23 => RE_Set_23, 658 24 => RE_Set_24, 659 25 => RE_Set_25, 660 26 => RE_Set_26, 661 27 => RE_Set_27, 662 28 => RE_Set_28, 663 29 => RE_Set_29, 664 30 => RE_Set_30, 665 31 => RE_Set_31, 666 32 => RE_Null, 667 33 => RE_Set_33, 668 34 => RE_Set_34, 669 35 => RE_Set_35, 670 36 => RE_Set_36, 671 37 => RE_Set_37, 672 38 => RE_Set_38, 673 39 => RE_Set_39, 674 40 => RE_Set_40, 675 41 => RE_Set_41, 676 42 => RE_Set_42, 677 43 => RE_Set_43, 678 44 => RE_Set_44, 679 45 => RE_Set_45, 680 46 => RE_Set_46, 681 47 => RE_Set_47, 682 48 => RE_Set_48, 683 49 => RE_Set_49, 684 50 => RE_Set_50, 685 51 => RE_Set_51, 686 52 => RE_Set_52, 687 53 => RE_Set_53, 688 54 => RE_Set_54, 689 55 => RE_Set_55, 690 56 => RE_Set_56, 691 57 => RE_Set_57, 692 58 => RE_Set_58, 693 59 => RE_Set_59, 694 60 => RE_Set_60, 695 61 => RE_Set_61, 696 62 => RE_Set_62, 697 63 => RE_Set_63, 698 64 => RE_Null, 699 65 => RE_Set_65, 700 66 => RE_Set_66, 701 67 => RE_Set_67, 702 68 => RE_Set_68, 703 69 => RE_Set_69, 704 70 => RE_Set_70, 705 71 => RE_Set_71, 706 72 => RE_Set_72, 707 73 => RE_Set_73, 708 74 => RE_Set_74, 709 75 => RE_Set_75, 710 76 => RE_Set_76, 711 77 => RE_Set_77, 712 78 => RE_Set_78, 713 79 => RE_Set_79, 714 80 => RE_Set_80, 715 81 => RE_Set_81, 716 82 => RE_Set_82, 717 83 => RE_Set_83, 718 84 => RE_Set_84, 719 85 => RE_Set_85, 720 86 => RE_Set_86, 721 87 => RE_Set_87, 722 88 => RE_Set_88, 723 89 => RE_Set_89, 724 90 => RE_Set_90, 725 91 => RE_Set_91, 726 92 => RE_Set_92, 727 93 => RE_Set_93, 728 94 => RE_Set_94, 729 95 => RE_Set_95, 730 96 => RE_Set_96, 731 97 => RE_Set_97, 732 98 => RE_Set_98, 733 99 => RE_Set_99, 734 100 => RE_Set_100, 735 101 => RE_Set_101, 736 102 => RE_Set_102, 737 103 => RE_Set_103, 738 104 => RE_Set_104, 739 105 => RE_Set_105, 740 106 => RE_Set_106, 741 107 => RE_Set_107, 742 108 => RE_Set_108, 743 109 => RE_Set_109, 744 110 => RE_Set_110, 745 111 => RE_Set_111, 746 112 => RE_Set_112, 747 113 => RE_Set_113, 748 114 => RE_Set_114, 749 115 => RE_Set_115, 750 116 => RE_Set_116, 751 117 => RE_Set_117, 752 118 => RE_Set_118, 753 119 => RE_Set_119, 754 120 => RE_Set_120, 755 121 => RE_Set_121, 756 122 => RE_Set_122, 757 123 => RE_Set_123, 758 124 => RE_Set_124, 759 125 => RE_Set_125, 760 126 => RE_Set_126, 761 127 => RE_Set_127); 762 763 -- Array of Set routine entities to be used in the case where the packed 764 -- array is itself a component of a packed structure, and therefore may not 765 -- be fully aligned. This only affects the even sizes, since for the odd 766 -- sizes, we do not get any fixed alignment in any case. 767 768 SetU_Id : constant E_Array := 769 (01 => RE_Null, 770 02 => RE_Null, 771 03 => RE_Set_03, 772 04 => RE_Null, 773 05 => RE_Set_05, 774 06 => RE_SetU_06, 775 07 => RE_Set_07, 776 08 => RE_Null, 777 09 => RE_Set_09, 778 10 => RE_SetU_10, 779 11 => RE_Set_11, 780 12 => RE_SetU_12, 781 13 => RE_Set_13, 782 14 => RE_SetU_14, 783 15 => RE_Set_15, 784 16 => RE_Null, 785 17 => RE_Set_17, 786 18 => RE_SetU_18, 787 19 => RE_Set_19, 788 20 => RE_SetU_20, 789 21 => RE_Set_21, 790 22 => RE_SetU_22, 791 23 => RE_Set_23, 792 24 => RE_SetU_24, 793 25 => RE_Set_25, 794 26 => RE_SetU_26, 795 27 => RE_Set_27, 796 28 => RE_SetU_28, 797 29 => RE_Set_29, 798 30 => RE_SetU_30, 799 31 => RE_Set_31, 800 32 => RE_Null, 801 33 => RE_Set_33, 802 34 => RE_SetU_34, 803 35 => RE_Set_35, 804 36 => RE_SetU_36, 805 37 => RE_Set_37, 806 38 => RE_SetU_38, 807 39 => RE_Set_39, 808 40 => RE_SetU_40, 809 41 => RE_Set_41, 810 42 => RE_SetU_42, 811 43 => RE_Set_43, 812 44 => RE_SetU_44, 813 45 => RE_Set_45, 814 46 => RE_SetU_46, 815 47 => RE_Set_47, 816 48 => RE_SetU_48, 817 49 => RE_Set_49, 818 50 => RE_SetU_50, 819 51 => RE_Set_51, 820 52 => RE_SetU_52, 821 53 => RE_Set_53, 822 54 => RE_SetU_54, 823 55 => RE_Set_55, 824 56 => RE_SetU_56, 825 57 => RE_Set_57, 826 58 => RE_SetU_58, 827 59 => RE_Set_59, 828 60 => RE_SetU_60, 829 61 => RE_Set_61, 830 62 => RE_SetU_62, 831 63 => RE_Set_63, 832 64 => RE_Null, 833 65 => RE_Set_65, 834 66 => RE_SetU_66, 835 67 => RE_Set_67, 836 68 => RE_SetU_68, 837 69 => RE_Set_69, 838 70 => RE_SetU_70, 839 71 => RE_Set_71, 840 72 => RE_SetU_72, 841 73 => RE_Set_73, 842 74 => RE_SetU_74, 843 75 => RE_Set_75, 844 76 => RE_SetU_76, 845 77 => RE_Set_77, 846 78 => RE_SetU_78, 847 79 => RE_Set_79, 848 80 => RE_SetU_80, 849 81 => RE_Set_81, 850 82 => RE_SetU_82, 851 83 => RE_Set_83, 852 84 => RE_SetU_84, 853 85 => RE_Set_85, 854 86 => RE_SetU_86, 855 87 => RE_Set_87, 856 88 => RE_SetU_88, 857 89 => RE_Set_89, 858 90 => RE_SetU_90, 859 91 => RE_Set_91, 860 92 => RE_SetU_92, 861 93 => RE_Set_93, 862 94 => RE_SetU_94, 863 95 => RE_Set_95, 864 96 => RE_SetU_96, 865 97 => RE_Set_97, 866 98 => RE_SetU_98, 867 99 => RE_Set_99, 868 100 => RE_SetU_100, 869 101 => RE_Set_101, 870 102 => RE_SetU_102, 871 103 => RE_Set_103, 872 104 => RE_SetU_104, 873 105 => RE_Set_105, 874 106 => RE_SetU_106, 875 107 => RE_Set_107, 876 108 => RE_SetU_108, 877 109 => RE_Set_109, 878 110 => RE_SetU_110, 879 111 => RE_Set_111, 880 112 => RE_SetU_112, 881 113 => RE_Set_113, 882 114 => RE_SetU_114, 883 115 => RE_Set_115, 884 116 => RE_SetU_116, 885 117 => RE_Set_117, 886 118 => RE_SetU_118, 887 119 => RE_Set_119, 888 120 => RE_SetU_120, 889 121 => RE_Set_121, 890 122 => RE_SetU_122, 891 123 => RE_Set_123, 892 124 => RE_SetU_124, 893 125 => RE_Set_125, 894 126 => RE_SetU_126, 895 127 => RE_Set_127); 896 897 ----------------- 898 -- Subprograms -- 899 ----------------- 900 901 procedure Create_Packed_Array_Impl_Type (Typ : Entity_Id); 902 -- Typ is a array type or subtype to which pragma Pack applies. If the 903 -- Packed_Array_Impl_Type field of Typ is already set, then the call has 904 -- no effect, otherwise a suitable type or subtype is created and stored in 905 -- the Packed_Array_Impl_Type field of Typ. This created type is an Itype 906 -- so that Gigi will simply elaborate and freeze the type on first use 907 -- (which is typically the definition of the corresponding array type). 908 -- 909 -- Note: although this routine is included in the expander package for 910 -- packed types, it is actually called unconditionally from Freeze, 911 -- whether or not expansion (and code generation) is enabled. We do this 912 -- since we want gigi to be able to properly compute type characteristics 913 -- (for the Data Decomposition Annex of ASIS, and possible other future 914 -- uses) even if code generation is not active. Strictly this means that 915 -- this procedure is not part of the expander, but it seems appropriate 916 -- to keep it together with the other expansion routines that have to do 917 -- with packed array types. 918 919 procedure Expand_Packed_Boolean_Operator (N : Node_Id); 920 -- N is an N_Op_And, N_Op_Or or N_Op_Xor node whose operand type is a 921 -- packed boolean array. This routine expands the appropriate operations 922 -- to carry out the logical operation on the packed arrays. It handles 923 -- both the modular and array representation cases. 924 925 procedure Expand_Packed_Element_Reference (N : Node_Id); 926 -- N is an N_Indexed_Component node whose prefix is a packed array. In 927 -- the bit packed case, this routine can only be used for the expression 928 -- evaluation case, not the assignment case, since the result is not a 929 -- variable. See Expand_Bit_Packed_Element_Set for how the assignment case 930 -- is handled in the bit packed case. For the enumeration case, the result 931 -- of this call is always a variable, so the call can be used for both the 932 -- expression evaluation and assignment cases. 933 934 procedure Expand_Bit_Packed_Element_Set (N : Node_Id); 935 -- N is an N_Assignment_Statement node whose name is an indexed 936 -- component of a bit-packed array. This procedure rewrites the entire 937 -- assignment statement with appropriate code to set the referenced 938 -- bits of the packed array type object. Note that this procedure is 939 -- used only for the bit-packed case, not for the enumeration case. 940 941 procedure Expand_Packed_Eq (N : Node_Id); 942 -- N is an N_Op_Eq node where the operands are packed arrays whose 943 -- representation is an array-of-bytes type (the case where a modular 944 -- type is used for the representation does not require any special 945 -- handling, because in the modular case, unused bits are zeroes. 946 947 procedure Expand_Packed_Not (N : Node_Id); 948 -- N is an N_Op_Not node where the operand is packed array of Boolean 949 -- in standard representation (i.e. component size is one bit). This 950 -- procedure expands the corresponding not operation. Note that the 951 -- non-standard representation case is handled by using a loop through 952 -- elements generated by the normal non-packed circuitry. 953 954 function Involves_Packed_Array_Reference (N : Node_Id) return Boolean; 955 -- N is the node for a name. This function returns true if the name 956 -- involves a packed array reference. A node involves a packed array 957 -- reference if it is itself an indexed component referring to a bit- 958 -- packed array, or it is a selected component whose prefix involves 959 -- a packed array reference. 960 961 procedure Expand_Packed_Address_Reference (N : Node_Id); 962 -- The node N is an attribute reference for the 'Address reference, where 963 -- the prefix involves a packed array reference. This routine expands the 964 -- necessary code for performing the address reference in this case. 965 966 procedure Expand_Packed_Bit_Reference (N : Node_Id); 967 -- The node N is an attribute reference for the 'Bit reference, where the 968 -- prefix involves a packed array reference. This routine expands the 969 -- necessary code for performing the bit reference in this case. 970 971end Exp_Pakd; 972