Hi Roland,

branch jankratochvil/readelf-width

On Wed, 10 Oct 2012 20:47:13 +0200, Roland McGrath wrote:
> I don't recall at all why I
> set ITEM_WRAP_COLUMN so high.  At the moment I can't think of any good
> rationale for ever wrapping past column 79, and 75 seems like a good choice.
> Does anything bad happen if you just change ITEM_WRAP_COLUMN to 75?

Yes, bad will happen:

    info.si_signo: 6, info.si_code: 0, info.si_errno: 0, cursig: 6
->
    info.si_signo: 6, info.si_code: 0
    info.si_errno: 0, cursig: 6

etc., everything gets too narrow.

Because max_width is very exaggerated there while the values here like "0" or
"6" are in reality much shorter.

I find the output with applied patch fine, do you see a problem there?

To see the reason this is a debug output with print_core_item having added:
printf ("<%zu:%s>", format_max, format);

Note segment of 2108 bytes at offset 0x2d4:
  Owner          Data size  Type
  CORE                 144  PRSTATUS
    info.si_signo: 6<11:%d>, info.si_code: 0<11:%d>, info.si_errno: 0<11:%d>, 
cursig: 6<6:%d>
    sigpend: <><132:<%s>>
    sighold: <><132:<%s>>
    pid: 21689<11:%d>, ppid: 21686<11:%d>, pgrp: 21686<11:%d>, sid: 5663<11:%d>
    utime: 0.000000<18:%lu.%.6lu>, stime: 0.000999<18:%lu.%.6lu>, cutime: 
0.000000<18:%lu.%.6lu>, cstime: 0.000000<18:%lu.%.6lu>
    orig_eax: 270<11:%d>, fpvalid: 1<11:%d>
    ebx:          21687<11:%11d>  ecx:          21689<11:%11d>  edx:            
  6<11:%11d>
    esi:              0<11:%11d>  edi:     -143585292<11:%11d>  ebp:     
0xf7562308<11: 0x%.8x>
    eax:              0<11:%11d>  eip:     0xf774d430<11: 0x%.8x>  eflags:  
0x00000296<11: 0x%.8x>
    esp:     0xf75621a4<11: 0x%.8x>
    ds: 0x002b<6:0x%.4x>  es: 0x002b<6:0x%.4x>  fs: 0x0000<6:0x%.4x>  gs: 
0x0063<6:0x%.4x>  cs: 0x0023<6:0x%.4x>  ss: 0x002b<6:0x%.4x>
  CORE                 124  PRPSINFO
    state: 2<4:%d>, sname: D<1:%c>, zomb: 0<4:%d>, nice: 0<4:%d>, flag: 
0x00402404<11:0x%.8x>
    uid: 1001<6:%d>, gid: 1001<6:%d>, pid: 21687<11:%d>, ppid: 21686<11:%d>, 
pgrp: 21686<11:%d>, sid: 5663<11:%d>
    fname: backtrace-child<16:%.*s>, psargs: ./backtrace-child-biarch --gencore 
--run <80:%.*s>
  CORE                 160  AUXV
    SYSINFO: 0xf774d420
    SYSINFO_EHDR: 0xf774d000
    HWCAP: 0xbfebfbff  <fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge 
mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe>
    PAGESZ: 4096
    CLKTCK: 100
    PHDR: 0xf7771034
    PHENT: 32
    PHNUM: 8
    BASE: 0xa84c7000
    FLAGS: 0
    ENTRY: 0xf7771670
    UID: 1001
    EUID: 1001
    GID: 1001
    EGID: 1001
    SECURE: 0
    RANDOM: 0xffcfabbb
    EXECFN: 0xffcfcfdf
    PLATFORM: 0xffcfabcb
    NULL
  CORE                 108  FPREGSET
    st0: 0x00000000000000000000<22:0x%s>  st1: 0x00000000000000000000<22:0x%s>
    st2: 0x00000000000000000000<22:0x%s>  st3: 0x00000000000000000000<22:0x%s>
    st4: 0x00000000000000000000<22:0x%s>  st5: 0x00000000000000000000<22:0x%s>
    st6: 0x00000000000000000000<22:0x%s>  st7: 0x00000000000000000000<22:0x%s>
    fctrl: 0x037f<6:0x%.4x>  fstat: 0xffff<6:0x%.4x>
  LINUX                512  PRXFPREG
    xmm0: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm1: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm2: 0x000000000030392e34312e3200504d53<34:0x%.16lx%.16lx>
    xmm3: 0xffffffffff00000000000000ff000000<34:0x%.16lx%.16lx>
    xmm4: 0x000000000030392e34312e3200504d53<34:0x%.16lx%.16lx>
    xmm5: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm6: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm7: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    st0: 0x00000000000000000000<22:0x%s>  st1: 0x00000000000000000000<22:0x%s>
    st2: 0x00000000000000000000<22:0x%s>  st3: 0x00000000000000000000<22:0x%s>
    st4: 0x00000000000000000000<22:0x%s>  st5: 0x00000000000000000000<22:0x%s>
    st6: 0x00000000000000000000<22:0x%s>  st7: 0x00000000000000000000<22:0x%s>
    mxcsr:  0x00001f80<11: 0x%.8x>
    fctrl: 0x037f<6:0x%.4x>  fstat: 0x0000<6:0x%.4x>
  LINUX                 48  386_TLS
    index: 12<11:%d>, base: 0xf7562b40<11:0x%.8x>, limit: 
