LXR 6.1/​cpukit/​libdl/​rtl-shell.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:16

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  * @file
  *
  * @ingroup rtems_rtld
  *
  * @brief RTEMS Run-Time Link Editor Shell Commands
  *
  * A simple RTL command to aid using the RTL.
  */
 
 /*
  *  COPYRIGHT (c) 2012, 2018 Chris Johns <chrisj@rtems.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <inttypes.h>
 #include <rtems/inttypes.h>
 
 #include <sys/stat.h>
 #include <regex.h>
 #include <string.h>
 
 #include <dlfcn.h>
 
 #include <rtems/printer.h>
 #include <rtems/rtl/rtl.h>
 #include <rtems/rtl/rtl-archive.h>
 #include <rtems/rtl/rtl-shell.h>
 #include <rtems/rtl/rtl-trace.h>
 #include "rtl-chain-iterator.h"
 
 /**
  * The type of the shell handlers we have.
  */
 typedef int (*rtems_rtl_shell_handler) (const rtems_printer* printer, int argc, char *argv[]);
 
 /**
  * Table of handlers we parse to invoke the command.
  */
 typedef struct
 {
   const char*             name;    /**< The sub-command's name. */
   rtems_rtl_shell_handler handler; /**< The sub-command's handler. */
   const char*             help;    /**< The sub-command's help. */
 } rtems_rtl_shell_cmd;
 
 /**
  * Object summary data.
  */
 typedef struct
 {
   int    count;   /**< The number of object files. */
   size_t exec;    /**< The amount of executable memory allocated. */
   size_t symbols; /**< The amount of symbol memory allocated. */
 } rtems_rtl_obj_summary;
 
 /**
  * Object summary iterator.
  */
 static bool
 rtems_rtl_obj_summary_iterator (rtems_chain_node* node, void* data)
 {
   rtems_rtl_obj_summary* summary = data;
   rtems_rtl_obj*         obj = (rtems_rtl_obj*) node;
   ++summary->count;
   summary->exec += obj->exec_size;
   summary->symbols += obj->global_size;
   return true;
 }
 
 /**
  * Count the number of symbols.
  */
 static int
 rtems_rtl_count_symbols (rtems_rtl_data* rtl)
 {
   int count;
   int bucket;
   for (count = 0, bucket = 0; bucket < rtl->globals.nbuckets; ++bucket)
     count += rtems_rtl_chain_count (&rtl->globals.buckets[bucket]);
   return count;
 }
 
 static int
 rtems_rtl_shell_status (const rtems_printer* printer,
                         int                  argc,
                         char*                argv[])
 {
   rtems_rtl_obj_summary summary;
   size_t                total_memory;
   rtems_rtl_data*       rtl;
 
   rtl = rtems_rtl_lock ();
   if (rtl == NULL)
   {
     rtems_printf (printer, "error: cannot lock the linker\n");
     return 1;
   }
 
   summary.count   = 0;
   summary.exec    = 0;
   summary.symbols = 0;
   rtems_rtl_chain_iterate (&rtl->objects,
                            rtems_rtl_obj_summary_iterator,
                            &summary);
   /*
    * Currently does not include the name strings in the obj struct.
    */
   total_memory =
     sizeof (*rtl) + (summary.count * sizeof (rtems_rtl_obj)) +
     summary.exec + summary.symbols;
 
   rtems_printf (printer, "Runtime Linker Status:\n");
   rtems_printf (printer, "        paths: %s\n", rtl->paths);
   rtems_printf (printer, "      objects: %d\n", summary.count);
   rtems_printf (printer, " total memory: %zi\n", total_memory);
   rtems_printf (printer, "  exec memory: %zi\n", summary.exec);
   rtems_printf (printer, "   sym memory: %zi\n", summary.symbols);
   rtems_printf (printer, "      symbols: %d\n", rtems_rtl_count_symbols (rtl));
 
   rtems_rtl_unlock ();
 
   return 0;
 }
 
 /**
  * Object print data.
  */
 typedef struct
 {
   const rtems_printer* printer;      /**< The RTEMS printer. */
   rtems_rtl_data*      rtl;          /**< The RTL data. */
   int                  indent;       /**< Spaces to indent. */
   bool                 oname;        /**< Print object names. */
   bool                 names;        /**< Print details of all names. */
   bool                 stats;        /**< Print stats. */
   bool                 memory_map;   /**< Print the memory map. */
   bool                 symbols;      /**< Print the global symbols. */
   bool                 dependencies; /**< Print any dependencies. */
   bool                 trampolines;  /**< Print trampoline stats. */
   bool                 base;         /**< Include the base object file. */
   const char*          re_name;      /**< Name regx to filter on. */
   const char*          re_symbol;    /**< Symbol regx to filter on. */
 } rtems_rtl_obj_print;
 
 /**
  * Parse an argument.
  */
 static bool
 rtems_rtl_parse_opt (const char opt, int argc, char *argv[])
 {
   size_t arg;
   for (arg = 1; arg < argc; ++arg)
   {
     if (argv[arg][0] == '-')
     {
       size_t len = strlen (argv[arg]);
       size_t i;
       for (i = 1; i < len; ++i)
         if (argv[arg][i] == opt)
           return true;
     }
   }
   return false;
 }
 
 static bool
 rtems_rtl_check_opts (const rtems_printer* printer,
                       const char*          opts,
                       int                  argc,
                       char*                argv[])
 {
   size_t olen = strlen (opts);
   size_t arg;
   for (arg = 1; arg < argc; ++arg)
   {
     if (argv[arg][0] == '-')
     {
       size_t len = strlen (argv[arg]);
       size_t i;
       for (i = 1; i < len; ++i)
       {
         bool found = false;
         size_t       o;
         for (o = 0; o < olen; ++o)
         {
           if (argv[arg][i] == opts[o])
           {
             found = true;
             break;
           }
         }
         if (!found)
         {
           rtems_printf (printer, "error: invalid option: %c (%s)\n",
                         argv[arg][i], argv[arg]);
           return false;
         }
       }
     }
   }
   return true;
 }
 
 static ssize_t
 rtems_rtl_parse_arg_index (const char  opt,
                            const char* skip_opts,
                            int         argc,
                            char*       argv[])
 {
   ssize_t arg;
   for (arg = 1; arg < argc; ++arg)
   {
     if (argv[arg][0] == '-')
     {
       /*
        * We can check the next char because there has to be a valid char or a
        * nul.
        */
       if (argv[arg][1] != '\0')
       {
         size_t len = skip_opts != NULL ? strlen (skip_opts) : 0;
         size_t i;
         for (i = 0; i < len; ++i)
         {
           if (skip_opts[i] == argv[arg][1])
           {
             ++arg;
             break;
           }
         }
       }
     }
     else
     {
       if (opt == ' ')
         return arg;
     }
     /*
      * Is this an option and does it match what we are looking for?
      */
     if (arg < argc && argv[arg][0] == '-' && argv[arg][1] == opt)
       return arg + 1;
   }
   return -1;
 }
 
 static const char*
 rtems_rtl_parse_arg (const char  opt,
                      const char* skip_opts,
                      int         argc,
                      char*       argv[])
 {
   ssize_t arg = rtems_rtl_parse_arg_index (opt, skip_opts, argc, argv);
   if (arg < 0)
     return NULL;
   return argv[arg];
 }
 
 /**
  * Regx matching.
  */
 static bool
 rtems_rtl_regx_compile (const rtems_printer* printer,
                         const char*          label,
                         regex_t*             rege,
                         const char*          expression)
 {
   int r = regcomp (rege, expression, REG_EXTENDED | REG_NOSUB);
   if (r != 0)
   {
     char rerror[128];
     regerror (r, rege, rerror, sizeof(rerror));
     rtems_printf (printer, "error: %s: %s\n", label, rerror);
     return false;
   }
   return true;
 }
 
 static int
 rtems_rtl_regx_match (const rtems_printer* printer,
                       const char*          label,
                       regex_t*             rege,
                       const char*          string)
 {
   int r = regexec (rege, string, 0, NULL, 0);
   if (r != 0 && r != REG_NOMATCH)
   {
     char rerror[128];
     regerror (r, rege, rerror, sizeof(rerror));
     rtems_printf (printer, "error: %s: %s\n", label, rerror);
     regfree (rege);
     return -1;
   }
   return r == 0 ? 1 : 0;
 }
 
 /**
  * Print the obj name.
  */
 static void
 rtems_rtl_print_obj_name (const rtems_rtl_obj_print* print, rtems_rtl_obj* obj)
 {
   rtems_printf (print->printer, "%-*c", print->indent, ' ');
   if (rtems_rtl_obj_aname (obj) != NULL)
     rtems_printf (print->printer, "%s:", rtems_rtl_obj_aname (obj));
   rtems_printf (print->printer, "%s\n", rtems_rtl_obj_oname (obj));
 }
 
 /**
  * Print symbols.
  */
 static bool
 rtems_rtl_print_symbols (rtems_rtl_obj_print* print,
                          rtems_rtl_obj*       obj,
                          int                  indent,
                          bool                 show_name)
 {
   regex_t rege;
   int     max_len = 0;
   int     s;
 
   if (print->re_symbol != NULL &&
       !rtems_rtl_regx_compile (print->printer,
                                "symbol filter",
                                &rege, print->re_symbol))
   {
     return false;
   }
 
   for (s = 0; s < obj->global_syms; ++s)
   {
     const char* sym = obj->global_table[s].name;
     int         len;
 
     if (print->re_symbol != NULL)
     {
       int r = rtems_rtl_regx_match (print->printer, "symbol match", &rege, sym);
       if (r < 0)
         return false;
       if (!r)
         continue;
     }
 
     len = strlen (obj->global_table[s].name);
     if (len > max_len)
       max_len = len;
   }
 
   for (s = 0; s < obj->global_syms; ++s)
   {
     const char* sym = obj->global_table[s].name;
     if (print->re_symbol != NULL)
     {
       int r = rtems_rtl_regx_match (print->printer, "symbol match", &rege, sym);
       if (r < 0)
         return false;
       if (r == 0)
         continue;
     }
     if (show_name)
     {
       show_name = false;
       rtems_rtl_print_obj_name (print, obj);
     }
     rtems_printf (print->printer, "%-*c%-*s = %p\n", indent + 2, ' ',
                   max_len, sym, obj->global_table[s].value);
   }
 
   regfree (&rege);
 
   return true;
 }
 
 /**
  * Dependencies printer.
  */
 typedef struct
 {
   const rtems_rtl_obj_print* print;     /**< The print data. */
   bool                       first;     /**< Is this the first line printed. */
   bool                       show_name; /**< Show the object name. */
   int                        indent;    /**< The indent. */
 } rtems_rtl_dep_data;
 
 static bool
 rtems_rtl_dependencies (rtems_rtl_obj* obj, rtems_rtl_obj* dependent, void* data)
 {
   rtems_rtl_dep_data* dd = (rtems_rtl_dep_data*) data;
   if (dd->first)
   {
     dd->first = false;
     if (dd->show_name)
     {
       dd->show_name = false;
       rtems_rtl_print_obj_name (dd->print, obj);
     }
     rtems_printf (dd->print->printer, "%-*cdependencies  : ", dd->indent, ' ');
     dd->indent += strlen ("dependencies :");
   }
   else
   {
     rtems_printf (dd->print->printer, "\n%-*c: ", (int) dd->indent, ' ');
   }
   rtems_printf (dd->print->printer, "%s", dependent->oname);
   return false;
 }
 
 /**
  * Object printer.
  */
 static bool
 rtems_rtl_obj_printer (rtems_rtl_obj_print* print, rtems_rtl_obj* obj)
 {
   char flags_str[33];
   int  indent = print->indent + 1;
   bool show_name = true;
 
   /*
    * Skip the base module unless asked to show it.
    */
   if (!print->base && (obj == print->rtl->base))
       return true;
 
   if (print->re_name != NULL)
   {
     regex_t rege;
     int     r = 0;
 
     if (!rtems_rtl_regx_compile (print->printer,
                                  "name filter",
                                  &rege, print->re_name))
     {
       return false;
     }
 
     if (rtems_rtl_obj_aname (obj) != NULL)
     {
       r = rtems_rtl_regx_match (print->printer,
                                 "aname match",
                                 &rege,
                                 rtems_rtl_obj_aname (obj));
       if (r < 0)
         return false;
     }
 
     if (r == 0)
     {
       r = rtems_rtl_regx_match (print->printer,
                                 "oname match",
                                 &rege,
                                 rtems_rtl_obj_oname (obj));
       if (r < 0)
         return false;
     }
 
     regfree (&rege);
 
     if (r == 0)
       return true;
   }
 
   if (print->names || print->memory_map || print->stats ||
       (!print->names && !print->memory_map && !print->stats &&
        !print->symbols && !print->dependencies))
   {
     show_name = false;
     rtems_rtl_print_obj_name (print, obj);
   }
 
   if (print->names)
   {
     rtems_printf (print->printer,
                   "%-*cfile name     : %s\n",
                   indent, ' ', rtems_rtl_obj_fname (obj));
     rtems_printf (print->printer,
                   "%-*carchive name  : %s\n",
                   indent, ' ', rtems_rtl_obj_aname (obj));
     strcpy (flags_str, "--");
     if (obj->flags & RTEMS_RTL_OBJ_LOCKED)
       flags_str[0] = 'L';
     if (obj->flags & RTEMS_RTL_OBJ_UNRESOLVED)
       flags_str[1] = 'U';
     rtems_printf (print->printer,
                   "%-*cflags         : %s\n", indent, ' ', flags_str);
     rtems_printf (print->printer,
                   "%-*cfile offset   : %" PRIdoff_t "\n", indent, ' ', obj->ooffset);
     rtems_printf (print->printer,
                   "%-*cfile size     : %zi\n", indent, ' ', obj->fsize);
   }
   if (print->memory_map)
   {
     rtems_printf (print->printer,
                   "%-*cexec size     : %zi\n", indent, ' ', obj->exec_size);
     rtems_printf (print->printer,
                   "%-*ctext base     : %p (%zi)\n", indent, ' ',
                   obj->text_base, obj->text_size);
     rtems_printf (print->printer,
                   "%-*cconst base    : %p (%zi)\n", indent, ' ',
                   obj->const_base, obj->const_size);
     rtems_printf (print->printer,
                   "%-*cdata base     : %p (%zi)\n", indent, ' ',
                   obj->data_base, obj->data_size);
     rtems_printf (print->printer,
                   "%-*cbss base      : %p (%zi)\n", indent, ' ',
                   obj->bss_base, obj->bss_size);
   }
   if (print->stats)
   {
     rtems_printf (print->printer, "%-*cunresolved    : %zu\n", indent, ' ', obj->unresolved);
     rtems_printf (print->printer, "%-*cusers         : %zu\n", indent, ' ', obj->users);
     rtems_printf (print->printer, "%-*creferences    : %zu\n", indent, ' ', obj->refs);
     rtems_printf (print->printer, "%-*ctrampolines   : %zu\n", indent, ' ',
                   rtems_rtl_obj_trampolines (obj));
     rtems_printf (print->printer, "%-*csymbols       : %zi\n", indent, ' ', obj->global_syms);
     rtems_printf (print->printer, "%-*csymbol memory : %zi\n", indent, ' ', obj->global_size);
   }
   if (print->symbols)
   {
     if (!rtems_rtl_print_symbols (print, obj, indent, show_name))
       return false;
   }
   if (print->dependencies)
   {
     rtems_rtl_dep_data dd = {
       .print = print,
       .first = true,
       .show_name = show_name,
       .indent = indent
     };
     rtems_rtl_obj_iterate_dependents (obj, rtems_rtl_dependencies, &dd);
     if (!dd.first)
       rtems_printf (print->printer, "\n");
   }
   if (print->trampolines)
   {
     if (obj->tramp_size == 0)
     {
       rtems_printf (print->printer, "%-*ctrampolines: not supported\n", indent, ' ');
     }
     else
     {
       size_t slots = rtems_rtl_obj_trampoline_slots (obj);
       size_t used = rtems_rtl_obj_trampolines (obj);
       rtems_printf (print->printer, "%-*ctrampolines:\n", indent, ' ');
       rtems_printf (print->printer, "%-*cslots     : %zu\n", indent + 4, ' ',
                     slots);
       rtems_printf (print->printer, "%-*csize      : %zu\n", indent + 4, ' ',
                     obj->tramp_size);
       rtems_printf (print->printer, "%-*cslot size : %zu\n", indent + 4, ' ',
                     obj->tramp_size);
       rtems_printf (print->printer, "%-*cused      : %zu\n", indent + 4, ' ',
                     used);
       rtems_printf (print->printer, "%-*crelocs    : %zu\n", indent + 4, ' ',
                     obj->tramp_relocs);
       rtems_printf (print->printer, "%-*cunresolved: %zu\n", indent + 4, ' ',
                     slots - obj->tramp_relocs);
       rtems_printf (print->printer, "%-*cyield     : %zu%%\n", indent + 4, ' ',
                     slots ? (used * 100) / slots : 0);
     }
   }
   return true;
 }
 
 /**
  * Object unresolved symbols printer.
  */
 static bool
 rtems_rtl_unresolved_printer (rtems_rtl_unresolv_rec* rec,
                               void*                   data)
 {
   rtems_rtl_obj_print* print = (rtems_rtl_obj_print*) data;
   if (rec->type == rtems_rtl_unresolved_symbol)
     rtems_printf (print->printer,
                   "%-*c%s\n", print->indent + 2, ' ', rec->rec.name.name);
   return false;
 }
 
 /**
  * Object print iterator.
  */
 static bool
 rtems_rtl_obj_print_iterator (rtems_chain_node* node, void* data)
 {
   rtems_rtl_obj_print* print = data;
   rtems_rtl_obj*       obj = (rtems_rtl_obj*) node;
   return rtems_rtl_obj_printer (print, obj);
 }
 
 int
 rtems_rtl_shell_list (const rtems_printer* printer, int argc, char* argv[])
 {
   rtems_rtl_obj_print print = { 0 };
   if (!rtems_rtl_check_opts (printer, "anlmsdbt", argc, argv))
     return 1;
   print.printer = printer;
   print.indent = 1;
   print.oname = true;
   if (rtems_rtl_parse_opt ('a', argc, argv))
   {
     print.names = true;
     print.stats = true;
     print.memory_map = true;
     print.symbols = true;
     print.dependencies = true;
     print.trampolines = true;
   }
   else
   {
     print.names = rtems_rtl_parse_opt ('n', argc, argv);
     print.stats = rtems_rtl_parse_opt ('l', argc, argv);;
     print.memory_map = rtems_rtl_parse_opt ('m', argc, argv);;
     print.symbols = rtems_rtl_parse_opt ('s', argc, argv);
     print.dependencies = rtems_rtl_parse_opt ('d', argc, argv);;
     print.trampolines = rtems_rtl_parse_opt ('t', argc, argv);;
     print.base = rtems_rtl_parse_opt ('b', argc, argv);;
     print.re_name = rtems_rtl_parse_arg (' ', NULL, argc, argv);
   }
   print.re_symbol = NULL;
   print.rtl = rtems_rtl_lock ();
   if (print.rtl == NULL)
   {
     rtems_printf (print.printer, "error: cannot lock the linker\n");
     return 1;
   }
   rtems_rtl_chain_iterate (&print.rtl->objects,
                            rtems_rtl_obj_print_iterator,
                            &print);
   rtems_rtl_unlock ();
   return 0;
 }
 
 int
 rtems_rtl_shell_sym (const rtems_printer* printer, int argc, char* argv[])
 {
   rtems_rtl_obj_print print = { 0 };
   if (!rtems_rtl_check_opts (printer, "buo", argc, argv))
     return 1;
   print.printer = printer;
   print.indent = 1;
   print.oname = true;
   print.names = false;
   print.stats = false;
   print.memory_map = false;
   print.symbols = !rtems_rtl_parse_opt ('u', argc, argv);;
   print.dependencies = false;
   print.base = rtems_rtl_parse_opt ('b', argc, argv);
   print.re_name = rtems_rtl_parse_arg ('o', NULL, argc, argv);;
   print.re_symbol = rtems_rtl_parse_arg (' ', "ou", argc, argv);
   print.rtl = rtems_rtl_lock ();
   if (print.rtl == NULL)
   {
     rtems_printf (print.printer, "error: cannot lock the linker\n");
     return 1;
   }
   if (print.symbols)
   {
     rtems_rtl_chain_iterate (&print.rtl->objects,
                              rtems_rtl_obj_print_iterator,
                              &print);
   }
   if (rtems_rtl_parse_opt ('u', argc, argv))
   {
     rtems_printf (printer, "Unresolved:\n");
     rtems_rtl_unresolved_iterate (rtems_rtl_unresolved_printer, &print);
   }
   rtems_rtl_unlock ();
   return 0;
 }
 
 int
 rtems_rtl_shell_object (const rtems_printer* printer, int argc, char* argv[])
 {
   size_t arg;
 
   --argc;
   ++argv;
 
   for (arg = 0; arg < argc; ++arg)
   {
     if (argv[arg][0] == '-')
     {
       switch (argv[arg][1])
       {
         case 'h':
         case '?':
           rtems_printf (printer, "obj commands:\n");
           rtems_printf (printer, " load <file>\n");
           rtems_printf (printer, " unload <file>\n");
           break;
         default:
           rtems_printf (printer, "error: invalid option: %s\n", argv[arg]);
           return 1;
       }
     }
     else
     {
       break;
     }
   }
 
   if (arg >= argc)
   {
     rtems_printf (printer, "error: no obj command\n");
     return 1;
   }
 
   if (strcmp (argv[arg], "load") == 0)
   {
     void* handle;
     int   unresolved;
 
     ++arg;
     if (arg >= argc)
     {
       rtems_printf (printer, "error: no object file to load\n");
       return 1;
     }
 
     handle = dlopen (argv[arg], RTLD_NOW | RTLD_GLOBAL);
     if (handle == NULL)
     {
       rtems_printf (printer, "error: load: %s: %s\n", argv[arg], dlerror ());
       return 1;
     }
 
     if (dlinfo (RTLD_SELF, RTLD_DI_UNRESOLVED, &unresolved) < 0)
     {
       rtems_printf (printer, "error: %s: %s\n", argv[arg], dlerror ());
       return 1;
     }
 
     if (unresolved != 0)
     {
       rtems_printf (printer, "warning: unresolved symbols present\n");
       return 1;
     }
   }
   else if (strcmp (argv[arg], "unload") == 0)
   {
     rtems_rtl_data* rtl;
     rtems_rtl_obj*  obj;
 
     ++arg;
     if (arg >= argc)
     {
       rtems_printf (printer, "error: no object file to load\n");
       return 1;
     }
 
     rtl = rtems_rtl_lock ();
     if (rtl == NULL)
     {
       rtems_printf (printer, "error: cannot lock RTL\n");
       return 1;
     }
 
     obj = rtems_rtl_find_obj (argv[arg]);
     if (obj == NULL)
     {
       rtems_rtl_unlock ();
       rtems_printf (printer, "error: unload: %s: %s\n", argv[arg], dlerror ());
       return 1;
     }
 
     if (!rtems_rtl_unload (obj))
     {
       rtems_rtl_unlock ();
       rtems_printf (printer, "error: unload: %s: %s\n", argv[arg], dlerror ());
       return 1;
     }
 
     rtems_rtl_unlock ();
   }
   else
   {
     rtems_printf (printer, "error: unknown obj command: %s\n", argv[arg]);
     return 1;
   }
 
   return 0;
 }
 
 int
 rtems_rtl_shell_archive (const rtems_printer* printer, int argc, char* argv[])
 {
   rtems_rtl_data*   rtl;
   rtems_chain_node* node;
   const char*       re_name;
   bool              details;
   bool              symbols;
   bool              duplicates;
   regex_t           rege;
 
   if (!rtems_rtl_check_opts (printer, "dsl", argc, argv))
     return 1;
 
   details = rtems_rtl_parse_opt ('l', argc, argv);
   symbols = rtems_rtl_parse_opt ('s', argc, argv);
   duplicates = rtems_rtl_parse_opt ('d', argc, argv);
 
   re_name = rtems_rtl_parse_arg (' ', NULL, argc, argv);
 
   if (re_name != NULL)
   {
     if (!rtems_rtl_regx_compile (printer,
                                  "name filter",
                                  &rege,
                                  re_name))
     {
       return false;
     }
   }
 
   rtl = rtems_rtl_lock ();
   if (rtl == NULL)
   {
     rtems_printf (printer, "error: cannot lock the linker\n");
     return 1;
   }
 
   node = rtems_chain_first (&rtl->archives.archives);
 
   while (!rtems_chain_is_tail (&rtl->archives.archives, node))
   {
     #define SYM_DUPLICATE (((size_t) 1) << ((8 * sizeof (size_t)) - 1))
 
     rtems_rtl_archive* archive = (rtems_rtl_archive*) node;
 
     if (re_name != NULL)
     {
       int r = rtems_rtl_regx_match (printer,
                                     "name match",
                                     &rege,
                                     archive->name);
       if (r < 0)
       {
         rtems_rtl_unlock ();
         return false;
       }
 
       if (r == 0)
       {
         node = rtems_chain_next (node);
         continue;
       }
     }
 
     rtems_printf (printer, "%s%c\n",
                   archive->name,
                   details | symbols | duplicates ? ':' : ' ');
 
     if (details)
     {
       rtems_printf (printer, "  size    : %zu\n", archive->size);
       rtems_printf (printer, "  symbols : %zu\n", archive->symbols.entries);
       rtems_printf (printer, "  refs    : %zu\n", archive->refs);
       rtems_printf (printer, "  flags   : %" PRIx32 "\n", archive->flags);
     }
 
     if (symbols)
     {
       const char* symbol = archive->symbols.names;
       int         indent = 0;
       size_t      s;
 
       rtems_printf (printer, "  symbols :");
 
       for (s = 0; s < archive->symbols.entries; ++s)
       {
         if (archive->symbols.symbols != NULL)
           symbol = archive->symbols.symbols[s].label;
 
         rtems_printf (printer, "%-*c%s\n", indent, ' ', symbol);
         indent = 12;
 
         if (archive->symbols.symbols == NULL)
           symbol += strlen (symbol) + 1;
       }
 
       if (indent == 0)
         rtems_printf (printer, "\n");
     }
 
     if (duplicates)
     {
       rtems_chain_node* match_node;
       int               indent = 0;
       bool              show_dups = true;
 
       match_node = rtems_chain_first (&rtl->archives.archives);
 
       while (!rtems_chain_is_tail (&rtl->archives.archives, match_node))
       {
         rtems_rtl_archive* match_archive = (rtems_rtl_archive*) match_node;
         const char*        symbol = archive->symbols.names;
         size_t             s;
 
         for (s = 0; s < archive->symbols.entries; ++s)
         {
           if (archive->symbols.symbols == NULL ||
               (archive->symbols.symbols[s].entry & SYM_DUPLICATE) == 0)
           {
             const char* match_symbol = match_archive->symbols.names;
             size_t      ms;
 
             if (archive->symbols.symbols != NULL)
               symbol = archive->symbols.symbols[s].label;
 
             for (ms = 0; ms < match_archive->symbols.entries; ++ms)
             {
               if (match_archive->symbols.symbols != NULL)
                 match_symbol = match_archive->symbols.symbols[ms].label;
 
               if (symbol != match_symbol && strcmp (symbol, match_symbol) == 0)
               {
                 if (show_dups)
                 {
                   show_dups = false;
                   rtems_printf (printer, "  dups    :");
                 }
                 rtems_printf (printer, "%-*c%s (%s)\n",
                               indent, ' ', symbol, archive->name);
                 indent = 12;
 
                 if (match_archive->symbols.symbols != NULL)
                   match_archive->symbols.symbols[ms].entry |= SYM_DUPLICATE;
               }
 
               if (match_archive->symbols.symbols == NULL)
                 match_symbol += strlen (match_symbol) + 1;
             }
           }
 
           if (archive->symbols.symbols == NULL)
             symbol += strlen (symbol) + 1;
         }
 
         match_node = rtems_chain_next (match_node);
       }
 
       if (indent == 0)
         rtems_printf (printer, "\n");
     }
 
     node = rtems_chain_next (node);
   }
 
   regfree (&rege);
 
   node = rtems_chain_first (&rtl->archives.archives);
 
   while (!rtems_chain_is_tail (&rtl->archives.archives, node))
   {
     rtems_rtl_archive* archive = (rtems_rtl_archive*) node;
     if (archive->symbols.symbols != NULL)
     {
       size_t s;
       for (s = 0; s < archive->symbols.entries; ++s)
         archive->symbols.symbols[s].entry &= ~SYM_DUPLICATE;
     }
     node = rtems_chain_next (node);
   }
 
   rtems_rtl_unlock ();
 
   return 0;
 }
 
 int
 rtems_rtl_shell_call (const rtems_printer* printer, int argc, char* argv[])
 {
   #define CALL_ARG_COUNT (4)
 
   typedef void (*csig_none)(void);
   typedef void (*csig_argv)(int argc, const char* argv[]);
   typedef void (*csig_s)(const char* str);
   typedef void (*csig_u)(unsigned int i1, unsigned int i2, unsigned int i3, unsigned int i4);
   typedef void (*csig_i)(int i1, int i2, int i3, int i4);
 
   union {
     char         s[64 + 1];
     unsigned int u[CALL_ARG_COUNT];
     int          i[CALL_ARG_COUNT];
   } values = { 0 };
   bool               keep_locked = false;
   bool               args_s = false;
   bool               args_i = false;
   bool               args_u = false;
   ssize_t            label;
   rtems_rtl_data*    rtl;
   rtems_rtl_obj_sym* sym;
   rtems_rtl_obj*     obj;
 
 
   if (!rtems_rtl_check_opts (printer, "lsui", argc, argv))
     return 1;
 
   keep_locked = rtems_rtl_parse_opt ('l', argc, argv);
   args_s = rtems_rtl_parse_opt ('s', argc, argv);
   args_u = rtems_rtl_parse_opt ('u', argc, argv);
   args_i = rtems_rtl_parse_opt ('i', argc, argv);
 
   if (args_s || args_u || args_i)
   {
     int c = 0;
     c += args_s ? 1 : 0;
     c += args_u ? 1 : 0;
     c += args_i ? 1 : 0;
     if (c > 1)
     {
       rtems_printf (printer,
                     "error: too many options, only one -sul at a time\n");
       return 1;
     }
   }
 
   label = rtems_rtl_parse_arg_index (' ', NULL, argc, argv);
   if (label < 0)
   {
     rtems_printf (printer, "error: no symbol found on command line\n");
     return 1;
   }
 
   if ((label + 1) < argc)
   {
     if (args_s)
     {
       size_t arg;
       for (arg = label + 1; arg < argc; ++arg)
       {
         size_t o = strlen (values.s);
         if (strlen (argv[arg]) + 1 >= (sizeof (values.s) - o))
         {
           rtems_printf (printer, "error: string args too big\n");
           return 1;
         }
         if (o > 0)
           values.s[o++] = ' ';
         strcat (values.s, argv[arg]);
       }
     }
     else if (args_u || args_i)
     {
       size_t arg;
       size_t i;
       if (argc > (label + 1 + CALL_ARG_COUNT))
       {
         rtems_printf (printer, "error: too many args\n");
         return 1;
       }
       for (i = 0, arg = label + 1; arg < argc; ++arg)
       {
         if (args_u)
           values.u[i] = strtoul (argv[arg], 0, 0);
         else
           values.i[i] = strtol (argv[arg], 0, 0);
         ++i;
       }
     }
   }
 
   rtl = rtems_rtl_lock ();
   if (rtl == NULL)
   {
     rtems_printf (printer, "error: cannot lock the linker\n");
     return 1;
   }
 
   sym = rtems_rtl_symbol_global_find (argv[label]);
   if (sym == NULL)
   {
     rtems_rtl_unlock ();
     rtems_printf (printer, "error: symbol not found: %s\n", argv[label]);
     return 1;
   }
 
   obj = rtems_rtl_find_obj_with_symbol (sym);
   if (obj == NULL)
   {
     rtems_rtl_unlock ();
     rtems_printf (printer, "error: symbol obj not found: %s\n", argv[label]);
     return 1;
   }
 
   if (!rtems_rtl_obj_text_inside (obj, (const void*) sym->value))
   {
     rtems_rtl_unlock ();
     rtems_printf (printer, "error: symbol not in obj text: %s\n", argv[label]);
     return 1;
   }
 
   /*
    * Lock the object file while it is being called.
    */
   rtems_rtl_obj_inc_reference (obj);
 
   rtems_rtl_unlock ();
 
   if (args_s)
   {
     csig_s call = (csig_s) sym->value;
     call (values.s);
   }
   else if (args_u)
   {
     csig_u call = (csig_u) sym->value;
     call (values.u[0], values.u[1], values.u[2], values.u[3]);
   }
   else if (args_i)
   {
     csig_i call = (csig_i) sym->value;
     call (values.i[0], values.i[1], values.i[2], values.i[3]);
   }
   else
   {
     int cargc = argc - (label + 1);
     if (cargc == 0)
     {
       csig_none call = (csig_none) sym->value;
       call ();
     }
     else
     {
       csig_argv   call = (csig_argv) sym->value;
       const char* cargv = argv[label + 1];
       call (cargc, &cargv);
     }
   }
 
   if (!keep_locked)
   {
     rtl = rtems_rtl_lock ();
     if (rtl == NULL)
     {
       rtems_printf (printer, "error: cannot lock the linker\n");
       return 1;
     }
 
     obj = rtems_rtl_find_obj_with_symbol (sym);
     if (obj == NULL)
     {
       rtems_rtl_unlock ();
       rtems_printf (printer, "error: symbol obj not found: %s\n", argv[label]);
       return 1;
     }
 
     rtems_rtl_obj_dec_reference (obj);
 
     rtems_rtl_unlock ();
   }
 
   return 0;
 }
 
 static void
 rtems_rtl_shell_usage (const rtems_printer* printer, const char* arg)
 {
   rtems_printf (printer, "%s: Runtime Linker\n", arg);
   rtems_printf (printer, "  %s [-hl] <command>\n", arg);
   rtems_printf (printer, "   where:\n");
   rtems_printf (printer, "     command: A n RTL command. See -l for a list plus help.\n");
   rtems_printf (printer, "     -h:      This help\n");
   rtems_printf (printer, "     -l:      The command list.\n");
 }
 
 int
 rtems_rtl_shell_command (int argc, char* argv[])
 {
   const rtems_rtl_shell_cmd table[] =
   {
     { "status", rtems_rtl_shell_status,
       "Display the status of the RTL" },
     { "list", rtems_rtl_shell_list,
       "\tList the object files currently loaded" },
     { "sym", rtems_rtl_shell_sym,
       "\tDisplay the symbols, sym [<name>], sym -o <obj> [<name>]" },
     { "obj", rtems_rtl_shell_object,
       "\tDisplay the object details, obj <name>" },
     { "call", rtems_rtl_shell_call,
       "\tCall a symbol" },
     { "ar", rtems_rtl_shell_archive,
       "\tDisplay the archive details, ar [-ls] <name>" },
     { "trace", rtems_rtl_trace_shell_command,
       "\tControl the RTL trace flags, trace [-h]" }
   };
 
   rtems_printer printer;
   int           arg;
   int           t;
 
   rtems_print_printer_printf (&printer);
 
   for (arg = 1; arg < argc; arg++)
   {
     if (argv[arg][0] != '-')
       break;
 
     switch (argv[arg][1])
     {
       case 'h':
         rtems_rtl_shell_usage (&printer, argv[0]);
         return 0;
       case 'l':
         rtems_printf (&printer, "%s: commands are:\n", argv[0]);
         for (t = 0;
              t < (sizeof (table) / sizeof (const rtems_rtl_shell_cmd));
              ++t)
           rtems_printf (&printer, "  %s\t%s\n", table[t].name, table[t].help);
         return 0;
       default:
         rtems_printf (&printer, "error: unknown option: %s\n", argv[arg]);
         return 1;
     }
   }
 
   if ((argc - arg) < 1)
     rtems_printf (&printer, "error: you need to provide a command, try %s -h\n",
                   argv[0]);
   else
   {
     for (t = 0;
          t < (sizeof (table) / sizeof (const rtems_rtl_shell_cmd));
          ++t)
     {
       if (strncmp (argv[arg], table[t].name, strlen (argv[arg])) == 0)
         return table[t].handler (&printer, argc - 1, argv + 1);
     }
     rtems_printf (&printer, "error: command not found: %s (try -h)\n", argv[arg]);
   }
 
   return 1;
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team