Changeset 5025439 in rtems-tools for linkers


Ignore:
Timestamp:
Sep 21, 2014, 4:24:37 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
6ae559c
Parents:
149a8a6
Message:

rtems-tld: Add config options, fix void args, and SCore traces.

Location:
linkers
Files:
7 added
4 edited

Legend:

Unmodified
Added
Removed
  • linkers/rtems-tld.cpp

    r149a8a6 r5025439  
    6060  {
    6161    /**
     62     * Dump on error user option.
     63     */
     64    bool dump_on_error;
     65
     66    /**
    6267     * A container of arguments.
    6368     */
     
    8792       */
    8893      signature (const rld::config::record& record);
     94
     95      /**
     96       * Has the signature got a return value ?
     97       */
     98      bool has_ret () const;
     99
     100      /**
     101       * Has the signature got any arguments ?
     102       */
     103      bool has_args () const;
    89104
    90105      /**
     
    174189
    175190      /**
     191       * Process any script based options.
     192       */
     193      void load_options (const rld::config::section& section);
     194
     195      /**
    176196       * The the functions for the trace.
    177197       */
     
    207227    private:
    208228
    209       std::string  name;        /**< The name of the trace. */
    210       std::string  bsp;         /**< The BSP we are linking to. */
    211       rld::strings traces;      /**< The functions to trace. */
    212       functions    functions_;  /**< The functions that can be traced. */
    213       generator    generator_;  /**< The tracer's generator. */
     229      std::string  name;          /**< The name of the trace. */
     230      rld::strings traces;        /**< The functions to trace. */
     231      functions    functions_;    /**< The functions that can be traced. */
     232      generator    generator_;    /**< The tracer's generator. */
    214233    };
    215234
     
    318337
    319338      if (si.size () == 0)
    320         throw rld::error ("no return value", "signature: " + record.name);
     339        throw rld::error ("no return value", "signature: " + name);
    321340      if (si.size () == 1)
    322           throw rld::error ("no arguments", "signature: " + record.name);
     341          throw rld::error ("no arguments", "signature: " + name);
    323342
    324343      ret = si[0];
     
    327346    }
    328347
     348    bool
     349    signature::has_ret () const
     350    {
     351      /*
     352       * @todo Need to define as part of the function signature if ret
     353       *       processing is required.
     354       */
     355      return ret != "void";
     356    }
     357
     358    bool
     359    signature::has_args () const
     360    {
     361      if (args.empty ())
     362          return false;
     363      return ((args.size() == 1) && (args[0] == "void")) ? false : true;
     364    }
     365
    329366    const std::string
    330367    signature::decl (const std::string& prefix) const
    331368    {
    332369      std::string ds = ret + ' ' + prefix + name + '(';
    333       int         arg = 0;
    334       for (function_args::const_iterator ai = args.begin ();
    335            ai != args.end ();
    336            ++ai)
     370      if (has_args ())
     371      {
     372        int arg = 0;
     373        for (function_args::const_iterator ai = args.begin ();
     374             ai != args.end ();
     375             ++ai)
    337376        {
    338377          if (ai != args.begin ())
     
    340379          ds += (*ai) + " a" + rld::to_string (++arg);
    341380        }
     381      }
     382      else
     383      {
     384        ds += "void";
     385      }
    342386      ds += ')';
    343387      return ds;
     
    375419           ++sli)
    376420      {
    377         const rld::config::section& sig_sec = config.get_section (*sli);
    378         for (rld::config::records::const_iterator si = sig_sec.recs.begin ();
    379              si != sig_sec.recs.end ();
    380              ++si)
     421        rld::strings sigs;
     422        rld::split(sigs, *sli, ',');
     423
     424        for (rld::strings::const_iterator ssi = sigs.begin ();
     425             ssi != sigs.end ();
     426             ++ssi)
    381427        {
    382           signature sig (*si);
    383           signatures_[sig.name] = sig;
     428          const rld::config::section& sig_sec = config.get_section (*ssi);
     429          for (rld::config::records::const_iterator si = sig_sec.recs.begin ();
     430               si != sig_sec.recs.end ();
     431               ++si)
     432          {
     433            signature sig (*si);
     434            signatures_[sig.name] = sig;
     435          }
    384436        }
    385437      }
     
    504556       *
    505557       *  # name
    506        *  # bsp
    507        *  # trace
     558       *  # traces
    508559       *  # functions
    509560       */
    510561      const rld::config::section& section = config.get_section (tname);
    511562
     563      name = section.get_record_item ("name");
     564      load_options (section);
    512565      config.includes (section);
    513 
    514       name = section.get_record_item ("name");
    515 
    516566      load_functions (config, section);
    517567      load_traces (config, section);
     568    }
     569
     570    void
     571    tracer::load_options (const rld::config::section& section)
     572    {
     573      rld::strings ol;
     574      rld::config::parse_items (section, "options", ol, true);
     575
     576      for (rld::strings::const_iterator oli = ol.begin ();
     577           oli != ol.end ();
     578           ++oli)
     579      {
     580        rld::strings opts;
     581        rld::split(opts, *oli, ',');
     582        for (rld::strings::const_iterator oi = opts.begin ();
     583             oi != opts.end ();
     584             ++oi)
     585        {
     586          const std::string& opt = *oi;
     587          if (opt == "dump-on-error")
     588            dump_on_error = true;
     589          else if (opt == "verbose")
     590            rld::verbose_inc ();
     591          else if (opt == "prefix")
     592          {
     593            rld::strings prefix;
     594            rld::split (prefix, opt, '=');
     595            if (prefix.size () != 2)
     596              throw rld::error ("invalid option", "option: " + opt);
     597            rld::cc::set_exec_prefix (prefix[1]);
     598          }
     599          else if (opt == "cc")
     600          {
     601            rld::strings cc;
     602            rld::split (cc, opt, '=');
     603            if (cc.size () != 2)
     604              throw rld::error ("invalid option", "option: " + opt);
     605            rld::cc::set_cc (cc[1]);
     606          }
     607          else if (opt == "ld")
     608          {
     609            rld::strings ld;
     610            rld::split (ld, opt, '=');
     611            if (ld.size () != 2)
     612              throw rld::error ("invalid option", "option: " + opt);
     613            rld::cc::set_ld (ld[1]);
     614          }
     615          else if (opt == "cflags")
     616          {
     617            rld::strings cflags;
     618            rld::split (cflags, opt, '=');
     619            if (cflags.size () < 2)
     620              throw rld::error ("invalid option", "option: " + opt);
     621            cflags.erase (cflags.begin ());
     622            rld::cc::append_flags (rld::join (cflags, "="), rld::cc::ft_cflags);
     623          }
     624        }
     625      }
    518626    }
    519627
     
    544652
    545653      if (gens.size () > 1)
     654      {
     655        if (dump_on_error)
     656          dump (std::cout);
    546657        throw rld::error ("duplicate generators", "tracer: " + section.name);
     658      }
    547659
    548660      if (gens.size () == 0)
    549661      {
    550         gen =
    551           config.get_section ("default-generator").get_record_item ("generator");
     662        const rld::config::section& dg_section = config.get_section ("default-generator");
     663        gen = dg_section.get_record_item ("generator");
     664        config.includes (dg_section);
    552665      }
    553666      else
     
    588701      {
    589702        c.close ();
     703        if (dump_on_error)
     704          dump (std::cout);
    590705        throw;
    591706      }
     
    660775            c.write_line("{");
    661776
    662             /*
    663              * @todo Need to define as part of the function signature if ret
    664              *       processing is required.
    665              */
    666             bool has_ret = sig.ret != "void";
    667 
    668             if (has_ret)
     777            if (sig.has_ret ())
    669778              c.write_line(" " + sig.ret + " ret;");
    670779
     
    679788            }
    680789
    681             if (!generator_.arg_trace.empty ())
     790            if (sig.has_args ())
    682791            {
    683792              for (size_t a = 0; a < sig.args.size (); ++a)
     
    695804            l.clear ();
    696805
    697             if (has_ret)
     806            if (sig.has_ret ())
    698807              l = " ret =";
    699808
    700809            l += " __real_" + sig.name + '(';
    701             for (size_t a = 0; a < sig.args.size (); ++a)
     810            if (sig.has_args ())
    702811            {
    703               if (a)
    704                 l += ", ";
    705               l += "a" + rld::to_string ((int) (a + 1));
     812              for (size_t a = 0; a < sig.args.size (); ++a)
     813              {
     814                if (a)
     815                  l += ", ";
     816                l += "a" + rld::to_string ((int) (a + 1));
     817              }
    706818            }
    707819            l += ");";
     
    716828            }
    717829
    718             if (has_ret && !generator_.ret_trace.empty ())
     830            if (sig.has_ret () && !generator_.ret_trace.empty ())
    719831            {
    720832              std::string l = ' ' + generator_.ret_trace;
     
    745857    {
    746858      out << " Tracer: " << name << std::endl
    747           << "  BSP: " << bsp << std::endl
    748859          << "  Traces: " << traces.size () << std::endl;
    749860      for (rld::strings::const_iterator ti = traces.begin ();
     
    825936      {
    826937        err.output (rld::cc::get_cc (), std::cout);
     938        if (dump_on_error)
     939          dump (std::cout);
    827940        throw rld::error ("Compiler error", "compiling wrapper");
    828941      }
     
    9211034            << " -r path     : RTEMS path (also --rtems)" << std::endl
    9221035            << " -B bsp      : RTEMS arch/bsp (also --rtems-bsp)" << std::endl
    923             << " -W wrappe r : wrapper file name without ext (also --wrapper)" << std::endl
     1036            << " -W wrapper : wrapper file name without ext (also --wrapper)" << std::endl
    9241037            << " -C ini      : user configuration INI file (also --config)" << std::endl;
    9251038  ::exit (exit_code);
  • linkers/rtems.ini

    r149a8a6 r5025439  
    11;
    2 ; RTEMS API Trace Configurations
     2; RTEMS Trace Configurations
    33;
    4 [rtems-api]
    5 headers = rtems-api-headers
    6 defines = rtems-api-defines
    7 signatures = rtems-api-signatures
     4[includes]
     5include = rtems-api.ini
     6include = rtems-score.ini
    87
    9 [rtems-api-headers]
    10 header = "#include <rtems.h>"
    11 
    12 [rtems-api-defines]
    13 ; Currently empty
    14 
    15 [rtems-api-task]
    16 trace = rtems_task_create
    17 
    18 [rtems-api-signatures]
    19 rtems_task_create = rtems_status_code, rtems_name, rtems_task_priority, size_t, rtems_mode, rtems_attribute, rtems_id*
    20 
  • linkers/rtld-base.ini

    r149a8a6 r5025439  
    1111generator = printf-generator
    1212
    13 ;
    14 ; A printf generator prints to stdout the trace functions.
    15 ;
    16 [printf-generator]
    17 headers = printf-generator-headers
    18 entry-trace = "rtld_pg_printf_entry(@FUNC_NAME@, (void*) &@FUNC_LABEL@);"
    19 arg-trace = "rtld_pg_printf_arg(@ARG_NUM@, @ARG_TYPE@, @ARG_SIZE@, (void*) &@ARG_LABEL@);"
    20 exit-trace = "rtld_pg_printf_exit(@FUNC_NAME@, (void*) &@FUNC_LABEL@);"
    21 ret-trace = "rtld_pg_printf_ret(@RET_TYPE@, @RET_SIZE@, (void*) &@RET_LABEL@);"
    22 code = <<<CODE
    23 static inline void rtld_pg_printf_entry(const char* func_name,
    24                                         void*       func_addr)
    25 {
    26   printf (" >> %s (0x%08x)\n", func_name, func_addr);
    27 }
    28 static inline void rtld_pg_printf_arg(int         arg_num,
    29                                       const char* arg_type,
    30                                       int         arg_size,
    31                                       void*       arg)
    32 {
    33   const unsigned char* p = arg;
    34   int   i;
    35   printf (" %2d] %s(%d) = ", arg_num, arg_type, arg_size);
    36   for (i = 0; i < arg_size; ++i, ++p) printf ("%02x", (unsigned int) *p);
    37   printf ("\n");
    38 }
    39 static inline void rtld_pg_printf_exit(const char* func_name,
    40                                        void*       func_addr)
    41 {
    42   printf (" << %s (0x%08x)\n", func_name, func_addr);
    43 }
    44 static inline void rtld_pg_printf_ret(const char* ret_type,
    45                                       int         ret_size,
    46                                       void*       ret)
    47 {
    48   const unsigned char* p = ret;
    49   int   i;
    50   printf (" rt] %s(%d) = ", ret_type, ret_size);
    51   for (i = 0; i < ret_size; ++i, ++p) printf ("%02x", (unsigned int) *p);
    52   printf ("\n");
    53 }
    54 CODE
    55 
    56 [printf-generator-headers]
    57 header = "#include <stdio.h>"
    58 
    59 [printk-generator]
    60 headers = printk-generator-headers
    61 entry-trace = "rtld_pg_printk_entry(@FUNC_NAME@, (void*) &@FUNC_LABEL@);"
    62 arg-trace = "rtld_pg_printk_arg(@ARG_NUM@, @ARG_TYPE@, @ARG_SIZE@, (void*) &@ARG_LABEL@);"
    63 exit-trace = "rtld_pg_printk_exit(@FUNC_NAME@, (void*) &@FUNC_LABEL@);"
    64 ret-trace = "rtld_pg_printk_ret(@RET_TYPE@, @RET_SIZE@, (void*) &@RET_LABEL@);"
    65 code = <<<CODE
    66 static inline void rtld_pg_printk_entry(const char* func_name,
    67                                         void*       func_addr)
    68 {
    69   printk (" >> %s (0x%08x)\n", func_name, func_addr);
    70 }
    71 static inline void rtld_pg_printk_arg(int         arg_num,
    72                                      const char* arg_type,
    73                                      int         arg_size,
    74                                      void*       arg)
    75 {
    76   const unsigned char* p = arg;
    77   int   i;
    78   printk (" %2d] %s(%d) = ", arg_num, arg_type, arg_size);
    79   for (i = 0; i < arg_size; ++i, ++p) printk ("%02x", (unsigned int) *p);
    80   printk ("\n");
    81 }
    82 static inline void rtld_pg_printk_exit(const char* func_name,
    83                                        void*       func_addr)
    84 {
    85   printk (" << %s (0x%08x)\n", func_name, func_addr);
    86 }
    87 static inline void rtld_pg_printk_ret(const char* ret_type,
    88                                       int         ret_size,
    89                                       void*       ret)
    90 {
    91   const unsigned char* p = ret;
    92   int   i;
    93   printk (" rt] %s(%d) = ", ret_type, ret_size);
    94   for (i = 0; i < ret_size; ++i, ++p) printk ("%02x", (unsigned int) *p);
    95   printk ("\n");
    96 }
    97 CODE
    98 
    99 [printk-generator-headers]
    100 header = "#include <stdio.h>"
     13[includes]
     14include = rtld-print.ini
  • linkers/wscript

    r149a8a6 r5025439  
    8989                use = modules)
    9090    bld.install_files('${PREFIX}/share/rtems/trace-linker',
    91                       ['rtems.ini', 'rtld-base.ini'])
     91                      ['rtems.ini',
     92                       'rtems-api.ini',
     93                       'rtems-score.ini',
     94                       'rtems-score-object.ini',
     95                       'rtems-score-thread.ini',
     96                       'rtems-score-heap.ini',
     97                       'rtems-score-coremutex.ini',
     98                       'rtld-base.ini',
     99                       'rtld-print.ini'])
    92100
    93101    #
Note: See TracChangeset for help on using the changeset viewer.