0x000fffff<11:0x%.8x>, flags: 0x00000051<11:0x%.8x>
    index: 13<11:%d>, base: 0x00000000<11:0x%.8x>, limit: 
0x00000000<11:0x%.8x>, flags: 0x00000028<11:0x%.8x>
    index: 14<11:%d>, base: 0x00000000<11:0x%.8x>, limit: 
0x00000000<11:0x%.8x>, flags: 0x00000028<11:0x%.8x>
  CORE                 144  PRSTATUS
    info.si_signo: 6<11:%d>, info.si_code: 0<11:%d>, info.si_errno: 0<11:%d>, 
cursig: 6<6:%d>
    sigpend: <><132:<%s>>
    sighold: <><132:<%s>>
    pid: 21687<11:%d>, ppid: 21686<11:%d>, pgrp: 21686<11:%d>, sid: 5663<11:%d>
    utime: 0.000000<18:%lu.%.6lu>, stime: 0.000999<18:%lu.%.6lu>, cutime: 
0.000000<18:%lu.%.6lu>, cstime: 0.000000<18:%lu.%.6lu>
    orig_eax: 240<11:%d>, fpvalid: 1<11:%d>
    ebx:     -145347672<11:%11d>  ecx:              0<11:%11d>  edx:          
21689<11:%11d>
    esi:              0<11:%11d>  edi:     -143470604<11:%11d>  ebp:     
0xf7562b40<11: 0x%.8x>
    eax:           -512<11:%11d>  eip:     0xf774d430<11: 0x%.8x>  eflags:  
0x00000296<11: 0x%.8x>
    esp:     0xffcfa900<11: 0x%.8x>
    ds: 0x002b<6:0x%.4x>  es: 0x002b<6:0x%.4x>  fs: 0x0000<6:0x%.4x>  gs: 
0x0000<6:0x%.4x>  cs: 0x0023<6:0x%.4x>  ss: 0x002b<6:0x%.4x>
  CORE                 108  FPREGSET
    st0: 0x00000000000000000000<22:0x%s>  st1: 0x00000000000000000000<22:0x%s>
    st2: 0x00000000000000000000<22:0x%s>  st3: 0x00000000000000000000<22:0x%s>
    st4: 0x00000000000000000000<22:0x%s>  st5: 0x00000000000000000000<22:0x%s>
    st6: 0x00000000000000000000<22:0x%s>  st7: 0x00000000000000000000<22:0x%s>
    fctrl: 0x037f<6:0x%.4x>  fstat: 0xffff<6:0x%.4x>
  LINUX                512  PRXFPREG
    xmm0: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm1: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm2: 0x000000000030392e34312e3200504d53<34:0x%.16lx%.16lx>
    xmm3: 0xffffffffff00000000000000ff000000<34:0x%.16lx%.16lx>
    xmm4: 0x000000000030392e34312e3200504d53<34:0x%.16lx%.16lx>
    xmm5: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm6: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    xmm7: 0x00000000000000000000000000000000<34:0x%.16lx%.16lx>
    st0: 0x00000000000000000000<22:0x%s>  st1: 0x00000000000000000000<22:0x%s>
    st2: 0x00000000000000000000<22:0x%s>  st3: 0x00000000000000000000<22:0x%s>
    st4: 0x00000000000000000000<22:0x%s>  st5: 0x00000000000000000000<22:0x%s>
    st6: 0x00000000000000000000<22:0x%s>  st7: 0x00000000000000000000<22:0x%s>
    mxcsr:  0x00001f80<11: 0x%.8x>
    fctrl: 0x037f<6:0x%.4x>  fstat: 0x0000<6:0x%.4x>
  LINUX                 48  386_TLS
    index: 12<11:%d>, base: 0xf7563940<11:0x%.8x>, limit: 
