[COMMITTED] libpoke: decouple pvm_val offset from the quality of being mapped

[Jose E. Marchesi]

2020-11-11  Jose E. Marchesi  <jemarch@gnu.org>

        * libpoke/pvm.jitter (mm,map,unmap): New instructions.
        * libpoke/pkl-insn.def: Entries for new instructions.
        * libpoke/pkl-gen.c (pkl_gen_pr_ass_stmt): Likewise.
        (pkl_gen_ps_op_unmap): Use the new unmap instruction.
        (pkl_gen_ps_op_attr): Use `mm' to determine
        whether a value is mapped or not.
        * libpoke/pkl-asm.pks (remap): Use mm instead of mgetm.
        (atrim): Likewise.
        (write) Likewise.
        * libpoke/pkl-gen.pks (array_mapper): Map the new value.
        (array_valmapper): Likewise.
        (struct_mapper): Likewise.
        (array_constructor): Set bit-offset of the constructed array.
        (struct_constructor): Likewise.
        (struct_field_inserter): Adapt to the fact mgeto can't return null
        any longer.
        (op_unmap): Delete macro.
        * libpoke/pvm-val.c (pvm_make_array): Make new arrays unmapped by
        default.
        (pvm_make_struct): Likewise for structs.
        (pvm_print_val_1): Print element offsets in
        mapped arrays and structs.
        * libpoke/pvm-val.h (PVM_VAL_ARR_MAPPED_P): Define.
        (struct pvm_array): New field `mapped_p'.
        (PVM_VAL_SCT_MAPPED_P): Define.
        (struct pvm_struct): New field `mapped_p'.
        (PVM_VAL_MAPPED_P): Define.
        (PVM_VAL_SET_MAPPED_P): Likewise.
        * testsuite/poke.cmd/set-omaps-1.pk: Adapt.
---
 ChangeLog                         | 32 +++++++++++++++++++++
 libpoke/pkl-asm.pks               | 17 +++++++----
 libpoke/pkl-gen.c                 | 27 ++++++++++--------
 libpoke/pkl-gen.pks               | 29 ++++++-------------
 libpoke/pkl-insn.def              |  5 ++++
 libpoke/pvm-val.c                 | 26 +++++++++++++++--
 libpoke/pvm-val.h                 | 31 ++++++++++++++++++--
 libpoke/pvm.jitter                | 47 +++++++++++++++++++++++++++++++
 testsuite/poke.cmd/set-omaps-1.pk |  2 +-
 9 files changed, 173 insertions(+), 43 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index d1be36cc..0e2560ba 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,35 @@
+2020-11-11  Jose E. Marchesi  <jemarch@gnu.org>
+
+       * libpoke/pvm.jitter (mm,map,unmap): New instructions.
+       * libpoke/pkl-insn.def: Entries for new instructions.
+       * libpoke/pkl-gen.c (pkl_gen_pr_ass_stmt): Likewise.
+       (pkl_gen_ps_op_unmap): Use the new unmap instruction.
+       (pkl_gen_ps_op_attr): Use `mm' to determine
+       whether a value is mapped or not.
+       * libpoke/pkl-asm.pks (remap): Use mm instead of mgetm.
+       (atrim): Likewise.
+       (write) Likewise.
+       * libpoke/pkl-gen.pks (array_mapper): Map the new value.
+       (array_valmapper): Likewise.
+       (struct_mapper): Likewise.
+       (array_constructor): Set bit-offset of the constructed array.
+       (struct_constructor): Likewise.
+       (struct_field_inserter): Adapt to the fact mgeto can't return null
+       any longer.
+       (op_unmap): Delete macro.
+       * libpoke/pvm-val.c (pvm_make_array): Make new arrays unmapped by
+       default.
+       (pvm_make_struct): Likewise for structs.
+       (pvm_print_val_1): Print element offsets in
+       mapped arrays and structs.
+       * libpoke/pvm-val.h (PVM_VAL_ARR_MAPPED_P): Define.
+       (struct pvm_array): New field `mapped_p'.
+       (PVM_VAL_SCT_MAPPED_P): Define.
+       (struct pvm_struct): New field `mapped_p'.
+       (PVM_VAL_MAPPED_P): Define.
+       (PVM_VAL_SET_MAPPED_P): Likewise.
+       * testsuite/poke.cmd/set-omaps-1.pk: Adapt.
+
 2020-11-11  Jose E. Marchesi  <jemarch@gnu.org>
 
        * libpoke/pvm.jitter (mktyv): New instruction.
