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-2019, 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 a variable of packed array type is allocated, gigi will allocate 90 -- the amount of space indicated by the corresponding packed array type. 91 -- However, we do NOT attempt to rewrite the types of any references or 92 -- to retype the variable itself, since this would cause all kinds of 93 -- semantic problems in the front end (remember that expansion proceeds 94 -- at the same time as analysis). 95 96 -- For an indexed reference to a packed array, we simply convert the 97 -- reference to the appropriate equivalent reference to the object 98 -- of the packed array type (using unchecked conversion). 99 100 -- In some cases (for internally generated types, and for the subtypes 101 -- for record fields that depend on a discriminant), the corresponding 102 -- packed type cannot be easily generated in advance. In these cases, 103 -- we generate the required subtype on the fly at the reference point. 104 105 -- For the modular case, any unused bits are initialized to zero, and 106 -- all operations maintain these bits as zero (where necessary all 107 -- unchecked conversions from corresponding array values require 108 -- these bits to be clear, which is done automatically by gigi). 109 110 -- For the array cases, there can be unused bits in the last byte, and 111 -- these are neither initialized, nor treated specially in operations 112 -- (i.e. it is allowable for these bits to be clobbered, e.g. by not). 113 114 --------------------------- 115 -- Endian Considerations -- 116 --------------------------- 117 118 -- The standard does not specify the way in which bits are numbered in 119 -- a packed array. There are two reasonable rules for deciding this: 120 121 -- Store the first bit at right end (low order) word. This means 122 -- that the scaled subscript can be used directly as a left shift 123 -- count (if we put bit 0 at the left end, then we need an extra 124 -- subtract to compute the shift count). 125 126 -- Layout the bits so that if the packed boolean array is overlaid on 127 -- a record, using unchecked conversion, then bit 0 of the array is 128 -- the same as the bit numbered bit 0 in a record representation 129 -- clause applying to the record. For example: 130 131 -- type Rec is record 132 -- C : Bits4; 133 -- D : Bits7; 134 -- E : Bits5; 135 -- end record; 136 137 -- for Rec use record 138 -- C at 0 range 0 .. 3; 139 -- D at 0 range 4 .. 10; 140 -- E at 0 range 11 .. 15; 141 -- end record; 142 143 -- type P16 is array (0 .. 15) of Boolean; 144 -- pragma Pack (P16); 145 146 -- Now if we use unchecked conversion to convert a value of the record 147 -- type to the packed array type, according to this second criterion, 148 -- we would expect field D to occupy bits 4..10 of the Boolean array. 149 150 -- Although not required, this correspondence seems a highly desirable 151 -- property, and is one that GNAT decides to guarantee. For a little 152 -- endian machine, we can also meet the first requirement, but for a 153 -- big endian machine, it will be necessary to store the first bit of 154 -- a Boolean array in the left end (most significant) bit of the word. 155 -- This may cost an extra instruction on some machines, but we consider 156 -- that a worthwhile price to pay for the consistency. 157 158 -- One more important point arises in the case where we have a constrained 159 -- subtype of an unconstrained array. Take the case of 20 bits. For the 160 -- unconstrained representation, we would use an array of bytes: 161 162 -- Little-endian case 163 -- 8-7-6-5-4-3-2-1 16-15-14-13-12-11-10-9 x-x-x-x-20-19-18-17 164 165 -- Big-endian case 166 -- 1-2-3-4-5-6-7-8 9-10-11-12-13-14-15-16 17-18-19-20-x-x-x-x 167 168 -- For the constrained case, we use a 20-bit modular value, but in 169 -- general this value may well be stored in 32 bits. Let's look at 170 -- what it looks like: 171 172 -- Little-endian case 173 174 -- 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 175 176 -- which stored in memory looks like 177 178 -- 8-7-...-2-1 16-15-...-10-9 x-x-x-x-20-19-18-17 x-x-x-x-x-x-x 179 180 -- An important rule is that the constrained and unconstrained cases 181 -- must have the same bit representation in memory, since we will often 182 -- convert from one to the other (e.g. when calling a procedure whose 183 -- formal is unconstrained). As we see, that criterion is met for the 184 -- little-endian case above. Now let's look at the big-endian case: 185 186 -- Big-endian case 187 188 -- 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 189 190 -- which stored in memory looks like 191 192 -- x-x-x-x-x-x-x-x x-x-x-x-1-2-3-4 5-6-...11-12 13-14-...-19-20 193 194 -- That won't do, the representation value in memory is NOT the same in 195 -- the constrained and unconstrained case. The solution is to store the 196 -- modular value left-justified: 197 198 -- 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 199 200 -- which stored in memory looks like 201 202 -- 1-2-...-7-8 9-10-...15-16 17-18-19-20-x-x-x-x x-x-x-x-x-x-x-x 203 204 -- and now, we do indeed have the same representation for the memory 205 -- version in the constrained and unconstrained cases. 206 207 ---------------------------------------------- 208 -- Entity Tables for Packed Access Routines -- 209 ---------------------------------------------- 210 211 -- For the cases of component size = 3,5-7,9-15,17-31,33-63 we call library 212 -- routines. These tables provide the entity for the proper routine. They 213 -- are exposed in the spec to allow checking for the presence of the needed 214 -- routine when an array is subject to pragma Pack. 215 216 type E_Array is array (Int range 01 .. 63) of RE_Id; 217 218 -- Array of Bits_nn entities. Note that we do not use library routines 219 -- for the 8-bit and 16-bit cases, but we still fill in the table, using 220 -- entries from System.Unsigned, because we also use this table for 221 -- certain special unchecked conversions in the big-endian case. 222 223 Bits_Id : constant E_Array := 224 (01 => RE_Bits_1, 225 02 => RE_Bits_2, 226 03 => RE_Bits_03, 227 04 => RE_Bits_4, 228 05 => RE_Bits_05, 229 06 => RE_Bits_06, 230 07 => RE_Bits_07, 231 08 => RE_Unsigned_8, 232 09 => RE_Bits_09, 233 10 => RE_Bits_10, 234 11 => RE_Bits_11, 235 12 => RE_Bits_12, 236 13 => RE_Bits_13, 237 14 => RE_Bits_14, 238 15 => RE_Bits_15, 239 16 => RE_Unsigned_16, 240 17 => RE_Bits_17, 241 18 => RE_Bits_18, 242 19 => RE_Bits_19, 243 20 => RE_Bits_20, 244 21 => RE_Bits_21, 245 22 => RE_Bits_22, 246 23 => RE_Bits_23, 247 24 => RE_Bits_24, 248 25 => RE_Bits_25, 249 26 => RE_Bits_26, 250 27 => RE_Bits_27, 251 28 => RE_Bits_28, 252 29 => RE_Bits_29, 253 30 => RE_Bits_30, 254 31 => RE_Bits_31, 255 32 => RE_Unsigned_32, 256 33 => RE_Bits_33, 257 34 => RE_Bits_34, 258 35 => RE_Bits_35, 259 36 => RE_Bits_36, 260 37 => RE_Bits_37, 261 38 => RE_Bits_38, 262 39 => RE_Bits_39, 263 40 => RE_Bits_40, 264 41 => RE_Bits_41, 265 42 => RE_Bits_42, 266 43 => RE_Bits_43, 267 44 => RE_Bits_44, 268 45 => RE_Bits_45, 269 46 => RE_Bits_46, 270 47 => RE_Bits_47, 271 48 => RE_Bits_48, 272 49 => RE_Bits_49, 273 50 => RE_Bits_50, 274 51 => RE_Bits_51, 275 52 => RE_Bits_52, 276 53 => RE_Bits_53, 277 54 => RE_Bits_54, 278 55 => RE_Bits_55, 279 56 => RE_Bits_56, 280 57 => RE_Bits_57, 281 58 => RE_Bits_58, 282 59 => RE_Bits_59, 283 60 => RE_Bits_60, 284 61 => RE_Bits_61, 285 62 => RE_Bits_62, 286 63 => RE_Bits_63); 287 288 -- Array of Get routine entities. These are used to obtain an element from 289 -- a packed array. The N'th entry is used to obtain elements from a packed 290 -- array whose component size is N. RE_Null is used as a null entry, for 291 -- the cases where a library routine is not used. 292 293 Get_Id : constant E_Array := 294 (01 => RE_Null, 295 02 => RE_Null, 296 03 => RE_Get_03, 297 04 => RE_Null, 298 05 => RE_Get_05, 299 06 => RE_Get_06, 300 07 => RE_Get_07, 301 08 => RE_Null, 302 09 => RE_Get_09, 303 10 => RE_Get_10, 304 11 => RE_Get_11, 305 12 => RE_Get_12, 306 13 => RE_Get_13, 307 14 => RE_Get_14, 308 15 => RE_Get_15, 309 16 => RE_Null, 310 17 => RE_Get_17, 311 18 => RE_Get_18, 312 19 => RE_Get_19, 313 20 => RE_Get_20, 314 21 => RE_Get_21, 315 22 => RE_Get_22, 316 23 => RE_Get_23, 317 24 => RE_Get_24, 318 25 => RE_Get_25, 319 26 => RE_Get_26, 320 27 => RE_Get_27, 321 28 => RE_Get_28, 322 29 => RE_Get_29, 323 30 => RE_Get_30, 324 31 => RE_Get_31, 325 32 => RE_Null, 326 33 => RE_Get_33, 327 34 => RE_Get_34, 328 35 => RE_Get_35, 329 36 => RE_Get_36, 330 37 => RE_Get_37, 331 38 => RE_Get_38, 332 39 => RE_Get_39, 333 40 => RE_Get_40, 334 41 => RE_Get_41, 335 42 => RE_Get_42, 336 43 => RE_Get_43, 337 44 => RE_Get_44, 338 45 => RE_Get_45, 339 46 => RE_Get_46, 340 47 => RE_Get_47, 341 48 => RE_Get_48, 342 49 => RE_Get_49, 343 50 => RE_Get_50, 344 51 => RE_Get_51, 345 52 => RE_Get_52, 346 53 => RE_Get_53, 347 54 => RE_Get_54, 348 55 => RE_Get_55, 349 56 => RE_Get_56, 350 57 => RE_Get_57, 351 58 => RE_Get_58, 352 59 => RE_Get_59, 353 60 => RE_Get_60, 354 61 => RE_Get_61, 355 62 => RE_Get_62, 356 63 => RE_Get_63); 357 358 -- Array of Get routine entities to be used in the case where the packed 359 -- array is itself a component of a packed structure, and therefore may not 360 -- be fully aligned. This only affects the even sizes, since for the odd 361 -- sizes, we do not get any fixed alignment in any case. 362 363 GetU_Id : constant E_Array := 364 (01 => RE_Null, 365 02 => RE_Null, 366 03 => RE_Get_03, 367 04 => RE_Null, 368 05 => RE_Get_05, 369 06 => RE_GetU_06, 370 07 => RE_Get_07, 371 08 => RE_Null, 372 09 => RE_Get_09, 373 10 => RE_GetU_10, 374 11 => RE_Get_11, 375 12 => RE_GetU_12, 376 13 => RE_Get_13, 377 14 => RE_GetU_14, 378 15 => RE_Get_15, 379 16 => RE_Null, 380 17 => RE_Get_17, 381 18 => RE_GetU_18, 382 19 => RE_Get_19, 383 20 => RE_GetU_20, 384 21 => RE_Get_21, 385 22 => RE_GetU_22, 386 23 => RE_Get_23, 387 24 => RE_GetU_24, 388 25 => RE_Get_25, 389 26 => RE_GetU_26, 390 27 => RE_Get_27, 391 28 => RE_GetU_28, 392 29 => RE_Get_29, 393 30 => RE_GetU_30, 394 31 => RE_Get_31, 395 32 => RE_Null, 396 33 => RE_Get_33, 397 34 => RE_GetU_34, 398 35 => RE_Get_35, 399 36 => RE_GetU_36, 400 37 => RE_Get_37, 401 38 => RE_GetU_38, 402 39 => RE_Get_39, 403 40 => RE_GetU_40, 404 41 => RE_Get_41, 405 42 => RE_GetU_42, 406 43 => RE_Get_43, 407 44 => RE_GetU_44, 408 45 => RE_Get_45, 409 46 => RE_GetU_46, 410 47 => RE_Get_47, 411 48 => RE_GetU_48, 412 49 => RE_Get_49, 413 50 => RE_GetU_50, 414 51 => RE_Get_51, 415 52 => RE_GetU_52, 416 53 => RE_Get_53, 417 54 => RE_GetU_54, 418 55 => RE_Get_55, 419 56 => RE_GetU_56, 420 57 => RE_Get_57, 421 58 => RE_GetU_58, 422 59 => RE_Get_59, 423 60 => RE_GetU_60, 424 61 => RE_Get_61, 425 62 => RE_GetU_62, 426 63 => RE_Get_63); 427 428 -- Array of Set routine entities. These are used to assign an element of a 429 -- packed array. The N'th entry is used to assign elements for a packed 430 -- array whose component size is N. RE_Null is used as a null entry, for 431 -- the cases where a library routine is not used. 432 433 Set_Id : constant E_Array := 434 (01 => RE_Null, 435 02 => RE_Null, 436 03 => RE_Set_03, 437 04 => RE_Null, 438 05 => RE_Set_05, 439 06 => RE_Set_06, 440 07 => RE_Set_07, 441 08 => RE_Null, 442 09 => RE_Set_09, 443 10 => RE_Set_10, 444 11 => RE_Set_11, 445 12 => RE_Set_12, 446 13 => RE_Set_13, 447 14 => RE_Set_14, 448 15 => RE_Set_15, 449 16 => RE_Null, 450 17 => RE_Set_17, 451 18 => RE_Set_18, 452 19 => RE_Set_19, 453 20 => RE_Set_20, 454 21 => RE_Set_21, 455 22 => RE_Set_22, 456 23 => RE_Set_23, 457 24 => RE_Set_24, 458 25 => RE_Set_25, 459 26 => RE_Set_26, 460 27 => RE_Set_27, 461 28 => RE_Set_28, 462 29 => RE_Set_29, 463 30 => RE_Set_30, 464 31 => RE_Set_31, 465 32 => RE_Null, 466 33 => RE_Set_33, 467 34 => RE_Set_34, 468 35 => RE_Set_35, 469 36 => RE_Set_36, 470 37 => RE_Set_37, 471 38 => RE_Set_38, 472 39 => RE_Set_39, 473 40 => RE_Set_40, 474 41 => RE_Set_41, 475 42 => RE_Set_42, 476 43 => RE_Set_43, 477 44 => RE_Set_44, 478 45 => RE_Set_45, 479 46 => RE_Set_46, 480 47 => RE_Set_47, 481 48 => RE_Set_48, 482 49 => RE_Set_49, 483 50 => RE_Set_50, 484 51 => RE_Set_51, 485 52 => RE_Set_52, 486 53 => RE_Set_53, 487 54 => RE_Set_54, 488 55 => RE_Set_55, 489 56 => RE_Set_56, 490 57 => RE_Set_57, 491 58 => RE_Set_58, 492 59 => RE_Set_59, 493 60 => RE_Set_60, 494 61 => RE_Set_61, 495 62 => RE_Set_62, 496 63 => RE_Set_63); 497 498 -- Array of Set routine entities to be used in the case where the packed 499 -- array is itself a component of a packed structure, and therefore may not 500 -- be fully aligned. This only affects the even sizes, since for the odd 501 -- sizes, we do not get any fixed alignment in any case. 502 503 SetU_Id : constant E_Array := 504 (01 => RE_Null, 505 02 => RE_Null, 506 03 => RE_Set_03, 507 04 => RE_Null, 508 05 => RE_Set_05, 509 06 => RE_SetU_06, 510 07 => RE_Set_07, 511 08 => RE_Null, 512 09 => RE_Set_09, 513 10 => RE_SetU_10, 514 11 => RE_Set_11, 515 12 => RE_SetU_12, 516 13 => RE_Set_13, 517 14 => RE_SetU_14, 518 15 => RE_Set_15, 519 16 => RE_Null, 520 17 => RE_Set_17, 521 18 => RE_SetU_18, 522 19 => RE_Set_19, 523 20 => RE_SetU_20, 524 21 => RE_Set_21, 525 22 => RE_SetU_22, 526 23 => RE_Set_23, 527 24 => RE_SetU_24, 528 25 => RE_Set_25, 529 26 => RE_SetU_26, 530 27 => RE_Set_27, 531 28 => RE_SetU_28, 532 29 => RE_Set_29, 533 30 => RE_SetU_30, 534 31 => RE_Set_31, 535 32 => RE_Null, 536 33 => RE_Set_33, 537 34 => RE_SetU_34, 538 35 => RE_Set_35, 539 36 => RE_SetU_36, 540 37 => RE_Set_37, 541 38 => RE_SetU_38, 542 39 => RE_Set_39, 543 40 => RE_SetU_40, 544 41 => RE_Set_41, 545 42 => RE_SetU_42, 546 43 => RE_Set_43, 547 44 => RE_SetU_44, 548 45 => RE_Set_45, 549 46 => RE_SetU_46, 550 47 => RE_Set_47, 551 48 => RE_SetU_48, 552 49 => RE_Set_49, 553 50 => RE_SetU_50, 554 51 => RE_Set_51, 555 52 => RE_SetU_52, 556 53 => RE_Set_53, 557 54 => RE_SetU_54, 558 55 => RE_Set_55, 559 56 => RE_SetU_56, 560 57 => RE_Set_57, 561 58 => RE_SetU_58, 562 59 => RE_Set_59, 563 60 => RE_SetU_60, 564 61 => RE_Set_61, 565 62 => RE_SetU_62, 566 63 => RE_Set_63); 567 568 ----------------- 569 -- Subprograms -- 570 ----------------- 571 572 procedure Create_Packed_Array_Impl_Type (Typ : Entity_Id); 573 -- Typ is a array type or subtype to which pragma Pack applies. If the 574 -- Packed_Array_Impl_Type field of Typ is already set, then the call has 575 -- no effect, otherwise a suitable type or subtype is created and stored in 576 -- the Packed_Array_Impl_Type field of Typ. This created type is an Itype 577 -- so that Gigi will simply elaborate and freeze the type on first use 578 -- (which is typically the definition of the corresponding array type). 579 -- 580 -- Note: although this routine is included in the expander package for 581 -- packed types, it is actually called unconditionally from Freeze, 582 -- whether or not expansion (and code generation) is enabled. We do this 583 -- since we want gigi to be able to properly compute type characteristics 584 -- (for the Data Decomposition Annex of ASIS, and possible other future 585 -- uses) even if code generation is not active. Strictly this means that 586 -- this procedure is not part of the expander, but it seems appropriate 587 -- to keep it together with the other expansion routines that have to do 588 -- with packed array types. 589 590 procedure Expand_Packed_Boolean_Operator (N : Node_Id); 591 -- N is an N_Op_And, N_Op_Or or N_Op_Xor node whose operand type is a 592 -- packed boolean array. This routine expands the appropriate operations 593 -- to carry out the logical operation on the packed arrays. It handles 594 -- both the modular and array representation cases. 595 596 procedure Expand_Packed_Element_Reference (N : Node_Id); 597 -- N is an N_Indexed_Component node whose prefix is a packed array. In 598 -- the bit packed case, this routine can only be used for the expression 599 -- evaluation case, not the assignment case, since the result is not a 600 -- variable. See Expand_Bit_Packed_Element_Set for how the assignment case 601 -- is handled in the bit packed case. For the enumeration case, the result 602 -- of this call is always a variable, so the call can be used for both the 603 -- expression evaluation and assignment cases. 604 605 procedure Expand_Bit_Packed_Element_Set (N : Node_Id); 606 -- N is an N_Assignment_Statement node whose name is an indexed 607 -- component of a bit-packed array. This procedure rewrites the entire 608 -- assignment statement with appropriate code to set the referenced 609 -- bits of the packed array type object. Note that this procedure is 610 -- used only for the bit-packed case, not for the enumeration case. 611 612 procedure Expand_Packed_Eq (N : Node_Id); 613 -- N is an N_Op_Eq node where the operands are packed arrays whose 614 -- representation is an array-of-bytes type (the case where a modular 615 -- type is used for the representation does not require any special 616 -- handling, because in the modular case, unused bits are zeroes. 617 618 procedure Expand_Packed_Not (N : Node_Id); 619 -- N is an N_Op_Not node where the operand is packed array of Boolean 620 -- in standard representation (i.e. component size is one bit). This 621 -- procedure expands the corresponding not operation. Note that the 622 -- non-standard representation case is handled by using a loop through 623 -- elements generated by the normal non-packed circuitry. 624 625 function Involves_Packed_Array_Reference (N : Node_Id) return Boolean; 626 -- N is the node for a name. This function returns true if the name 627 -- involves a packed array reference. A node involves a packed array 628 -- reference if it is itself an indexed component referring to a bit- 629 -- packed array, or it is a selected component whose prefix involves 630 -- a packed array reference. 631 632 procedure Expand_Packed_Address_Reference (N : Node_Id); 633 -- The node N is an attribute reference for the 'Address reference, where 634 -- the prefix involves a packed array reference. This routine expands the 635 -- necessary code for performing the address reference in this case. 636 637 procedure Expand_Packed_Bit_Reference (N : Node_Id); 638 -- The node N is an attribute reference for the 'Bit reference, where the 639 -- prefix involves a packed array reference. This routine expands the 640 -- necessary code for performing the bit reference in this case. 641 642end Exp_Pakd; 643