diff mbox series

[v4,03/36] tcg: Allocate objects contiguously in temp_allocate_frame

Message ID 20230108023719.2466341-4-richard.henderson@linaro.org
State Superseded
Headers show
Series tcg: Support for Int128 with helpers | expand

Commit Message

Richard Henderson Jan. 8, 2023, 2:36 a.m. UTC 
When allocating a temp to the stack frame, consider the
base type and allocate all parts at once.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
---
 tcg/tcg.c | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

Comments

Alex Bennée Jan. 11, 2023, 9:59 a.m. UTC | #1 
Richard Henderson <richard.henderson@linaro.org> writes:

> When allocating a temp to the stack frame, consider the
> base type and allocate all parts at once.
>
> Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
> ---
>  tcg/tcg.c | 30 ++++++++++++++++++++++--------
>  1 file changed, 22 insertions(+), 8 deletions(-)
>
> diff --git a/tcg/tcg.c b/tcg/tcg.c
> index 99e6e4e1a8..7e69e2c9fd 100644
> --- a/tcg/tcg.c
> +++ b/tcg/tcg.c
> @@ -3242,11 +3242,12 @@ static bool liveness_pass_2(TCGContext *s)
>  
>  static void temp_allocate_frame(TCGContext *s, TCGTemp *ts)
>  {
> -    int size = tcg_type_size(ts->type);
> -    int align;
>      intptr_t off;
> +    int size, align;
>  
> -    switch (ts->type) {
> +    /* When allocating an object, look at the full type. */
> +    size = tcg_type_size(ts->base_type);
> +    switch (ts->base_type) {
>      case TCG_TYPE_I32:
>          align = 4;
>          break;
> @@ -3277,13 +3278,26 @@ static void temp_allocate_frame(TCGContext *s, TCGTemp *ts)
>          tcg_raise_tb_overflow(s);
>      }
>      s->current_frame_offset = off + size;
> -
> -    ts->mem_offset = off;
>  #if defined(__sparc__)
> -    ts->mem_offset += TCG_TARGET_STACK_BIAS;
> +    off += TCG_TARGET_STACK_BIAS;
>  #endif
> -    ts->mem_base = s->frame_temp;
> -    ts->mem_allocated = 1;
> +
> +    /* If the object was subdivided, assign memory to all the parts. */
> +    if (ts->base_type != ts->type) {
> +        int part_size = tcg_type_size(ts->type);
> +        int part_count = size / part_size;
> +
> +        ts -= ts->temp_subindex;

Whats going on here? Are we jumping to a previous temp? What guarentees
there is something at ts - ts->temp_subindex?

> +        for (int i = 0; i < part_count; ++i) {
> +            ts[i].mem_offset = off + i * part_size;
> +            ts[i].mem_base = s->frame_temp;
> +            ts[i].mem_allocated = 1;
> +        }
> +    } else {
> +        ts->mem_offset = off;
> +        ts->mem_base = s->frame_temp;
> +        ts->mem_allocated = 1;
> +    }
>  }
>  
>  /* Assign @reg to @ts, and update reg_to_temp[]. */
Richard Henderson Jan. 11, 2023, 3:06 p.m. UTC | #2 
On 1/11/23 01:59, Alex Bennée wrote:
>> @@ -3277,13 +3278,26 @@ static void temp_allocate_frame(TCGContext *s, TCGTemp *ts)
>>           tcg_raise_tb_overflow(s);
>>       }
>>       s->current_frame_offset = off + size;
>> -
>> -    ts->mem_offset = off;
>>   #if defined(__sparc__)
>> -    ts->mem_offset += TCG_TARGET_STACK_BIAS;
>> +    off += TCG_TARGET_STACK_BIAS;
>>   #endif
>> -    ts->mem_base = s->frame_temp;
>> -    ts->mem_allocated = 1;
>> +
>> +    /* If the object was subdivided, assign memory to all the parts. */
>> +    if (ts->base_type != ts->type) {
>> +        int part_size = tcg_type_size(ts->type);
>> +        int part_count = size / part_size;
>> +
>> +        ts -= ts->temp_subindex;
> 
> Whats going on here? Are we jumping to a previous temp? What guarentees
> there is something at ts - ts->temp_subindex?

Yes.  Guaranteed by base_type != type.  See tcg_temp_new_internal -- it's the raison 
d'être of temp_subindex.


r~
diff mbox series

Patch

diff --git a/tcg/tcg.c b/tcg/tcg.c
index 99e6e4e1a8..7e69e2c9fd 100644
--- a/tcg/tcg.c
+++ b/tcg/tcg.c
@@ -3242,11 +3242,12 @@  static bool liveness_pass_2(TCGContext *s)
 
 static void temp_allocate_frame(TCGContext *s, TCGTemp *ts)
 {
-    int size = tcg_type_size(ts->type);
-    int align;
     intptr_t off;
+    int size, align;
 
-    switch (ts->type) {
+    /* When allocating an object, look at the full type. */
+    size = tcg_type_size(ts->base_type);
+    switch (ts->base_type) {
     case TCG_TYPE_I32:
         align = 4;
         break;
@@ -3277,13 +3278,26 @@  static void temp_allocate_frame(TCGContext *s, TCGTemp *ts)
         tcg_raise_tb_overflow(s);
     }
     s->current_frame_offset = off + size;
-
-    ts->mem_offset = off;
 #if defined(__sparc__)
-    ts->mem_offset += TCG_TARGET_STACK_BIAS;
+    off += TCG_TARGET_STACK_BIAS;
 #endif
-    ts->mem_base = s->frame_temp;
-    ts->mem_allocated = 1;
+
+    /* If the object was subdivided, assign memory to all the parts. */
+    if (ts->base_type != ts->type) {
+        int part_size = tcg_type_size(ts->type);
+        int part_count = size / part_size;
+
+        ts -= ts->temp_subindex;
+        for (int i = 0; i < part_count; ++i) {
+            ts[i].mem_offset = off + i * part_size;
+            ts[i].mem_base = s->frame_temp;
+            ts[i].mem_allocated = 1;
+        }
+    } else {
+        ts->mem_offset = off;
+        ts->mem_base = s->frame_temp;
+        ts->mem_allocated = 1;
+    }
 }
 
 /* Assign @reg to @ts, and update reg_to_temp[]. */