diff --git a/libpoke/pkl-asm.pks b/libpoke/pkl-asm.pks
index 40473cd5..003697c6 100644
--- a/libpoke/pkl-asm.pks
+++ b/libpoke/pkl-asm.pks
@@ -39,9 +39,9 @@
 ;;; implementation of the PKL_INSN_REMAP macro-instruction.
 
         .macro remap
-        ;; The re-map should be done only if the value has a mapper.
-        mgetm                   ; VAL MCLS
-        bn .label               ; VAL MCLS
+        ;; The re-map should be done only if the value is mapped.
+        mm                      ; VAL MAPPED_P
+        bzi .label              ; VAL MAPPED_P
         drop                    ; VAL
         ;; XXX do not re-map if the object is up to date (cached
         ;; value.)
@@ -78,6 +78,9 @@
         .macro write
         dup                     ; VAL VAL
         ;; The write should be done only if the value is mapped.
+        mm                      ; VAL VAL MAPPED_P
+        bzi .label
+        drop                    ; VAL VAL
         mgetw                   ; VAL VAL WCLS
         bn .label
         call                    ; VAL null
@@ -470,9 +473,11 @@
         ;; bounded by number of elements, regardless of the
         ;; characteristics of the mapping of the trimmed array.
         pushvar $array          ; TARR ARR
-        mgeto                   ; TARR ARR BOFFSET
-        bn .notmapped
+        mm                      ; TARR ARR MAPPED_P
+        bzi .notmapped
+        drop                    ; TARR ARR
         ;; Calculate the new offset.
+        mgeto                   ; TARR ARR BOFFSET
         swap                    ; TARR BOFFSET ARR
         pushvar $from           ; TARR BOFFSET ARR FROM
         arefo                   ; TARR BOFFSET ARR FROM BOFF(FROM)
@@ -509,6 +514,8 @@
         msetm                   ; BOFFSET TARR
         swap                    ; TARR BOFFSET
         mseto                   ; TARR
+        ;; Mark the new array as mapped.
+        map                     ; TARR
         ;; Remap!!
         remap
         push null
diff --git a/libpoke/pkl-gen.c b/libpoke/pkl-gen.c
index 93dcde77..37a26511 100644
--- a/libpoke/pkl-gen.c
+++ b/libpoke/pkl-gen.c
@@ -675,8 +675,8 @@ PKL_PHASE_BEGIN_HANDLER (pkl_gen_pr_ass_stmt)
         /* If VAL is not mapped, skip the mapval.  */
         pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_PUSHR, 0);  /* LVALUE IDX VAL EXP 
*/
         pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_SWAP);      /* LVALUE IDX EXP VAL 
*/
-        pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MGETM);     /* LVALUE IDX EXP VAL 
MCLS */
-        pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_BN, label); /* LVALUE IDX EXP VAL 
MCLS */
+        pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MM);        /* LVALUE IDX EXP VAL 
MAPPED_P */
+        pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_BZI, label); /* LVALUE IDX EXP VAL 
MAPPED_P */
         pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_DROP);      /* LVALUE IDX EXP VAL 
*/
         pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MGETO);     /* LVALUE IDX EXP VAL 
OFFSET */
         pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_NROT);      /* LVALUE IDX OFFSET 
EXP VAL */
@@ -3304,17 +3304,22 @@ PKL_PHASE_BEGIN_HANDLER (pkl_gen_ps_op_attr)
           {
             pvm_program_label label = pkl_asm_fresh_label (PKL_GEN_ASM);
 
-            if (attr == PKL_AST_ATTR_OFFSET)
-              pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MGETO);
-            else
-              pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MGETIOS);
-            pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_NIP);
-            pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_BNN, label);
+            pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MM); /* VAL MAPPED_P */
+            pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_BNZI, label);
+
             pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_PUSH,
                           pvm_make_exception (PVM_E_MAP, PVM_E_MAP_MSG,
                                               PVM_E_MAP_ESTATUS));
             pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_RAISE);
             pkl_asm_label (PKL_GEN_ASM, label);
