LCOV - code coverage report
Current view: top level - libebl - eblobjnote.c (source / functions) Hit Total Coverage
Test: elfutils- Lines: 159 259 61.4 %
Date: 2020-06-11 18:20:19 Functions: 1 1 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* Print contents of object file note.
       2             :    Copyright (C) 2002, 2007, 2009, 2011, 2015, 2016, 2018 Red Hat, Inc.
       3             :    This file is part of elfutils.
       4             :    Written by Ulrich Drepper <drepper@redhat.com>, 2002.
       5             : 
       6             :    This file is free software; you can redistribute it and/or modify
       7             :    it under the terms of either
       8             : 
       9             :      * the GNU Lesser General Public License as published by the Free
      10             :        Software Foundation; either version 3 of the License, or (at
      11             :        your option) any later version
      12             : 
      13             :    or
      14             : 
      15             :      * the GNU General Public License as published by the Free
      16             :        Software Foundation; either version 2 of the License, or (at
      17             :        your option) any later version
      18             : 
      19             :    or both in parallel, as here.
      20             : 
      21             :    elfutils is distributed in the hope that it will be useful, but
      22             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      23             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      24             :    General Public License for more details.
      25             : 
      26             :    You should have received copies of the GNU General Public License and
      27             :    the GNU Lesser General Public License along with this program.  If
      28             :    not, see <http://www.gnu.org/licenses/>.  */
      29             : 
      30             : #ifdef HAVE_CONFIG_H
      31             : # include <config.h>
      32             : #endif
      33             : 
      34             : #include <inttypes.h>
      35             : #include <stdio.h>
      36             : #include <stdlib.h>
      37             : #include <string.h>
      38             : #include <libeblP.h>
      39             : 
      40             : #include "common.h"
      41             : #include "libelfP.h"
      42             : #include "libdwP.h"
      43             : #include "memory-access.h"
      44             : 
      45             : 
      46             : void
      47        1038 : ebl_object_note (Ebl *ebl, uint32_t namesz, const char *name, uint32_t type,
      48             :                  uint32_t descsz, const char *desc)
      49             : {
      50        1038 :   if (! ebl->object_note (name, type, descsz, desc))
      51             :     {
      52             :       /* The machine specific function did not know this type.  */
      53             : 
      54        1038 :       if (strcmp ("stapsdt", name) == 0)
      55             :         {
      56           0 :           if (type != 3)
      57             :             {
      58           0 :               printf (gettext ("unknown SDT version %u\n"), type);
      59           0 :               return;
      60             :             }
      61             : 
      62             :           /* Descriptor starts with three addresses, pc, base ref and
      63             :              semaphore.  Then three zero terminated strings provider,
      64             :              name and arguments.  */
      65             : 
      66           0 :           union
      67             :           {
      68             :             Elf64_Addr a64[3];
      69             :             Elf32_Addr a32[3];
      70             :           } addrs;
      71             : 
      72           0 :           size_t addrs_size = gelf_fsize (ebl->elf, ELF_T_ADDR, 3, EV_CURRENT);
      73           0 :           if (descsz < addrs_size + 3)
      74             :             {
      75           0 :             invalid_sdt:
      76           0 :               printf (gettext ("invalid SDT probe descriptor\n"));
      77           0 :               return;
      78             :             }
      79             : 
      80           0 :           Elf_Data src =
      81             :             {
      82             :               .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
      83             :               .d_buf = (void *) desc, .d_size = addrs_size
      84             :             };
      85             : 
      86           0 :           Elf_Data dst =
      87             :             {
      88             :               .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
      89             :               .d_buf = &addrs, .d_size = addrs_size
      90             :             };
      91             : 
      92           0 :           if (gelf_xlatetom (ebl->elf, &dst, &src,
      93           0 :                              elf_getident (ebl->elf, NULL)[EI_DATA]) == NULL)
      94             :             {
      95           0 :               printf ("%s\n", elf_errmsg (-1));
      96           0 :               return;
      97             :             }
      98             : 
      99           0 :           const char *provider = desc + addrs_size;
     100           0 :           const char *pname = memchr (provider, '\0', desc + descsz - provider);
     101           0 :           if (pname == NULL)
     102             :             goto invalid_sdt;
     103             : 
     104           0 :           ++pname;
     105           0 :           const char *args = memchr (pname, '\0', desc + descsz - pname);
     106           0 :           if (args == NULL ||
     107           0 :               memchr (++args, '\0', desc + descsz - pname) != desc + descsz - 1)
     108             :             goto invalid_sdt;
     109             : 
     110           0 :           GElf_Addr pc;
     111           0 :           GElf_Addr base;
     112           0 :           GElf_Addr sem;
     113           0 :           if (gelf_getclass (ebl->elf) == ELFCLASS32)
     114             :             {
     115           0 :               pc = addrs.a32[0];
     116           0 :               base = addrs.a32[1];
     117           0 :               sem = addrs.a32[2];
     118             :             }
     119             :           else
     120             :             {
     121           0 :               pc = addrs.a64[0];
     122           0 :               base = addrs.a64[1];
     123           0 :               sem = addrs.a64[2];
     124             :             }
     125             : 
     126           0 :           printf (gettext ("    PC: "));
     127           0 :           printf ("%#" PRIx64 ",", pc);
     128           0 :           printf (gettext (" Base: "));
     129           0 :           printf ("%#" PRIx64 ",", base);
     130           0 :           printf (gettext (" Semaphore: "));
     131           0 :           printf ("%#" PRIx64 "\n", sem);
     132           0 :           printf (gettext ("    Provider: "));
     133           0 :           printf ("%s,", provider);
     134           0 :           printf (gettext (" Name: "));
     135           0 :           printf ("%s,", pname);
     136           0 :           printf (gettext (" Args: "));
     137           0 :           printf ("'%s'\n", args);
     138           0 :           return;
     139             :         }
     140             : 
     141        1038 :       if (strncmp (name, ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX,
     142             :                    strlen (ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX)) == 0
     143         930 :           && (type == NT_GNU_BUILD_ATTRIBUTE_OPEN
     144         930 :               || type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
     145             :         {
     146             :           /* There might or might not be a pair of addresses in the desc.  */
     147         930 :           if (descsz > 0)
     148             :             {
     149         134 :               printf ("    Address Range: ");
     150             : 
     151         134 :               union
     152             :               {
     153             :                 Elf64_Addr a64[2];
     154             :                 Elf32_Addr a32[2];
     155             :               } addrs;
     156             : 
     157         134 :               size_t addr_size = gelf_fsize (ebl->elf, ELF_T_ADDR,
     158             :                                              2, EV_CURRENT);
     159         134 :               if (descsz != addr_size)
     160           0 :                 printf ("<unknown data>\n");
     161             :               else
     162             :                 {
     163         134 :                   Elf_Data src =
     164             :                     {
     165             :                      .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
     166             :                      .d_buf = (void *) desc, .d_size = descsz
     167             :                     };
     168             : 
     169         134 :                   Elf_Data dst =
     170             :                     {
     171             :                      .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
     172             :                      .d_buf = &addrs, .d_size = descsz
     173             :                     };
     174             : 
     175         134 :                   if (gelf_xlatetom (ebl->elf, &dst, &src,
     176         134 :                                      elf_getident (ebl->elf,
     177         134 :                                                    NULL)[EI_DATA]) == NULL)
     178           0 :                     printf ("%s\n", elf_errmsg (-1));
     179             :                   else
     180             :                     {
     181         134 :                       if (addr_size == 4)
     182           0 :                         printf ("%#" PRIx32 " - %#" PRIx32 "\n",
     183             :                                 addrs.a32[0], addrs.a32[1]);
     184             :                       else
     185         134 :                         printf ("%#" PRIx64 " - %#" PRIx64 "\n",
     186             :                                 addrs.a64[0], addrs.a64[1]);
     187             :                     }
     188             :                 }
     189             :             }
     190             : 
     191             :           /* Most data actually is inside the name.
     192             :              https://fedoraproject.org/wiki/Toolchain/Watermark  */
     193             : 
     194             :           /* We need at least 2 chars of data to describe the
     195             :              attribute and value encodings.  */
     196         930 :           const char *data = (name
     197             :                               + strlen (ELF_NOTE_GNU_BUILD_ATTRIBUTE_PREFIX));
     198         930 :           if (namesz < 2)
     199             :             {
     200           0 :               printf ("<insufficient data>\n");
     201           0 :               return;
     202             :             }
     203             : 
     204         930 :           printf ("    ");
     205             : 
     206             :           /* In most cases the value comes right after the encoding bytes.  */
     207         930 :           const char *value = &data[2];
     208         930 :           switch (data[1])
     209             :             {
     210             :             case GNU_BUILD_ATTRIBUTE_VERSION:
     211         127 :               printf ("VERSION: ");
     212             :               break;
     213             :             case GNU_BUILD_ATTRIBUTE_STACK_PROT:
     214          68 :               printf ("STACK_PROT: ");
     215             :               break;
     216             :             case GNU_BUILD_ATTRIBUTE_RELRO:
     217           0 :               printf ("RELRO: ");
     218             :               break;
     219             :             case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
     220           0 :               printf ("STACK_SIZE: ");
     221             :               break;
     222             :             case GNU_BUILD_ATTRIBUTE_TOOL:
     223          61 :               printf ("TOOL: ");
     224             :               break;
     225             :             case GNU_BUILD_ATTRIBUTE_ABI:
     226          68 :               printf ("ABI: ");
     227             :               break;
     228             :             case GNU_BUILD_ATTRIBUTE_PIC:
     229          68 :               printf ("PIC: ");
     230             :               break;
     231             :             case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
     232          68 :               printf ("SHORT_ENUM: ");
     233             :               break;
     234         470 :             case 32 ... 126:
     235         470 :               printf ("\"%s\": ", &data[1]);
     236         470 :               value += strlen (&data[1]) + 1;
     237         470 :               break;
     238             :             default:
     239           0 :               printf ("<unknown>: ");
     240             :               break;
     241             :             }
     242             : 
     243         930 :           switch (data[0])
     244             :             {
     245         406 :             case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
     246             :               {
     247             :                 /* Any numbers are always in (unsigned) little endian.  */
     248         406 :                 static const Dwarf dbg
     249             :                   = { .other_byte_order = MY_ELFDATA != ELFDATA2LSB };
     250         406 :                 size_t bytes = namesz - (value - name);
     251         406 :                 uint64_t val;
     252         406 :                 if (bytes == 1)
     253         134 :                   val = *(unsigned char *) value;
     254         272 :                 else if (bytes == 2)
     255         204 :                   val = read_2ubyte_unaligned (&dbg, value);
     256          68 :                 else if (bytes == 4)
     257           0 :                   val = read_4ubyte_unaligned (&dbg, value);
     258          68 :                 else if (bytes == 8)
     259          68 :                   val = read_8ubyte_unaligned (&dbg, value);
     260             :                 else
     261             :                   goto unknown;
     262         406 :                 printf ("%" PRIx64, val);
     263             :               }
     264             :               break;
     265             :             case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
     266         188 :               printf ("\"%s\"", value);
     267             :               break;
     268             :             case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
     269         132 :               printf ("TRUE");
     270             :               break;
     271             :             case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
     272         204 :               printf ("FALSE");
     273             :               break;
     274             :             default:
     275             :               {
     276           0 :               unknown:
     277           0 :                 printf ("<unknown>");
     278             :               }
     279             :               break;
     280             :             }
     281             : 
     282         930 :           printf ("\n");
     283             : 
     284         930 :           return;
     285             :         }
     286             : 
     287             :       /* NT_VERSION doesn't have any info.  All data is in the name.  */
     288         108 :       if (descsz == 0 && type == NT_VERSION)
     289             :         return;
     290             : 
     291             :       /* Everything else should have the "GNU" owner name.  */
     292         103 :       if (strcmp ("GNU", name) != 0)
     293             :         return;
     294             : 
     295         102 :       switch (type)
     296             :         {
     297          55 :         case NT_GNU_BUILD_ID:
     298          55 :           if (strcmp (name, "GNU") == 0 && descsz > 0)
     299             :             {
     300          55 :               printf (gettext ("    Build ID: "));
     301          55 :               uint_fast32_t i;
     302        1100 :               for (i = 0; i < descsz - 1; ++i)
     303        1045 :                 printf ("%02" PRIx8, (uint8_t) desc[i]);
     304          55 :               printf ("%02" PRIx8 "\n", (uint8_t) desc[i]);
     305             :             }
     306             :           break;
     307             : 
     308           0 :         case NT_GNU_GOLD_VERSION:
     309           0 :           if (strcmp (name, "GNU") == 0 && descsz > 0)
     310             :             /* A non-null terminated version string.  */
     311           0 :             printf (gettext ("    Linker version: %.*s\n"),
     312             :                     (int) descsz, desc);
     313             :           break;
     314             : 
     315          13 :         case NT_GNU_PROPERTY_TYPE_0:
     316          13 :           if (strcmp (name, "GNU") == 0 && descsz > 0)
     317             :             {
     318             :               /* There are at least 2 words. type and datasz.  */
     319          14 :               while (descsz >= 8)
     320             :                 {
     321          14 :                   struct pr_prop
     322             :                   {
     323             :                     GElf_Word pr_type;
     324             :                     GElf_Word pr_datasz;
     325             :                   } prop;
     326             : 
     327          14 :                   Elf_Data in =
     328             :                     {
     329             :                       .d_version = EV_CURRENT,
     330             :                       .d_type = ELF_T_WORD,
     331             :                       .d_size = 8,
     332             :                       .d_buf = (void *) desc
     333             :                     };
     334          14 :                   Elf_Data out =
     335             :                     {
     336             :                       .d_version = EV_CURRENT,
     337             :                       .d_type = ELF_T_WORD,
     338             :                       .d_size = descsz,
     339             :                       .d_buf = (void *) &prop
     340             :                     };
     341             : 
     342          14 :                   if (gelf_xlatetom (ebl->elf, &out, &in,
     343          14 :                                      elf_getident (ebl->elf,
     344          14 :                                                    NULL)[EI_DATA]) == NULL)
     345             :                     {
     346           0 :                       printf ("%s\n", elf_errmsg (-1));
     347           0 :                       return;
     348             :                     }
     349             : 
     350          14 :                   desc += 8;
     351          14 :                   descsz -= 8;
     352             : 
     353          14 :                   if (prop.pr_datasz > descsz)
     354             :                     {
     355           0 :                       printf ("BAD property datasz: %" PRId32 "\n",
     356             :                               prop.pr_datasz);
     357           0 :                       return;
     358             :                     }
     359             : 
     360          14 :                   int elfclass = gelf_getclass (ebl->elf);
     361          14 :                   char *elfident = elf_getident (ebl->elf, NULL);
     362          14 :                   GElf_Ehdr ehdr;
     363          14 :                   gelf_getehdr (ebl->elf, &ehdr);
     364             : 
     365             :                   /* Prefix.  */
     366          14 :                   printf ("    ");
     367          14 :                   if (prop.pr_type == GNU_PROPERTY_STACK_SIZE)
     368             :                     {
     369           4 :                       printf ("STACK_SIZE ");
     370           4 :                       union
     371             :                         {
     372             :                           Elf64_Addr a64;
     373             :                           Elf32_Addr a32;
     374             :                         } addr;
     375           4 :                       if ((elfclass == ELFCLASS32 && prop.pr_datasz == 4)
     376           2 :                           || (elfclass == ELFCLASS64 && prop.pr_datasz == 8))
     377             :                         {
     378           4 :                           in.d_type = ELF_T_ADDR;
     379           4 :                           out.d_type = ELF_T_ADDR;
     380           4 :                           in.d_size = prop.pr_datasz;
     381           4 :                           out.d_size = prop.pr_datasz;
     382           4 :                           in.d_buf = (void *) desc;
     383           8 :                           out.d_buf = (elfclass == ELFCLASS32
     384             :                                        ? (void *) &addr.a32
     385           4 :                                        : (void *) &addr.a64);
     386             : 
     387           4 :                           if (gelf_xlatetom (ebl->elf, &out, &in,
     388           4 :                                              elfident[EI_DATA]) == NULL)
     389             :                             {
     390           0 :                               printf ("%s\n", elf_errmsg (-1));
     391           0 :                               return;
     392             :                             }
     393           4 :                           if (elfclass == ELFCLASS32)
     394           2 :                             printf ("%#" PRIx32 "\n", addr.a32);
     395             :                           else
     396           2 :                             printf ("%#" PRIx64 "\n", addr.a64);
     397             :                         }
     398             :                       else
     399           0 :                         printf (" (garbage datasz: %" PRIx32 ")\n",
     400             :                                 prop.pr_datasz);
     401             :                     }
     402          10 :                   else if (prop.pr_type == GNU_PROPERTY_NO_COPY_ON_PROTECTED)
     403             :                     {
     404           4 :                       printf ("NO_COPY_ON_PROTECTION");
     405           4 :                       if (prop.pr_datasz == 0)
     406           4 :                         printf ("\n");
     407             :                       else
     408           0 :                         printf (" (garbage datasz: %" PRIx32 ")\n",
     409             :                                 prop.pr_datasz);
     410             :                     }
     411          12 :                   else if (prop.pr_type >= GNU_PROPERTY_LOPROC
     412           6 :                       && prop.pr_type <= GNU_PROPERTY_HIPROC
     413          12 :                       && (ehdr.e_machine == EM_386
     414           6 :                           || ehdr.e_machine == EM_X86_64))
     415             :                     {
     416           6 :                       printf ("X86 ");
     417           6 :                       if (prop.pr_type == GNU_PROPERTY_X86_FEATURE_1_AND)
     418             :                         {
     419           4 :                           printf ("FEATURE_1_AND: ");
     420             : 
     421           4 :                           if (prop.pr_datasz == 4)
     422             :                             {
     423           4 :                               GElf_Word data;
     424           4 :                               in.d_type = ELF_T_WORD;
     425           4 :                               out.d_type = ELF_T_WORD;
     426           4 :                               in.d_size = 4;
     427           4 :                               out.d_size = 4;
     428           4 :                               in.d_buf = (void *) desc;
     429           4 :                               out.d_buf = (void *) &data;
     430             : 
     431           4 :                               if (gelf_xlatetom (ebl->elf, &out, &in,
     432           4 :                                                  elfident[EI_DATA]) == NULL)
     433             :                                 {
     434           0 :                                   printf ("%s\n", elf_errmsg (-1));
     435           0 :                                   return;
     436             :                                 }
     437           4 :                               printf ("%08" PRIx32 " ", data);
     438             : 
     439           4 :                               if ((data & GNU_PROPERTY_X86_FEATURE_1_IBT)
     440             :                                   != 0)
     441             :                                 {
     442           4 :                                   printf ("IBT");
     443           4 :                                   data &= ~GNU_PROPERTY_X86_FEATURE_1_IBT;
     444           4 :                                   if (data != 0)
     445           4 :                                     printf (" ");
     446             :                                 }
     447             : 
     448           4 :                               if ((data & GNU_PROPERTY_X86_FEATURE_1_SHSTK)
     449             :                                   != 0)
     450             :                                 {
     451           4 :                                   printf ("SHSTK");
     452           4 :                                   data &= ~GNU_PROPERTY_X86_FEATURE_1_SHSTK;
     453           4 :                                   if (data != 0)
     454           0 :                                     printf (" ");
     455             :                                 }
     456             : 
     457           4 :                               if (data != 0)
     458           0 :                                 printf ("UNKNOWN");
     459             :                             }
     460             :                           else
     461           0 :                             printf ("<bad datasz: %" PRId32 ">",
     462             :                                     prop.pr_datasz);
     463             : 
     464           4 :                           printf ("\n");
     465             :                         }
     466             :                       else
     467             :                         {
     468           2 :                           printf ("%#" PRIx32, prop.pr_type);
     469           2 :                           if (prop.pr_datasz > 0)
     470             :                             {
     471           2 :                               printf (" data: ");
     472           2 :                               size_t i;
     473           8 :                               for (i = 0; i < prop.pr_datasz - 1; i++)
     474           6 :                                 printf ("%02" PRIx8 " ", (uint8_t) desc[i]);
     475           2 :                               printf ("%02" PRIx8 "\n", (uint8_t) desc[i]);
     476             :                             }
     477             :                         }
     478             :                     }
     479             :                   else
     480             :                     {
     481           0 :                       if (prop.pr_type >= GNU_PROPERTY_LOPROC
     482             :                           && prop.pr_type <= GNU_PROPERTY_HIPROC)
     483           0 :                         printf ("proc_type %#" PRIx32, prop.pr_type);
     484           0 :                       else if (prop.pr_type >= GNU_PROPERTY_LOUSER
     485             :                           && prop.pr_type <= GNU_PROPERTY_HIUSER)
     486           0 :                         printf ("app_type %#" PRIx32, prop.pr_type);
     487             :                       else
     488           0 :                         printf ("unknown_type %#" PRIx32, prop.pr_type);
     489             : 
     490           0 :                       if (prop.pr_datasz > 0)
     491             :                         {
     492           0 :                           printf (" data: ");
     493           0 :                           size_t i;
     494           0 :                           for (i = 0; i < prop.pr_datasz - 1; i++)
     495           0 :                             printf ("%02" PRIx8 " ", (uint8_t) desc[i]);
     496           0 :                           printf ("%02" PRIx8 "\n", (uint8_t) desc[i]);
     497             :                         }
     498             :                     }
     499             : 
     500          14 :                   if (elfclass == ELFCLASS32)
     501           5 :                     prop.pr_datasz = NOTE_ALIGN4 (prop.pr_datasz);
     502             :                   else
     503           9 :                     prop.pr_datasz = NOTE_ALIGN8 (prop.pr_datasz);
     504             : 
     505          14 :                   desc += prop.pr_datasz;
     506          14 :                   if (descsz > prop.pr_datasz)
     507           1 :                     descsz -= prop.pr_datasz;
     508             :                   else
     509             :                     descsz = 0;
     510             :                 }
     511             :             }
     512             :           break;
     513             : 
     514          34 :         case NT_GNU_ABI_TAG:
     515          34 :           if (descsz >= 8 && descsz % 4 == 0)
     516             :             {
     517          34 :               Elf_Data in =
     518             :                 {
     519             :                   .d_version = EV_CURRENT,
     520             :                   .d_type = ELF_T_WORD,
     521             :                   .d_size = descsz,
     522             :                   .d_buf = (void *) desc
     523             :                 };
     524             :               /* Normally NT_GNU_ABI_TAG is just 4 words (16 bytes).  If it
     525             :                  is much (4*) larger dynamically allocate memory to convert.  */
     526             : #define FIXED_TAG_BYTES 16
     527          34 :               uint32_t sbuf[FIXED_TAG_BYTES];
     528          34 :               uint32_t *buf;
     529          34 :               if (unlikely (descsz / 4 > FIXED_TAG_BYTES))
     530             :                 {
     531           0 :                   buf = malloc (descsz);
     532           0 :                   if (unlikely (buf == NULL))
     533           0 :                     return;
     534             :                 }
     535             :               else
     536             :                 buf = sbuf;
     537          34 :               Elf_Data out =
     538             :                 {
     539             :                   .d_version = EV_CURRENT,
     540             :                   .d_type = ELF_T_WORD,
     541             :                   .d_size = descsz,
     542             :                   .d_buf = buf
     543             :                 };
     544             : 
     545          34 :               if (elf32_xlatetom (&out, &in, ebl->data) != NULL)
     546             :                 {
     547          34 :                   const char *os;
     548          34 :                   switch (buf[0])
     549             :                     {
     550             :                     case ELF_NOTE_OS_LINUX:
     551             :                       os = "Linux";
     552             :                       break;
     553             : 
     554           0 :                     case ELF_NOTE_OS_GNU:
     555           0 :                       os = "GNU";
     556           0 :                       break;
     557             : 
     558           0 :                     case ELF_NOTE_OS_SOLARIS2:
     559           0 :                       os = "Solaris";
     560           0 :                       break;
     561             : 
     562           0 :                     case ELF_NOTE_OS_FREEBSD:
     563           0 :                       os = "FreeBSD";
     564           0 :                       break;
     565             : 
     566           0 :                     default:
     567           0 :                       os = "???";
     568           0 :                       break;
     569             :                     }
     570             : 
     571          34 :                   printf (gettext ("    OS: %s, ABI: "), os);
     572         136 :                   for (size_t cnt = 1; cnt < descsz / 4; ++cnt)
     573             :                     {
     574         102 :                       if (cnt > 1)
     575          68 :                         putchar_unlocked ('.');
     576         102 :                       printf ("%" PRIu32, buf[cnt]);
     577             :                     }
     578          34 :                   putchar_unlocked ('\n');
     579             :                 }
     580          34 :               if (descsz / 4 > FIXED_TAG_BYTES)
     581           0 :                 free (buf);
     582          34 :               break;
     583             :             }
     584             :           FALLTHROUGH;
     585             : 
     586             :         default:
     587             :           /* Unknown type.  */
     588             :           break;
     589             :         }
     590           0 :     }
     591             : }

Generated by: LCOV version 1.13