0x000fffff<11:0x%.8x>, flags: 0x00000051<11:0x%.8x>
    index: 13<11:%d>, base: 0x00000000<11:0x%.8x>, limit: 
0x00000000<11:0x%.8x>, flags: 0x00000028<11:0x%.8x>
    index: 14<11:%d>, base: 0x00000000<11:0x%.8x>, limit: 
0x00000000<11:0x%.8x>, flags: 0x00000028<11:0x%.8x>



Thanks,
Jan


commit 033e40bfb2d9e780197995f378c0c51c666ecabc
Author: Jan Kratochvil <[email protected]>
Date:   Wed Oct 10 22:27:58 2012 +0200

    src/
    2012-10-10  Jan Kratochvil  <[email protected]>
    
        * readelf.c (ITEM_WRAP_COLUMN, REGISTER_WRAP_COLUMN): Merge to ...
        (WRAP_COLUMN): ... here, keep it at 75.
        (print_core_item): Remove parameter format_max.  Update function
        comment.  Replace FORMAT_MAX by the real output width.
        (handle_core_item): Remove the FORMAT_MAX values in TYPES, DO_TYPE,
        calls of print_core_item, remove variable maxfmt, change
        ITEM_WRAP_COLUMN to WRAP_COLUMN.
        (handle_core_register): Remove the FORMAT_MAX values in TYPES, BITS,
        calls of print_core_item, change REGISTER_WRAP_COLUMN to WRAP_COLUMN.
    
    tests/
    2012-10-10  Jan Kratochvil  <[email protected]>
    
        * run-readelf-mixed-corenote.sh: Update expected output.
        * run-readelf-vmcoreinfo.sh: Likewise.
    
    Signed-off-by: Jan Kratochvil <[email protected]>

diff --git a/src/readelf.c b/src/readelf.c
index 5d167eb..1a9092c 100644
--- a/src/readelf.c
+++ b/src/readelf.c
@@ -7337,24 +7337,30 @@ print_debug (Dwfl_Module *dwflmod, Ebl *ebl, GElf_Ehdr 
*ehdr)
 
 
 #define ITEM_INDENT            4
-#define ITEM_WRAP_COLUMN       150
-#define REGISTER_WRAP_COLUMN   75
+#define WRAP_COLUMN            75
+
+/* Print "NAME: FORMAT", wrapping when output text would make the line exceed
+   WRAP_COLUMN.  We do not want the line breaks to depend on the particular
+   values, this is why the FORMAT strings typically already contain their
+   maximum width.  */
 
-/* Print "NAME: FORMAT", wrapping when FORMAT_MAX chars of FORMAT would
-   make the line exceed ITEM_WRAP_COLUMN.  Unpadded numbers look better
-   for the core items.  But we do not want the line breaks to depend on
-   the particular values.  */
 static unsigned int