+
+            pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_DROP); /* VAL */
+            if (attr == PKL_AST_ATTR_OFFSET)
+              pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MGETO);
+            else
+              pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MGETIOS);
+            pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_NIP); /* (BOFF|IOS) */
+
             if (attr == PKL_AST_ATTR_OFFSET)
               {
                 pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_PUSH,
@@ -3337,9 +3342,7 @@ PKL_PHASE_BEGIN_HANDLER (pkl_gen_ps_op_attr)
         case PKL_TYPE_ANY:
         case PKL_TYPE_ARRAY:
         case PKL_TYPE_STRUCT:
-          pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MGETO);
-          pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_NIP);
-          pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_NN);
+          pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_MM);
           pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_NIP);
           break;
         default:
@@ -3388,7 +3391,7 @@ PKL_PHASE_END_HANDLER
 
 PKL_PHASE_BEGIN_HANDLER (pkl_gen_ps_op_unmap)
 {
-  RAS_MACRO_OP_UNMAP;
+  pkl_asm_insn (PKL_GEN_ASM, PKL_INSN_UNMAP);
 }
 PKL_PHASE_END_HANDLER
 
diff --git a/libpoke/pkl-gen.pks b/libpoke/pkl-gen.pks
index b5c48f0e..07ea9852 100644
--- a/libpoke/pkl-gen.pks
+++ b/libpoke/pkl-gen.pks
@@ -24,14 +24,7 @@
 ;;; is mapped.  If the value is not mapped, this is a NOP.
 
         .macro op_unmap
-        push null
-        mseto
-        push null
-        msetm
-        push null
-        msetw
-        push null
-        msetios
+        unmap
         .end
 
 ;;; RAS_FUNCTION_ARRAY_MAPPER @array_type
@@ -226,6 +219,7 @@
         ;; Set the other map attributes.
         pushvar $ios          ; ARRAY IOS
         msetios               ; ARRAY
+        map                   ; ARRAY
         popf 1
         return
 .bounds_fail:
@@ -370,6 +364,7 @@
         msetsiz                 ; ARRAY
         pushvar $ebound         ; ARRAY EBOUND
         msetsel                 ; ARRAY
+        map                     ; ARRAY
         popf 1
         return
 .bounds_fail:
@@ -501,14 +496,13 @@
         dup                     ; 0UL 0UL
         regvar $eidx            ; BOFF
         regvar $eboff           ; _
-        ;; The offset of the constructed array is null, since it is
-        ;; not mapped.
-        push null               ; null
+        ;; The bit-offset of the constructed array is 0 by convention.
+        push ulong<64>0         ; 0UL
         ;; Build the type of the constructed array.
         .c PKL_GEN_PAYLOAD->in_constructor = 0;
         .c PKL_PASS_SUBPASS (PKL_AST_TYPE_A_ETYPE (@array_type));
         .c PKL_GEN_PAYLOAD->in_constructor = 1;
-                                ; null ATYPE
+                                ; 0UL ATYPE
         ;; Ok, loop to add elements to the constructed array.
      .while
         ;; If there is an EBOUND, check it.
@@ -1038,6 +1032,7 @@
         ;; Install the attributes of the mapped object.
         pushvar $ios            ; SCT IOS
         msetios                 ; SCT
+        map                     ; SCT
         popf 1
         return
         .end
@@ -1202,8 +1197,8 @@
         ;; So we have the same lexical structure than struct_mapper.
         push null
         regvar $unused
-        ;; The struct is not mapped, so its offset is null.
-        push null               ; null
+        ;; The struct is not mapped, so set its bit-offset to 0UL.
+        push ulong<64>0          ; 0UL
         ;; Iterate over the fields of the struct type.
  .c size_t vars_registered = 0;
         .let @field
