Changeset b6d7f5f in rtems-tools for linkers


Ignore:
Timestamp:
Aug 3, 2014, 11:19:55 PM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
0a21024
Parents:
ea29902
Message:

rtems-tld: Add trace configuration support.

Extend the configuration support to provide the needed configuration
required to generate the C stub support.

Location:
linkers
Files:
1 added
1 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-config.cpp

    rea29902 rb6d7f5f  
    2626
    2727#include <rld-config.h>
    28 #include <rld.h>
    2928
    3029#include <SimpleIni.h>
     
    128127    }
    129128
     129
     130    void
     131    config::includes (const section& sec, bool must_exist)
     132    {
     133      bool have_includes = false;
     134
     135      try
     136      {
     137        const rld::config::record& rec = sec.get_record ("include");
     138
     139        have_includes = true;
     140
     141        /*
     142         * Include records are a path which we can just load.
     143         *
     144         * @todo Add a search path. See 'rld::files' for details. We can default
     145         *       the search path to the install $prefix of this tool and we can
     146         *       then provide a default set of function signatures for RTEMS
     147         *       APIs.
     148         */
     149
     150        for (rld::config::items::const_iterator ri = rec.items.begin ();
     151             ri != rec.items.end ();
     152             ++ri)
     153        {
     154          load ((*ri).text);
     155        }
     156      }
     157      catch (rld::error re)
     158      {
     159        /*
     160         * No include records, must be all inlined. If we have includes it must
     161         * be another error so throw it.
     162         */
     163        if (have_includes || (!have_includes && must_exist))
     164          throw;
     165      }
     166    }
     167
    130168    const section&
    131169    config::get_section (const std::string& name) const
  • linkers/rld-config.h

    rea29902 rb6d7f5f  
    3030#include <vector>
    3131
     32#include <rld.h>
     33
    3234namespace rld
    3335{
     
    6264      std::string name;   //< Name of the record.
    6365      items       items;  //< The record's items.
     66
     67      /**
     68       * Return true if there is only one item.
     69       */
     70      bool single () const {
     71        return items.size () == 1;
     72      }
    6473    };
    6574
     
    117126
    118127      /**
     128       * Process any include records in the section named. If the section has
     129       * any records named 'include' split the items and include the
     130       * configuration files.
     131       */
     132      void includes (const section& sec, bool must_exist = false);
     133
     134      /**
    119135       * Get the section and throw an error if not found.
    120136       */
     
    131147      sections secs;  /**< The sections loaded from configuration files */
    132148    };
     149
     150    /**
     151     * Return the items from a record.
     152     */
     153    template < typename T >
     154    void parse_items (const rld::config::record& record, T& items)
     155    {
     156      items.clear ();
     157      for (rld::config::items::const_iterator ii = record.items.begin ();
     158           ii != record.items.end ();
     159           ++ii)
     160      {
     161        rld::strings ss;
     162        rld::split (ss, (*ii).text, ',');
     163        std::copy (ss.begin (), ss.end (), std::back_inserter (items));
     164      }
     165    }
     166
     167    /**
     168     * Return the items from a record in a section. Optionally raise an error
     169     * if the record is not found and it is to be present.
     170     */
     171    template < typename T >
     172    void parse_items (const rld::config::section& section,
     173                      const std::string&          name,
     174                      T&                          items,
     175                      bool                        present = false)
     176    {
     177      items.clear ();
     178      const rld::config::record* rec = 0;
     179      try
     180      {
     181        const rld::config::record& rr = section.get_record (name);
     182        rec = &rr;
     183      }
     184      catch (rld::error re)
     185      {
     186        /*
     187         * Ignore the error if it does not need to exist.
     188         */
     189        if (present)
     190          throw rld::error ("not found", "record: " + section.name + name);
     191      }
     192
     193      if (rec)
     194        parse_items (*rec, items);
     195    }
     196
     197    /**
     198     * Return the items from a record in a section in the
     199     * configuration. Optionally raise an error if the section is not found and
     200     * it is to be present.
     201     */
     202    template < typename T >
     203    void parse_items (const rld::config::config& config,
     204                      const std::string&         section,
     205                      const std::string&         record,
     206                      T&                         items,
     207                      bool                       present = false)
     208    {
     209      items.clear ();
     210      const rld::config::section* sec = 0;
     211      try
     212      {
     213        const rld::config::section& sr = config.get_section (section);
     214        sec = &sr;
     215      }
     216      catch (rld::error re)
     217      {
     218        /*
     219         * Ignore the error if it does not need to exist.
     220         */
     221        if (present)
     222          throw rld::error ("not found", "section: " + section);
     223      }
     224
     225      if (sec)
     226        parse_items (*sec, record, items);
     227    }
    133228  }
    134229}
  • linkers/rld.h

    rea29902 rb6d7f5f  
    2626#define _RLD_H_
    2727
     28#include <algorithm>
     29#include <cctype>
     30#include <functional>
    2831#include <iostream>
     32#include <locale>
    2933#include <sstream>
    3034#include <string>
     
    7882{
    7983  /**
     84   * General error.
     85   */
     86  struct error
     87  {
     88    const std::string what;
     89    const std::string where;
     90
     91    error (const std::ostringstream& what, const std::string& where) :
     92      what (what.str ()), where (where) {
     93    }
     94
     95    error (const std::string& what, const std::string& where) :
     96      what (what), where (where) {
     97    }
     98  };
     99
     100  /**
     101   * A convenience macro to make where a file and line number.
     102   */
     103  #define rld_error_at(_what) \
     104    rld::error (_what, std::string (__FILE__) + ":" + to_string (__LINE__))
     105
     106  /**
    80107   * Convert a supported type to a string.
    81108   */
     
    89116
    90117  /**
    91    * General error.
    92    */
    93   struct error
    94   {
    95     const std::string what;
    96     const std::string where;
    97 
    98     error (const std::ostringstream& what, const std::string& where) :
    99       what (what.str ()), where (where) {
    100     }
    101 
    102     error (const std::string& what, const std::string& where) :
    103       what (what), where (where) {
    104     }
    105   };
    106 
    107   /**
    108    * A convenience macro to make where a file and line number.
    109    */
    110   #define rld_error_at(_what) \
    111     rld::error (_what, std::string (__FILE__) + ":" + to_string (__LINE__))
     118   * A container of strings.
     119   */
     120  typedef std::vector < std::string > strings;
     121
     122  /**
     123   * Trim from start.
     124   */
     125  inline std::string& ltrim (std::string &s)
     126  {
     127    s.erase (s.begin (),
     128            std::find_if (s.begin (), s.end (),
     129                         std::not1 (std::ptr_fun < int, int > (std::isspace))));
     130    return s;
     131  }
     132
     133  /**
     134   * Trim from end.
     135   */
     136  inline std::string& rtrim (std::string &s)
     137  {
     138    s.erase (std::find_if (s.rbegin (), s.rend (),
     139                           std::not1 (std::ptr_fun < int, int > (std::isspace))).base(),
     140             s.end());
     141    return s;
     142  }
     143
     144  /**
     145   * Trim from both ends.
     146   */
     147  inline std::string& trim (std::string &s)
     148  {
     149    return ltrim (rtrim (s));
     150  }
     151
     152  /**
     153   * Split the string in a contain of strings based on the the
     154   * delimiter. Optionally trim any white space or include empty string.
     155   *
     156   * @todo The split should optionally honour string quoting.
     157   */
     158  inline strings& split (strings&           se,
     159                         const std::string& s,
     160                         char               delimiter,
     161                         bool               strip_quotes = true,
     162                         bool               strip_whitespace = true,
     163                         bool               empty = false)
     164  {
     165    std::stringstream ss(s);
     166    std::string       e;
     167    se.clear ();
     168    while (std::getline (ss, e, delimiter))
     169    {
     170      if (strip_whitespace)
     171        trim (e);
     172      if (strip_quotes)
     173      {
     174        if ((e.front () == '"') || (e.front () == '\''))
     175        {
     176          if (e.front () != e.back ())
     177            throw rld::error ("invalid quoting", "string: " + s);
     178          e = e.substr (1, e.length () - 1);
     179        }
     180      }
     181      if (empty || !e.empty ())
     182      {
     183        se.push_back (e);
     184      }
     185    }
     186    return se;
     187  }
     188
     189  /**
     190   * Join the strings together with the separator.
     191   */
     192  inline std::string& join (const strings&     ss,
     193                            const std::string& separator,
     194                            std::string&       s)
     195  {
     196    for (strings::const_iterator ssi = ss.begin ();
     197         ssi != ss.end ();
     198         ++ssi)
     199    {
     200      s += *ssi;
     201      if ((ssi != ss.begin ()) && (ssi != ss.end ()))
     202        s += separator;
     203    }
     204    return s;
     205  }
    112206
    113207  /**
  • linkers/rtems-tld.cpp

    rea29902 rb6d7f5f  
    5353namespace rld
    5454{
    55 
    5655  /**
    57    * Trim from start.
     56   * RTEMS Trace Linker.
    5857   */
    59   inline std::string &ltrim (std::string &s)
     58  namespace trace
    6059  {
    61     s.erase (s.begin (),
    62             std::find_if (s.begin (), s.end (),
    63                          std::not1 (std::ptr_fun < int, int > (std::isspace))));
    64     return s;
    65   }
    66 
    67   /**
    68    * Trim from end.
    69    */
    70   inline std::string &rtrim (std::string &s)
    71   {
    72     s.erase (std::find_if (s.rbegin (), s.rend (),
    73                            std::not1 (std::ptr_fun < int, int > (std::isspace))).base(),
    74              s.end());
    75     return s;
    76   }
    77 
    78   /**
    79    * Trim from both ends.
    80    */
    81   inline std::string &trim (std::string &s)
    82   {
    83     return ltrim (rtrim (s));
    84   }
    85 }
    86 
    87 /**
    88  * RTEMS Trace Linker.
    89  */
    90 namespace trace
    91 {
    92   /**
    93    * A container of arguments.
    94    */
    95   typedef std::vector < std::string > function_args;
    96 
    97   /**
    98    * The return value.
    99    */
    100   typedef std::string function_return;
    101 
    102   /**
    103    * A function's signature.
    104    */
    105   struct function_sig
    106   {
    107     std::string     name; /**< The function's name. */
    108     function_args   args; /**< The function's list of arguments. */
    109     function_return ret;  /**< The fuctions return value. */
    110   };
    111 
    112   /**
    113    * A container of function signatures.
    114    */
    115   typedef std::map < std::string, function_sig > function_sigs;
    116 
    117   /**
    118    * Trace Linker.
    119    */
    120   class linker
    121   {
    122   public:
    123     linker ();
    124 
    125     /**
    126      * Load the user's configuration.
    127      */
    128     void load_config (const std::string& path);
    129 
    130     /**
    131      * Dump the linker status.
    132      */
    133     void dump (std::ostream& out);
    134 
    135   private:
    136 
    137     rld::config::config config; /**< User configuration. */
    138     function_sigs       sigs;   /**< Function signatures. */
    139   };
    140 
    141   linker::linker ()
    142   {
    143   }
    144 
    145   void
    146   linker::load_config (const std::string& path)
    147   {
    148     config.clear ();
    149     config.load (path);
    150 
    151     /*
    152      * The configuration must contain a "trace" section. This is the top level
    153      * configuration and must the following fields:
    154      *
    155      *   # < add here >
    156      *
    157      * The 'trace" section may optionally contain a number of 'include' records
    158      * and these configuration files are included.
    159      */
    160 
    161     const rld::config::section& tsec = config.get_section ("trace");
    162     bool                        have_includes = false;
    163 
    164     try
    165     {
    166       const rld::config::record& irec = tsec.get_record ("include");
    167 
    168       have_includes = true;
    169 
    170       /*
    171        * Include records are a path which we can just load.
    172        *
    173        * @todo Add a search path. See 'rld::files' for details. We can default
    174        *       the search path to the install $prefix of this tool and we can
    175        *       then provide a default set of function signatures for RTEMS
    176        *       APIs.
    177        */
    178 
    179       for (rld::config::items::const_iterator ii = irec.items.begin ();
    180            ii != irec.items.end ();
    181            ++ii)
    182       {
    183         config.load ((*ii).text);
    184       }
    185     }
    186     catch (rld::error re)
    187     {
    188       /*
    189        * No include records, must be all inlined. If we have includes it must
    190        * be another error so throw it.
    191        */
    192       if (have_includes)
    193         throw;
    194     }
    195 
    196     /*
    197      * Get the function signatures from the configuration and load them into
    198      * the sig map.
    199      */
    200 
    201     const rld::config::section& fssec = config.get_section ("function-signatures");
    202 
    203     for (rld::config::records::const_iterator ri = fssec.recs.begin ();
    204          ri != fssec.recs.end ();
    205          ++ri)
     60    /**
     61     * A container of arguments.
     62     */
     63    typedef std::vector < std::string > function_args;
     64
     65    /**
     66     * The return value.
     67     */
     68    typedef std::string function_return;
     69
     70    /**
     71     * A function's signature.
     72     */
     73    struct function_sig
     74    {
     75      std::string     name; /**< The function's name. */
     76      function_args   args; /**< The function's list of arguments. */
     77      function_return ret;  /**< The fuctions return value. */
     78
     79      /**
     80       * The default constructor.
     81       */
     82      function_sig ();
     83
     84      /**
     85       * Construct the signature loading it from the configuration.
     86       */
     87      function_sig (const rld::config::record& record);
     88
     89      /**
     90       * Copy constructor.
     91       */
     92      function_sig (const function_sig& orig);
     93
     94      /**
     95       * Return the function's declaration.
     96       */
     97      const std::string decl () const;
     98    };
     99
     100    /**
     101     * A container of function signatures.
     102     */
     103    typedef std::map < std::string, function_sig > function_sigs;
     104
     105    /**
     106     * Wrappers hold the data used when wrapping the code. It knows how to wrap
     107     * a specific trace function. Wrapping a function requires specific defines
     108     * and header files.
     109     */
     110    struct wrapper
     111    {
     112      std::string   name;     /**< The name of this wrapper. */
     113      rld::strings  headers;  /**< Include statements. */
     114      rld::strings  defines;  /**< Define statements. */
     115      function_sigs sigs;     /**< The functions this wrapper wraps. */
     116
     117      /**
     118       * Load the wrapper.
     119       */
     120      wrapper (const std::string&   name,
     121               rld::config::config& config);
     122
     123      /**
     124       * Dump the wrapper.
     125       */
     126      void dump (std::ostream& out) const;
     127    };
     128
     129    /**
     130     * A container of wrappers. The order is the order we wrap.
     131     */
     132    typedef std::vector < wrapper > wrappers;
     133
     134    /**
     135     * Tracer.
     136     */
     137    class tracer
     138    {
     139    public:
     140      tracer ();
     141
     142      /**
     143       * Load the user's configuration.
     144       */
     145      void load (rld::config::config& config,
     146                 const std::string&   section);
     147
     148      /**
     149       * Dump the wrapper.
     150       */
     151      void dump (std::ostream& out) const;
     152
     153    private:
     154
     155      std::string  name;     /**< The name of the trace. */
     156      std::string  bsp;      /**< The BSP we are linking to. */
     157      rld::strings trace;    /**< The functions to trace. */
     158      wrappers     wrappers; /**< Wrappers wrap trace functions. */
     159    };
     160
     161    /**
     162     * Trace Linker.
     163     */
     164    class linker
     165    {
     166    public:
     167      linker ();
     168
     169      /**
     170       * Load the user's configuration.
     171       */
     172      void load_config (const std::string& path,
     173                        const std::string& trace);
     174
     175      /**
     176       * Generate the C file.
     177       */
     178      void generate_c ();
     179
     180      /**
     181       * Dump the linker.
     182       */
     183      void dump (std::ostream& out) const;
     184
     185    private:
     186
     187      rld::config::config config;   /**< User configuration. */
     188      tracer              tracer;   /**< The tracer */
     189    };
     190
     191    function_sig::function_sig ()
     192    {
     193    }
     194
     195    function_sig::function_sig (const rld::config::record& record)
    206196    {
    207197      /*
    208198       * There can only be one function signature in the configuration.
    209199       */
    210       if ((*ri).items.size () > 1)
    211         throw rld::error ("duplicate", "function signature: " + (*ri).name);
    212 
    213       function_sig sig;
    214       sig.name = (*ri).name;
     200      if (!record.single ())
     201        throw rld::error ("duplicate", "function signature: " + record.name);
     202
     203      name = record.name;
    215204
    216205      /*
     
    219208       * return value or arguments.
    220209       */
    221       rld::config::items::const_iterator ii = (*ri).items.begin ();
    222       std::stringstream                  ts((*ii).text);
    223       std::string                        arg;
    224       while (std::getline (ts, arg, ','))
    225       {
    226         rld::trim (arg);
    227         if (!arg.empty ())
     210      rld::strings si;
     211      rld::config::parse_items (record, si);
     212
     213      if (si.size () == 0)
     214        throw rld::error ("no return value", "function signature: " + record.name);
     215      if (si.size () == 1)
     216          throw rld::error ("no arguments", "function signature: " + record.name);
     217
     218      ret = si[0];
     219      args.resize (si.size () - 1);
     220      std::copy (si.begin ()  + 1, si.end (), args.begin ());
     221    }
     222
     223    function_sig::function_sig (const function_sig& orig)
     224      : name (orig.name),
     225        args (orig.args),
     226        ret (orig.ret)
     227    {
     228    }
     229
     230    const std::string
     231    function_sig::decl () const
     232    {
     233      std::string ds = ret + ' ' + name + '(';
     234      int         arg = 0;
     235      for (function_args::const_iterator ai = args.begin ();
     236           ai != args.end ();
     237           ++ai)
    228238        {
    229           if (sig.ret.empty ())
    230             sig.ret = arg;
    231           else
    232             sig.args.push_back(arg);
     239          if (ai != args.begin ())
     240            ds += ", ";
     241          ds += (*ai) + " a" + rld::to_string (++arg);
    233242        }
    234       }
    235 
    236       if (sig.ret.empty ())
    237         throw rld::error ("no return value", "function signature: " + (*ri).name);
    238 
    239       if (sig.args.empty ())
    240         throw rld::error ("no arguments", "function signature: " + (*ri).name);
    241 
    242       sigs[sig.name] = sig;
    243     }
    244   }
    245 
    246   void
    247   linker::dump (std::ostream& out)
    248   {
    249     const rld::config::paths& cpaths = config.get_paths ();
    250     out << "Configuration Files: " << cpaths.size () << std::endl;
    251     for (rld::config::paths::const_iterator pi = cpaths.begin ();
    252          pi != cpaths.end ();
    253          ++pi)
    254     {
    255       out << " " << (*pi) << std::endl;
    256     }
    257 
    258     out << std::endl
    259         << "Function Signatures: " << sigs.size () << std::endl;
    260     for (function_sigs::const_iterator si = sigs.begin ();
    261          si != sigs.end ();
    262          ++si)
    263     {
    264       const function_sig& sig = (*si).second;
    265       out << " " << sig.name << ": " << sig.ret << ' ' << sig.name << '(';
    266       for (function_args::const_iterator fai = sig.args.begin ();
    267            fai != sig.args.end ();
    268            ++fai)
    269       {
    270         if (fai != sig.args.begin ())
    271           out << ", ";
    272         out << (*fai);
    273       }
    274       out << ");" << std::endl;
     243      ds += ')';
     244
     245      return ds;
     246    }
     247
     248    wrapper::wrapper (const std::string&   name,
     249                      rld::config::config& config)
     250      : name (name)
     251    {
     252      /*
     253       * A wrapper section optionally contain one or more records of:
     254       *
     255       * # header    A list of include string that are single or double quoted.
     256       * # define    A list of define string that are single or double quoted.
     257       * # signature A list of section names of function signatures.
     258       *
     259       * @note The quoting and list spliting is a little weak because a delimiter
     260       *       in a quote should not be seen as a delimiter.
     261       */
     262      const rld::config::section& section = config.get_section (name);
     263
     264      rld::strings sig_list;
     265
     266      rld::config::parse_items (section, "header", headers);
     267      rld::config::parse_items (section, "define", defines);
     268      rld::config::parse_items (section, "signature", sig_list);
     269
     270      for (rld::strings::const_iterator sli = sig_list.begin ();
     271           sli != sig_list.end ();
     272           ++sli)
     273      {
     274        const rld::config::section& sig_sec = config.get_section (*sli);
     275        for (rld::config::records::const_iterator ri = sig_sec.recs.begin ();
     276             ri != sig_sec.recs.end ();
     277             ++ri)
     278        {
     279          function_sig func (*ri);
     280          sigs[func.name] = func;
     281        }
     282      }
     283    }
     284
     285    void
     286    wrapper::dump (std::ostream& out) const
     287    {
     288      out << "  Wrapper: " << name << std::endl
     289          << "   Headers: " << headers.size () << std::endl;
     290      for (rld::strings::const_iterator hi = headers.begin ();
     291           hi != headers.end ();
     292           ++hi)
     293      {
     294        out << "    " << (*hi) << std::endl;
     295      }
     296      out << "   Defines: " << defines.size () << std::endl;
     297      for (rld::strings::const_iterator di = defines.begin ();
     298           di != defines.end ();
     299           ++di)
     300      {
     301        out << "    " << (*di) << std::endl;
     302      }
     303      out << "   Function Signatures: " << sigs.size () << std::endl;
     304      for (function_sigs::const_iterator si = sigs.begin ();
     305           si != sigs.end ();
     306           ++si)
     307      {
     308        const function_sig& sig = (*si).second;
     309        out << "    " << sig.name << ": " << sig.decl () << ';' << std::endl;
     310      }
     311    }
     312
     313    tracer::tracer ()
     314    {
     315    }
     316
     317    void
     318    tracer::load (rld::config::config& config,
     319                  const std::string&   section)
     320    {
     321      /*
     322       * The configuration must contain a "trace" section. This is the top level
     323       * configuration and must the following fields:
     324       *
     325       *  # name    The name of trace being linked.
     326       *  # trace   The list of sections containing functions to trace.
     327       *  # wrapper The list of sections containing wrapping details.
     328       *
     329       * The following record are optional:
     330       *
     331       *  # bdp     The BSP the executable is for. Can be supplied on the command
     332       *            line.
     333       *  # include Include the INI file.
     334       *
     335       * The following will throw an error is the section or records are not
     336       * found.
     337       */
     338      rld::strings ss;
     339
     340      const rld::config::section& tsec = config.get_section (section);
     341      const rld::config::record&  nrec = tsec.get_record ("name");
     342      const rld::config::record&  brec = tsec.get_record ("bsp");
     343      const rld::config::record&  trec = tsec.get_record ("trace");
     344      const rld::config::record&  wrec = tsec.get_record ("wrapper");
     345
     346      if (!nrec.single ())
     347        throw rld::error ("duplicate", "trace names");
     348      name = nrec.items[0].text;
     349
     350      if (!brec.single ())
     351        throw rld::error ("duplicate", "trace bsp");
     352      bsp = brec.items[0].text;
     353
     354      /*
     355       * Include any files.
     356       */
     357      config.includes (tsec);
     358
     359      /*
     360       * Load the wrappers.
     361       */
     362      rld::strings wi;
     363      rld::config::parse_items (wrec, wi);
     364      for (rld::strings::const_iterator wsi = wi.begin ();
     365           wsi != wi.end ();
     366           ++wsi)
     367      {
     368        wrappers.push_back (wrapper (*wsi, config));
     369      }
     370
     371      /*
     372       * Load the trace functions.
     373       */
     374      rld::strings ti;
     375      rld::config::parse_items (trec, ti);
     376      for (rld::strings::const_iterator tsi = ti.begin ();
     377           tsi != ti.end ();
     378           ++tsi)
     379      {
     380        rld::config::parse_items (config, *tsi, "trace", trace, true);
     381      }
     382
     383    }
     384
     385    void
     386    tracer::dump (std::ostream& out) const
     387    {
     388      out << " Tracer: " << name << std::endl
     389          << "  BSP: " << bsp << std::endl;
     390      for (wrappers::const_iterator wi = wrappers.begin ();
     391           wi != wrappers.end ();
     392           ++wi)
     393      {
     394        (*wi).dump (out);
     395      }
     396    }
     397
     398    linker::linker ()
     399    {
     400    }
     401
     402    void
     403    linker::load_config (const std::string& path,
     404                         const std::string& trace)
     405    {
     406      config.clear ();
     407      config.load (path);
     408      tracer.load (config, trace);
     409    }
     410
     411    void
     412    linker::dump (std::ostream& out) const
     413    {
     414      const rld::config::paths& cpaths = config.get_paths ();
     415      out << "RTEMS Trace Linker" << std::endl
     416          << " Configuration Files: " << cpaths.size () << std::endl;
     417      for (rld::config::paths::const_iterator pi = cpaths.begin ();
     418           pi != cpaths.end ();
     419           ++pi)
     420      {
     421        out << "  " << (*pi) << std::endl;
     422      }
     423
     424      tracer.dump (out);
    275425    }
    276426  }
     
    354504  try
    355505  {
    356     trace::linker linker;
    357     std::string   ld_cmd;
    358     std::string   configuration;
    359     bool          exec_prefix_set = false;
     506    rld::trace::linker linker;
     507    std::string        ld_cmd;
     508    std::string        configuration;
     509    std::string        trace = "tracer";
     510    bool               exec_prefix_set = false;
    360511#if HAVE_WARNINGS
    361     bool          warnings = false;
     512    bool               warnings = false;
    362513#endif
    363514
     
    440591    try
    441592    {
    442       linker.load_config (configuration);
     593      linker.load_config (configuration, trace);
    443594      linker.dump (std::cout);
    444595    }
  • linkers/test-trace.ini

    rea29902 rb6d7f5f  
    44; We must provide a top level trace section.
    55;
    6 [trace]
     6[tracer]
    77;
    88; Name of the trace.
     
    1010name = RTEMS Trace Linker Test
    1111;
    12 ; Include the function signatures.
     12; The BSP.
    1313;
    14 include = test-fsigs.ini
     14bsp = sis
     15;
     16; Functions to trace.
     17;
     18trace = test-trace, test-trace-funcs, rtems-api-task
     19;
     20; Define the wrapper.
     21;
     22wrapper = test-trace, rtems-api
     23;
     24; Include RTEMS Trace support.
     25;
     26include = rtems.ini
     27
     28;
     29; User application trace example.
     30;
     31[test-trace-funcs]
     32trace = test_trace_1, test_trace_2
     33
     34[test-trace]
     35trace = test_trace_3
     36header = '#include "test-trace.h"'
     37define = "#define TEST_TRACE 1"
     38signature = test-signatures
     39
     40[test-signatures]
     41test_trace_1 = void, int
     42test_trace_2 = test_type_2, test_type_1
     43test_trace_3 = float, float*
Note: See TracChangeset for help on using the changeset viewer.