-__attribute__ ((format (printf, 7, 8)))
+__attribute__ ((format (printf, 6, 7)))
 print_core_item (unsigned int colno, char sep, unsigned int wrap,
-                size_t name_width, const char *name,
-                size_t format_max, const char *format, ...)
+                size_t name_width, const char *name, const char *format, ...)
 {
   size_t len = strlen (name);
   if (name_width < len)
     name_width = len;
 
-  size_t n = name_width + sizeof ": " - 1 + format_max;
+  char *out;
+  va_list ap;
+  va_start (ap, format);
+  int i = vasprintf (&out, format, ap);
+  assert (i >= 0);
+  va_end (ap);
+
+  size_t n = name_width + sizeof ": " - 1 + strlen (out);
 
   if (colno == 0)
     {
@@ -7372,12 +7378,7 @@ print_core_item (unsigned int colno, char sep, unsigned 
int wrap,
       colno = ITEM_INDENT + n;
     }
 
-  printf ("%s: %*s", name, (int) (name_width - len), "");
-
-  va_list ap;
-  va_start (ap, format);
-  vprintf (format, ap);
-  va_end (ap);
+  printf ("%s: %*s%s", name, (int) (name_width - len), "", out);
 
   return colno;
 }
@@ -7420,14 +7421,14 @@ handle_core_item (Elf *core, const Ebl_Core_Item *item, 
const void *desc,
   uint_fast16_t count = item->count ?: 1;
 
 #define TYPES                                                                \
-  DO_TYPE (BYTE, Byte, "0x%.2" PRIx8, "%" PRId8, 4);                         \
-  DO_TYPE (HALF, Half, "0x%.4" PRIx16, "%" PRId16, 6);                       \
-  DO_TYPE (WORD, Word, "0x%.8" PRIx32, "%" PRId32, 11);                        
      \
-  DO_TYPE (SWORD, Sword, "%" PRId32, "%" PRId32, 11);                        \
-  DO_TYPE (XWORD, Xword, "0x%.16" PRIx64, "%" PRId64, 20);                   \
-  DO_TYPE (SXWORD, Sxword, "%" PRId64, "%" PRId64, 20)
-
-#define DO_TYPE(NAME, Name, hex, dec, max) GElf_##Name Name[count]
+  DO_TYPE (BYTE, Byte, "0x%.2" PRIx8, "%" PRId8);                            \
+  DO_TYPE (HALF, Half, "0x%.4" PRIx16, "%" PRId16);                          \
+  DO_TYPE (WORD, Word, "0x%.8" PRIx32, "%" PRId32);                          \
+  DO_TYPE (SWORD, Sword, "%" PRId32, "%" PRId32);                            \
+  DO_TYPE (XWORD, Xword, "0x%.16" PRIx64, "%" PRId64);                       \
+  DO_TYPE (SXWORD, Sxword, "%" PRId64, "%" PRId64)
+
+#define DO_TYPE(NAME, Name, hex, dec) GElf_##Name Name[count]
   union { TYPES; } value;
 #undef DO_TYPE
 
@@ -7459,10 +7460,10 @@ handle_core_item (Elf *core, const Ebl_Core_Item *item, 
const void *desc,
       assert (count == 1);
       switch (type)
        {
-#define DO_TYPE(NAME, Name, hex, dec, max)                                   \
+#define DO_TYPE(NAME, Name, hex, dec)                                        \
          case ELF_T_##NAME:                                                  \
-           colno = print_core_item (colno, ',', ITEM_WRAP_COLUMN,            \
-                                    0, item->name, max, dec, value.Name[0]); \
+           colno = print_core_item (colno, ',', WRAP_COLUMN,                 \
+                                    0, item->name, dec, value.Name[0]); \
            break
          TYPES;
 #undef DO_TYPE
@@ -7475,10 +7476,10 @@ handle_core_item (Elf *core, const Ebl_Core_Item *item, 
const void *desc,
       assert (count == 1);
       switch (type)
        {
-#define DO_TYPE(NAME, Name, hex, dec, max)                                   \
+#define DO_TYPE(NAME, Name, hex, dec)                                        \
          case ELF_T_##NAME:                                                  \
-           colno = print_core_item (colno, ',', ITEM_WRAP_COLUMN,            \
-                                    0, item->name, max, hex, value.Name[0]); \
+           colno = print_core_item (colno, ',', WRAP_COLUMN,                 \
+                                    0, item->name, hex, value.Name[0]);      \
            break
          TYPES;
 #undef DO_TYPE
@@ -7546,8 +7547,7 @@ handle_core_item (Elf *core, const Ebl_Core_Item *item, 
const void *desc,
        if (lastbit > 0 && lastbit + 1 != nbits)
          p += sprintf (p, "-%u", nbits - bias);
 
-       colno = print_core_item (colno, ',', ITEM_WRAP_COLUMN, 0, item->name,
-                                4 + nbits * 4,
+       colno = print_core_item (colno, ',', WRAP_COLUMN, 0, item->name,
                                 negate ? "~<%s>" : "<%s>", printed);
       }
       break;
@@ -7557,14 +7557,12 @@ handle_core_item (Elf *core, const Ebl_Core_Item *item, 
const void *desc,
       assert (count == 2);
       Dwarf_Word sec;
       Dwarf_Word usec;
-      size_t maxfmt = 7;
       switch (type)
        {
-#define DO_TYPE(NAME, Name, hex, dec, max)                                   \
+#define DO_TYPE(NAME, Name, hex, dec)                                        \
          case ELF_T_##NAME:                                                  \
            sec = value.Name[0];                                              \
            usec = value.Name[1];                                             \
-           maxfmt += max;                                                    \
            break
          TYPES;
 #undef DO_TYPE
@@ -7587,19 +7585,19 @@ handle_core_item (Elf *core, const Ebl_Core_Item *item, 
const void *desc,
          else
            usec &= UINT32_MAX;
        }
-      colno = print_core_item (colno, ',', ITEM_WRAP_COLUMN, 0, item->name,
-                              maxfmt, "%" PRIu64 ".%.6" PRIu64, sec, usec);
+      colno = print_core_item (colno, ',', WRAP_COLUMN, 0, item->name,
+                              "%" PRIu64 ".%.6" PRIu64, sec, usec);
       break;
 
     case 'c':
       assert (count == 1);
-      colno = print_core_item (colno, ',', ITEM_WRAP_COLUMN, 0, item->name,
-                              1, "%c", value.Byte[0]);
+      colno = print_core_item (colno, ',', WRAP_COLUMN, 0, item->name,
+                              "%c", value.Byte[0]);
       break;
 
     case 's':
-      colno = print_core_item (colno, ',', ITEM_WRAP_COLUMN, 0, item->name,
-                              count, "%.*s", (int) count, value.Byte);
+      colno = print_core_item (colno, ',', WRAP_COLUMN, 0, item->name,
+                              "%.*s", (int) count, value.Byte);
       break;
 
     case '\n':
@@ -7626,7 +7624,7 @@ handle_core_item (Elf *core, const Ebl_Core_Item *item, 
const void *desc,
          s = eol + 1;
        }
 
-      colno = ITEM_WRAP_COLUMN;
+      colno = WRAP_COLUMN;
       break;
 
     default:
@@ -7722,7 +7720,7 @@ handle_core_items (Elf *core, const void *desc, size_t 
descsz,
            colno = handle_core_item (core, *item, desc, colno, NULL);
 
          /* Force a line break at the end of the group.  */
-         colno = ITEM_WRAP_COLUMN;
+         colno = WRAP_COLUMN;
        }
 
       if (descsz == 0)
@@ -7790,12 +7788,12 @@ handle_core_register (Ebl *ebl, Elf *core, int 
maxregname,
       register_info (ebl, reg, regloc, name, &bits, &type);
 
 #define TYPES                                                                \
-      BITS (8, BYTE, "%4" PRId8, "0x%.2" PRIx8, 4);                          \
-      BITS (16, HALF, "%6" PRId16, "0x%.4" PRIx16, 6);                       \
-      BITS (32, WORD, "%11" PRId32, " 0x%.8" PRIx32, 11);                    \
-      BITS (64, XWORD, "%20" PRId64, "  0x%.16" PRIx64, 20)
+      BITS (8, BYTE, "%4" PRId8, "0x%.2" PRIx8);                             \
+      BITS (16, HALF, "%6" PRId16, "0x%.4" PRIx16);                          \
+      BITS (32, WORD, "%11" PRId32, " 0x%.8" PRIx32);                        \
+      BITS (64, XWORD, "%20" PRId64, "  0x%.16" PRIx64)
 
-#define BITS(bits, xtype, sfmt, ufmt, max)                             \
+#define BITS(bits, xtype, sfmt, ufmt)                          \
       uint##bits##_t b##bits; int##bits##_t b##bits##s
       union { TYPES; uint64_t b128[2]; } value;
 #undef BITS
@@ -7807,17 +7805,17 @@ handle_core_register (Ebl *ebl, Elf *core, int 
maxregname,
        case DW_ATE_address:
          switch (bits)
            {
-#define BITS(bits, xtype, sfmt, ufmt, max)                                   \
+#define BITS(bits, xtype, sfmt, ufmt)                                        \
            case bits:                                                        \
              desc = convert (core, ELF_T_##xtype, 1, &value, desc, 0);       \
              if (type == DW_ATE_signed)                                      \
-               colno = print_core_item (colno, ' ', REGISTER_WRAP_COLUMN,    \
+               colno = print_core_item (colno, ' ', WRAP_COLUMN,             \
                                         maxregname, name,                    \
-                                        max, sfmt, value.b##bits##s);        \
+                                        sfmt, value.b##bits##s);             \
              else                                                            \
-               colno = print_core_item (colno, ' ', REGISTER_WRAP_COLUMN,    \
+               colno = print_core_item (colno, ' ', WRAP_COLUMN,             \
                                         maxregname, name,                    \
-                                        max, ufmt, value.b##bits);           \
+                                        ufmt, value.b##bits);                \
              break
 
            TYPES;
@@ -7826,9 +7824,9 @@ handle_core_register (Ebl *ebl, Elf *core, int maxregname,
              assert (type == DW_ATE_unsigned);
              desc = convert (core, ELF_T_XWORD, 2, &value, desc, 0);
              int be = elf_getident (core, NULL)[EI_DATA] == ELFDATA2MSB;
-             colno = print_core_item (colno, ' ', REGISTER_WRAP_COLUMN,
+             colno = print_core_item (colno, ' ', WRAP_COLUMN,
                                       maxregname, name,
-                                      34, "0x%.16" PRIx64 "%.16" PRIx64,
+                                      "0x%.16" PRIx64 "%.16" PRIx64,
                                       value.b128[!be], value.b128[be]);
              break;
 
@@ -7857,9 +7855,8 @@ handle_core_register (Ebl *ebl, Elf *core, int maxregname,
              *h++ = "0123456789abcdef"[bytes[idx] >> 4];
              *h++ = "0123456789abcdef"[bytes[idx] & 0xf];
            }
-         colno = print_core_item (colno, ' ', REGISTER_WRAP_COLUMN,
-                                  maxregname, name,
-                                  2 + sizeof hex - 1, "0x%s", hex);
+         colno = print_core_item (colno, ' ', WRAP_COLUMN,
+                                  maxregname, name, "0x%s", hex);
          break;
        }
       desc += regloc->pad;
@@ -7998,7 +7995,7 @@ handle_core_registers (Ebl *ebl, Elf *core, const void 
*desc,
                                      reg->regloc, desc, colno);
 
       /* Force a line break at the end of the group.  */
-      colno = REGISTER_WRAP_COLUMN;
+      colno = WRAP_COLUMN;
     }
 
   return colno;
diff --git a/tests/run-readelf-mixed-corenote.sh 
b/tests/run-readelf-mixed-corenote.sh
index f9b96c8..5406433 100755
--- a/tests/run-readelf-mixed-corenote.sh
+++ b/tests/run-readelf-mixed-corenote.sh
@@ -25,8 +25,7 @@ Note segment of 892 bytes at offset 0x274:
   Owner          Data size  Type
   CORE                 148  PRSTATUS
     info.si_signo: 11, info.si_code: 0, info.si_errno: 0, cursig: 11
-    sigpend: <>
-    sighold: <>
+    sigpend: <>, sighold: <>
     pid: 11087, ppid: 11063, pgrp: 11087, sid: 11063
     utime: 0.000000, stime: 0.010000, cutime: 0.000000, cstime: 0.000000
     orig_r0: -1, fpvalid: 1
diff --git a/tests/run-readelf-vmcoreinfo.sh b/tests/run-readelf-vmcoreinfo.sh
index da361c8..b441a58 100755
--- a/tests/run-readelf-vmcoreinfo.sh
+++ b/tests/run-readelf-vmcoreinfo.sh
@@ -25,8 +25,7 @@ Note segment of 2104 bytes at offset 0x158:
   Owner          Data size  Type
   CORE                 336  PRSTATUS
     info.si_signo: 0, info.si_code: 0, info.si_errno: 0, cursig: 0
-    sigpend: <>
-    sighold: <>
+    sigpend: <>, sighold: <>
     pid: 3519, ppid: 0, pgrp: 0, sid: 0
     utime: 0.000000, stime: 0.000000, cutime: 0.000000, cstime: 0.000000
     orig_rax: -1, fpvalid: 0
@@ -43,8 +42,7 @@ Note segment of 2104 bytes at offset 0x158:
     cs: 0x0010  ss: 0x0018  ds: 0x0000  es: 0x0000  fs: 0x0000  gs: 0x0000
   CORE                 336  PRSTATUS
     info.si_signo: 0, info.si_code: 0, info.si_errno: 0, cursig: 0
-    sigpend: <>
-    sighold: <>
+    sigpend: <>, sighold: <>
     pid: 0, ppid: 0, pgrp: 0, sid: 0
     utime: 0.000000, stime: 0.000000, cutime: 0.000000, cstime: 0.000000
     orig_rax: -1, fpvalid: 0
_______________________________________________
elfutils-devel mailing list
[email protected]
https://lists.fedorahosted.org/mailman/listinfo/elfutils-devel

Reply via email to