@@ -1477,12 +1472,6 @@
         tor                     ; SCT I [IVAL EVAL]
         swap                    ; I SCT [IVAL EVAL]
         mgeto                   ; I SCT SOFF [IVAL EVAL]
-        ;; XXX: if NULL, put 0UL.  This check will go away when we
-        ;; add a separated flag for mapped values.
-        bnn .done
-        drop
-        push ulong<64>0
-.done:
         tor                     ; I SCT [IVAL EVAL SOFF]
         swap                    ; SCT I [IVAL EVAL SOFF]
         srefio                  ; SCT I EOFF [IVAL EVAL SOFF]
diff --git a/libpoke/pkl-insn.def b/libpoke/pkl-insn.def
index 24ce0bf8..1e11ae59 100644
--- a/libpoke/pkl-insn.def
+++ b/libpoke/pkl-insn.def
@@ -265,6 +265,11 @@ PKL_DEF_INSN(PKL_INSN_SMODI, "", "smodi")
 
 /* Instructions to handle mapped values.  */
 
+PKL_DEF_INSN(PKL_INSN_MM, "", "mm")
+
+PKL_DEF_INSN(PKL_INSN_MAP, "", "map")
+PKL_DEF_INSN(PKL_INSN_UNMAP, "", "unmap")
+
 PKL_DEF_INSN(PKL_INSN_MGETO, "", "mgeto")
 PKL_DEF_INSN(PKL_INSN_MSETO, "", "mseto")
 
diff --git a/libpoke/pvm-val.c b/libpoke/pvm-val.c
index 0720d01c..a7c77001 100644
--- a/libpoke/pvm-val.c
+++ b/libpoke/pvm-val.c
@@ -96,6 +96,7 @@ pvm_make_array (pvm_val nelem, pvm_val type)
   size_t nbytes = sizeof (struct pvm_array_elem) * PVM_VAL_ULONG (nelem);
   size_t i;
 
+  arr->mapped_p = 0;
   arr->ios = PVM_NULL;
   arr->offset = PVM_NULL;
   arr->elems_bound = PVM_NULL;
@@ -127,6 +128,7 @@ pvm_make_struct (pvm_val nfields, pvm_val nmethods, pvm_val 
type)
   size_t nmethodbytes
     = sizeof (struct pvm_struct_method) * PVM_VAL_ULONG (nmethods);
 
+  sct->mapped_p = 0;
   sct->ios = PVM_NULL;
   sct->offset = PVM_NULL;
   sct->mapper = PVM_NULL;
