Patchwork [Ada] Optimization of assignments to bit-packed components with rep. clauses

login
register
mail settings
Submitter Arnaud Charlet
Date Aug. 29, 2011, 9:41 a.m.
Message ID <20110829094125.GA27763@adacore.com>
Download mbox | patch
Permalink /patch/112004/
State New
Headers show

Comments

Arnaud Charlet - Aug. 29, 2011, 9:41 a.m.
This patch improves on the code generated for an assignment to a component of
a bit-packed array, when lhs and rhs have a different representation.

Executing the following :

   gcc -c -gnatG p1.adb | grep -c '\$system__pack_40'

must yield:

   1
---

package Conf is
   type UINT32_T is mod 2**32;
   for UINT32_T'SIZE use 32;

   type UINT4_T is mod 2**4;
   for UINT4_T'SIZE use 4;

   -- record type

   type REC_T is record
      SIZE : UINT32_T;
      V1, V2 : Uint4_T;
   end record;

   -- packed record type

   type REC_pack_T is new REC_T;
   for REC_pack_T use record
      SIZE at 0 range 0 .. 31;     -- 32 bits
      V1   at 0 range 32 .. 35;    -- 4 bits
      V2   at 0 range 36 .. 39;    -- 4 bits
   end record;
   for REC_pack_T'Size use 40;

   -- packed arrays of each record type

   subtype ARRAY_INDEX_T is Integer range 1 .. 10;

   type PARR_R_T is array (ARRAY_INDEX_T) of REC_T;
   pragma Pack (PARR_R_T);

   type PARR_PR_T is array(ARRAY_INDEX_T) of REC_PACK_T;
   pragma Pack (PARR_PR_T);

   -- data

   Csz : constant Uint32_T := 0;
   Cv1 : constant Uint4_T := 0;
   Cv2 : constant Uint4_T := 3;

   A_R : PARR_R_T := (others => (SIZE => Csz, V1 => Cv1, V2 => Cv2));
   
   --
   
   procedure Assert (Cond : Boolean);

   PR : REC_PACK_T;
   A_PR : PARR_PR_T;
   
   INDEX : constant := 8;
end;
---
with Conf; use Conf;
procedure P1 is
begin
   PR := REC_PACK_T(A_R (INDEX));
   A_PR (INDEX) := PR;
end;

Tested on x86_64-pc-linux-gnu, committed on trunk

2011-08-29  Ed Schonberg  <schonberg@adacore.com>

	* exp_ch5.adb (Expand_N_Assignment_Statement): if the left-hand side is
	an indexed component of a packed array whose element type is a record
	with a representation clause different from that of the right-hand
	side, generate a temporary to minimuze the number of bit-field
	operations generated.

Patch

Index: exp_ch5.adb
===================================================================
--- exp_ch5.adb	(revision 178177)
+++ exp_ch5.adb	(working copy)
@@ -1890,11 +1890,42 @@ 
 
       if Nkind (Lhs) = N_Indexed_Component
         and then Is_Bit_Packed_Array (Etype (Prefix (Lhs)))
-        and then not Crep
       then
-         Expand_Bit_Packed_Element_Set (N);
-         return;
+         if not Crep then
+            Expand_Bit_Packed_Element_Set (N);
+            return;
+         else
 
+            --  Generate the following, to force component-by-component
+            --  assignments in an efficient way. Otherwise each component
+            --  will require a temporary and two bit-field manipulations.
+
+            --  T1 : Elmt_Type;
+            --  T1 := RhS;
+            --  Lhs := T1;
+
+            declare
+               Tnn : constant Entity_Id := Make_Temporary (Loc, 'T');
+               Stats : List_Id;
+
+            begin
+               Stats := New_List (
+                 Make_Object_Declaration (Loc,
+                   Defining_Identifier => Tnn,
+                   Object_Definition => New_Occurrence_Of (Etype (Lhs), Loc)),
+                Make_Assignment_Statement (Loc,
+                  Name => New_Occurrence_Of (Tnn, Loc),
+                  Expression => Relocate_Node (Rhs)),
+                Make_Assignment_Statement (Loc,
+                  Name => Relocate_Node (Lhs),
+                  Expression => New_Occurrence_Of (Tnn, Loc)));
+
+               Insert_Actions (N, Stats);
+               Rewrite (N, Make_Null_Statement (Loc));
+               Analyze (N);
+            end;
+         end if;
+
       --  Build-in-place function call case. Note that we're not yet doing
       --  build-in-place for user-written assignment statements (the assignment
       --  here came from an aggregate.)