@@ -953,6 +955,7 @@ pvm_print_val_1 (pvm vm, int depth, int mode, int base, int 
indent,
       for (idx = 0; idx < nelem; idx++)
         {
           pvm_val elem_value = PVM_VAL_ARR_ELEM_VALUE (val, idx);
+          pvm_val elem_offset = PVM_VAL_ARR_ELEM_OFFSET (val, idx);
 
           if (idx != 0)
             pk_puts (",");
@@ -966,6 +969,15 @@ pvm_print_val_1 (pvm vm, int depth, int mode, int base, 
int indent,
             }
 
           PVM_PRINT_VAL_1 (elem_value, ndepth);
+
+          if (maps && elem_offset != PVM_NULL)
+            {
+              pk_puts (" @ ");
+              pk_term_class ("offset");
+              PVM_PRINT_VAL_1 (elem_offset, ndepth);
+              pk_puts ("#b");
+              pk_term_end_class ("offset");
+            }
         }
       pk_puts ("]");
 
@@ -1023,8 +1035,9 @@ pvm_print_val_1 (pvm vm, int depth, int mode, int base, 
int indent,
       nabsent = 0;
       for (idx = 0; idx < nelem; ++idx)
         {
-          pvm_val name = PVM_VAL_SCT_FIELD_NAME(val, idx);
-          pvm_val value = PVM_VAL_SCT_FIELD_VALUE(val, idx);
+          pvm_val name = PVM_VAL_SCT_FIELD_NAME (val, idx);
+          pvm_val value = PVM_VAL_SCT_FIELD_VALUE (val, idx);
+          pvm_val offset = PVM_VAL_SCT_FIELD_OFFSET (val, idx);
 
           if (PVM_VAL_SCT_FIELD_ABSENT_P (val, idx))
             nabsent++;
@@ -1045,6 +1058,15 @@ pvm_print_val_1 (pvm vm, int depth, int mode, int base, 
int indent,
                 }
               PVM_PRINT_VAL_1 (value, ndepth + 1);
             }
+
+          if (maps && offset != PVM_NULL)
+            {
+              pk_puts (" @ ");
+              pk_term_class ("offset");
+              PVM_PRINT_VAL_1 (offset, ndepth);
+              pk_puts ("#b");
+              pk_term_end_class ("offset");
+            }
         }
 
       if (mode == PVM_PRINT_TREE)
diff --git a/libpoke/pvm-val.h b/libpoke/pvm-val.h
index b464afa0..c75a0358 100644
--- a/libpoke/pvm-val.h
+++ b/libpoke/pvm-val.h
@@ -154,12 +154,15 @@ typedef struct pvm_val_box *pvm_val_box;
 /* Arrays values are boxed, and store sequences of homogeneous values
    called array "elements".  They can be mapped in IO, or unmapped.
 
+   MAPPED_P is 0 if the array value is not mapped, or has any other
+   value if it is mapped.
+
    IOS is an int<32> value that identifies the IO space where the
    value is mapped.  If the array is not mapped then this is PVM_NULL.
 
    OFFSET is an ulong<64> value with the bit offset in the current IO
    space where the array is mapped.  If the array is not mapped then
-   this is PVM_NULL.
+   this holds 0UL by convention.
 
    If the array is mapped, ELEMS_BOUND is an unsigned long containing
    the number of elements to which the map is bounded.  Similarly,
@@ -189,6 +192,7 @@ typedef struct pvm_val_box *pvm_val_box;
    relevant.  */
 
 #define PVM_VAL_ARR(V) (PVM_VAL_BOX_ARR (PVM_VAL_BOX ((V))))
+#define PVM_VAL_ARR_MAPPED_P(V) (PVM_VAL_ARR(V)->mapped_p)
 #define PVM_VAL_ARR_IOS(V) (PVM_VAL_ARR(V)->ios)
 #define PVM_VAL_ARR_OFFSET(V) (PVM_VAL_ARR(V)->offset)
 #define PVM_VAL_ARR_ELEMS_BOUND(V) (PVM_VAL_ARR(V)->elems_bound)
@@ -201,6 +205,7 @@ typedef struct pvm_val_box *pvm_val_box;
 
 struct pvm_array
 {
+  int mapped_p;
   pvm_val ios;
   pvm_val offset;
   pvm_val elems_bound;
@@ -238,12 +243,15 @@ struct pvm_array_elem
    called structure "elements".  They can be mapped in IO, or
    unmapped.
 
-   IO is an int<32> value that identifies the IO space where the value
+   MAPPED_P is 0 if the struct value is not mapped, or has any other
+   value if it is mapped.
+
+   IOS is an int<32> value that identifies the IO space where the value
    is mapped.  If the structure is not mapped then this is PVM_NULL.
 
    OFFSET is an ulong<64> value holding the bit offset of in the IO
    space where the structure is mapped.  If the structure is not
-   mapped then this is PVM_NULL.
+   mapped then this is 0UL by convention.
 
    TYPE is the type of the struct.  This includes the types of the
    struct fields.
@@ -259,6 +267,7 @@ struct pvm_array_elem
    irrelevant.  */
 
 #define PVM_VAL_SCT(V) (PVM_VAL_BOX_SCT (PVM_VAL_BOX ((V))))
+#define PVM_VAL_SCT_MAPPED_P(V) (PVM_VAL_SCT((V))->mapped_p)
 #define PVM_VAL_SCT_IOS(V) (PVM_VAL_SCT((V))->ios)
 #define PVM_VAL_SCT_OFFSET(V) (PVM_VAL_SCT((V))->offset)
 #define PVM_VAL_SCT_MAPPER(V) (PVM_VAL_SCT((V))->mapper)
@@ -271,6 +280,7 @@ struct pvm_array_elem
 
 struct pvm_struct
 {
+  int mapped_p;
   pvm_val ios;
   pvm_val offset;
   pvm_val mapper;
@@ -540,6 +550,21 @@ typedef struct pvm_off *pvm_off;
         PVM_VAL_SCT_IOS ((V)) = (I);             \
     } while (0)
 
+#define PVM_VAL_MAPPED_P(V)                             \
+  (PVM_IS_ARR ((V)) ? PVM_VAL_ARR_MAPPED_P ((V))        \
+   : PVM_IS_SCT ((V)) ? PVM_VAL_SCT_MAPPED_P ((V))      \
+   : 0)
+
+#define PVM_VAL_SET_MAPPED_P(V,I)               \
+  do                                            \
+    {                                           \
+      if (PVM_IS_ARR ((V)))                     \
+        PVM_VAL_ARR_MAPPED_P ((V)) = (I);       \
+      else if (PVM_IS_SCT ((V)))                \
+        PVM_VAL_SCT_MAPPED_P ((V)) = (I);       \
+    }                                           \
+  while (0)
+
 #define PVM_VAL_MAPPER(V)                               \
   (PVM_IS_ARR ((V)) ? PVM_VAL_ARR_MAPPER ((V))          \
    : PVM_IS_SCT ((V)) ? PVM_VAL_SCT_MAPPER ((V))        \
diff --git a/libpoke/pvm.jitter b/libpoke/pvm.jitter
index a5ebc29e..7cc4e825 100644
--- a/libpoke/pvm.jitter
+++ b/libpoke/pvm.jitter
@@ -3985,6 +3985,53 @@ end
 
 ## Instructions to handle mapped values
 
+# Instruction: mm
+#
+# Given a value, push 1 on the stack if the value is mapped.
+# Push 0 otherwise.
+#
+# Stack: ( VAL -- VAL INT )
+
+instruction mm ()
+  code
+    pvm_val mapped_p = pvm_make_int (PVM_VAL_MAPPED_P (JITTER_TOP_STACK ()),
+                                     32);
+    JITTER_PUSH_STACK (mapped_p);
+  end
+end
+
+# Instruction: map
+#
+# Given a value, mark it as as mapped.  If the value can't be
+# mapped then PVM_E_INVAL is raised.
+#
+# Stack: ( VAL -- VAL )
+# Exceptions: PVM_E_INVAL
+
+instruction map ()
+  code
+    pvm_val val = JITTER_TOP_STACK ();
+
+    if (!(PVM_IS_ARR (val) || PVM_IS_SCT (val)))
+      PVM_RAISE_DFL (PVM_E_INVAL);
+
+    PVM_VAL_SET_MAPPED_P (JITTER_TOP_STACK (), 1);
+  end
+end
+
+# Instruction: unmap
+#
+# Given a value, mark it as as not mapped.  If the value can't be
+# mapped then this is a no-operation.
+#
+# Stack: ( VAL -- VAL )
+
+instruction unmap ()
+  code
+    PVM_VAL_SET_MAPPED_P (JITTER_TOP_STACK (), 0);
+  end
+end
+
 # Instruction: mgeto
 #
 # Given a map-able value, push its bit-offset on the stack as an
diff --git a/testsuite/poke.cmd/set-omaps-1.pk 
b/testsuite/poke.cmd/set-omaps-1.pk
index e7a0eb52..682551b6 100644
--- a/testsuite/poke.cmd/set-omaps-1.pk
+++ b/testsuite/poke.cmd/set-omaps-1.pk
@@ -11,4 +11,4 @@ type Foo = struct { byte a; byte[2] b; };
 
 /* { dg-command { .set omaps yes } } */
 /* { dg-command { Foo @ 0#B } } */
-/* { dg-output "\nFoo \{a=0x10UB,b=\\\[0x20UB,0x30UB\\\] @ 0x8UL#b\} @ 
0x0UL#b" } */
+/* { dg-output "\nFoo \{a=0x10UB @ 0x0UL#b,b=\\\[0x20UB @ 0x8UL#b,0x30UB @ 
0x10UL#b\\\] @ 0x8UL#b @ 0x8UL#b\} @ 0x0UL#b" } */
-- 
2.25.0.2.g232378479e