Changeset 097f1fd in rtems-tools


Ignore:
Timestamp:
Aug 7, 2014, 8:15:06 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
e5165d2
Parents:
4fd758e
Message:

rtms-tld: Refactor the code to match a better configuration format.

Location:
linkers
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-config.cpp

    r4fd758e r097f1fd  
    6161    {
    6262      const record& rec = get_record (rec_name);
    63       if (rec.items.size () != 1)
     63      if (rec.items_.size () != 1)
    6464        throw rld::error ("duplicate", "record item: " + name + '/' + rec_name);
    65       return rec.items[0].text;
     65      return rec.items_[0].text;
    6666    }
    6767
     
    7171      const record& rec = get_record (rec_name);
    7272      items.clear ();
    73       for (rld::config::items::const_iterator ii = rec.items.begin ();
    74            ii != rec.items.end ();
     73      for (rld::config::items::const_iterator ii = rec.items_.begin ();
     74           ii != rec.items_.end ();
    7575           ++ii)
    7676      {
     
    101101        throw rld::error (::strerror (errno), "load config: " + path);
    102102
    103       paths.push_back (path);
     103      paths_.push_back (path);
    104104
    105105      /*
     
    139139               ++vi)
    140140          {
    141             rec.items.push_back (item ((*vi).pItem));
     141            rec.items_.push_back (item ((*vi).pItem));
    142142          }
    143143
     
    206206    config::get_paths () const
    207207    {
    208       return paths;
     208      return paths_;
    209209    }
    210210  }
  • linkers/rld-config.h

    r4fd758e r097f1fd  
    6363    {
    6464      std::string name;   //< Name of the record.
    65       items       items; //< The record's items.
     65      items       items_; //< The record's items.
    6666
    6767      /**
     
    6969       */
    7070      bool single () const {
    71         return items.size () == 1;
     71        return items_.size () == 1;
    7272      }
    7373    };
     
    101101       * Return the list of items in a record in a strings container.
    102102       */
    103       void get_record_items (const std::string& name, rld::strings& items) const;
     103      void get_record_items (const std::string& name, rld::strings& items_) const;
    104104    };
    105105
     
    155155    private:
    156156
    157       paths    paths; /**< The path's of the loaded files. */
    158       sections secs;  /**< The sections loaded from configuration files */
     157      paths    paths_; /**< The path's of the loaded files. */
     158      sections secs;   /**< The sections loaded from configuration files */
    159159    };
    160160
     
    163163     */
    164164    template < typename T >
    165     void parse_items (const rld::config::record& record, T& items)
    166     {
    167       items.clear ();
    168       for (rld::config::items::const_iterator ii = record.items.begin ();
    169            ii != record.items.end ();
     165    void parse_items (const rld::config::record& record,
     166                      T&                         items_,
     167                      bool                       clear = true,
     168                      bool                       split = true)
     169    {
     170      if (clear)
     171        items_.clear ();
     172      for (rld::config::items::const_iterator ii = record.items_.begin ();
     173           ii != record.items_.end ();
    170174           ++ii)
    171175      {
    172         rld::strings ss;
    173         rld::split (ss, (*ii).text, ',');
    174         std::copy (ss.begin (), ss.end (), std::back_inserter (items));
     176        if (split)
     177        {
     178          rld::strings ss;
     179          rld::split (ss, (*ii).text, ',');
     180          std::copy (ss.begin (), ss.end (), std::back_inserter (items_));
     181        }
     182        else
     183        {
     184          items_.push_back ((*ii).text);
     185        }
    175186      }
    176187    }
     
    183194    void parse_items (const rld::config::section& section,
    184195                      const std::string&          name,
    185                       T&                          items,
    186                       bool                        present = false)
    187     {
    188       items.clear ();
     196                      T&                          items_,
     197                      bool                        present = false,
     198                      bool                        clear = true,
     199                      bool                        split = true)
     200    {
     201      if (clear)
     202        items_.clear ();
    189203      const rld::config::record* rec = 0;
    190204      try
     
    203217
    204218      if (rec)
    205         parse_items (*rec, items);
     219        parse_items (*rec, items_, clear, split);
    206220    }
    207221
     
    215229                      const std::string&         section,
    216230                      const std::string&         record,
    217                       T&                         items,
     231                      T&                         items_,
    218232                      bool                       present = false)
    219233    {
    220       items.clear ();
     234      items_.clear ();
    221235      const rld::config::section* sec = 0;
    222236      try
     
    235249
    236250      if (sec)
    237         parse_items (*sec, record, items);
     251        parse_items (*sec, record, items_);
    238252    }
    239253  }
  • linkers/rld-rap.cpp

    r4fd758e r097f1fd  
    151151     * value can be adjusted by the offset of the section in the RAP section.
    152152     */
    153     typedef std::map < const int, osection > osections;
     153    typedef std::map < int, osection > osections;
    154154
    155155    /**
  • linkers/rld.h

    r4fd758e r097f1fd  
    157157  inline std::string dequote (const std::string& s)
    158158  {
    159     if ((s.front () == '"') || (s.front () == '\''))
    160     {
    161       if (s.front () != s.back ())
    162         throw rld::error ("invalid quoting", "string: " + s);
    163       return s.substr (1, s.length () - (1 + 1));
     159    if (!s.empty ())
     160    {
     161      char front = s[0];
     162      char back = s[s.length () - 1];
     163      if ((front == '"') || (front == '\''))
     164      {
     165        if (front != back)
     166          throw rld::error ("invalid quoting", "string: " + s);
     167        return s.substr (1, s.length () - (1 + 1));
     168      }
    164169    }
    165170    return s;
  • linkers/rtems-tld.cpp

    r4fd758e r097f1fd  
    7171     * A function's signature.
    7272     */
    73     struct function_sig
     73    struct signature
    7474    {
    7575      std::string     name; /**< The function's name. */
     
    8080       * The default constructor.
    8181       */
    82       function_sig ();
     82      signature ();
    8383
    8484      /**
    8585       * Construct the signature loading it from the configuration.
    8686       */
    87       function_sig (const rld::config::record& record);
    88 
    89       /**
    90        * Copy constructor.
    91        */
    92       function_sig (const function_sig& orig);
     87      signature (const rld::config::record& record);
    9388
    9489      /**
     
    9994
    10095    /**
    101      * A container of function signatures.
    102      */
    103     typedef std::map < std::string, function_sig > function_sigs;
     96     * A container of signatures.
     97     */
     98    typedef std::map < std::string, signature > signatures;
    10499
    105100    /**
    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       std::string   map_sym_prefix;  /**< Mapping symbol prefix. */
    116       std::string   arg_trace;       /**< Code template to trace an argument. */
    117       std::string   ret_trace;       /**< Code template to trace the return value. */
    118       rld::strings& code;            /**< Code block inserted before the trace code. */
    119       function_sigs sigs;            /**< The functions this wrapper wraps. */
    120 
    121       /**
    122        * Load the wrapper.
    123        */
    124       wrapper (const std::string&   name,
    125                rld::strings&        code,
    126                rld::config::config& config);
    127 
    128       /**
    129        * Parse the generator.
    130        */
    131       void parse_generator (rld::config::config& config,
    132                             const rld::config::section& section);
    133 
    134       /**
    135        * Recursive parser for strings.
    136        */
    137       void parse (rld::config::config&        config,
    138                   const rld::config::section& section,
    139                   const std::string&          sec_name,
    140                   const std::string&          rec_name,
    141                   rld::strings&               items,
    142                   int                         depth = 0);
    143 
    144       /**
    145        * Dump the wrapper.
     101     * A function is list of function signatures headers and defines that allow
     102     * a function to be wrapped.
     103     */
     104    struct function
     105    {
     106      std::string  name;        /**< The name of this wrapper. */
     107      rld::strings headers;     /**< Include statements. */
     108      rld::strings defines;     /**< Define statements. */
     109      signatures   signatures_; /**< Signatures in this function. */
     110
     111      /**
     112       * Load the function.
     113       */
     114      function (rld::config::config& config,
     115                const std::string&   name);
     116
     117      /**
     118       * Dump the function.
    146119       */
    147120      void dump (std::ostream& out) const;
     
    149122
    150123    /**
    151      * A container of wrappers. The order is the order we wrap.
    152      */
    153     typedef std::vector < wrapper > wrappers;
     124     * A container of functions.
     125     */
     126    typedef std::vector < function > functions;
     127
     128    /**
     129     * A generator and that contains the functions used to trace arguments and
     130     * return values. It also provides the implementation of those functions.
     131     */
     132    struct generator
     133    {
     134      std::string  name;            /**< The name of this wrapper. */
     135      rld::strings headers;         /**< Include statements. */
     136      rld::strings defines;         /**< Define statements. */
     137      std::string  map_sym_prefix;  /**< Mapping symbol prefix. */
     138      std::string  arg_trace;       /**< Code template to trace an argument. */
     139      std::string  ret_trace;       /**< Code template to trace the return value. */
     140      rld::strings code;            /**< Code block inserted before the trace code. */
     141
     142      /**
     143       * Default constructor.
     144       */
     145      generator ();
     146
     147      /**
     148       * Load the generator.
     149       */
     150      generator (rld::config::config& config,
     151                 const std::string&   name);
     152
     153      /**
     154       * Dump the generator.
     155       */
     156      void dump (std::ostream& out) const;
     157    };
    154158
    155159    /**
     
    168172
    169173      /**
     174       * The the functions for the trace.
     175       */
     176      void load_functions (rld::config::config&        config,
     177                           const rld::config::section& section);
     178
     179      /**
     180       * The the traces for the tracer.
     181       */
     182      void load_traces (rld::config::config&        config,
     183                        const rld::config::section& section);
     184
     185      /**
    170186       * Generate the wrapper object file.
    171187       */
     
    184200    private:
    185201
    186       std::string  name;      /**< The name of the trace. */
    187       std::string  bsp;       /**< The BSP we are linking to. */
    188       rld::strings traces;    /**< The functions to trace. */
    189       wrappers     wrappers;  /**< Wrappers wrap trace functions. */
    190       rld::strings code;      /**< Wrapper code records. Must be unique. */
     202      std::string  name;       /**< The name of the trace. */
     203      std::string  bsp;        /**< The BSP we are linking to. */
     204      rld::strings traces;     /**< The functions to trace. */
     205      functions    functions_; /**< The functions that can be traced. */
     206      generator    generator_; /**< The tracer's generator. */
    191207    };
    192208
     
    218234
    219235      rld::config::config config;   /**< User configuration. */
    220       tracer              tracer;   /**< The tracer */
     236      tracer              tracer_;  /**< The tracer */
    221237    };
    222238
    223     function_sig::function_sig ()
    224     {
    225     }
    226 
    227     function_sig::function_sig (const rld::config::record& record)
     239    /**
     240     * Recursive parser for strings.
     241     */
     242    void
     243    parse (rld::config::config&        config,
     244           const rld::config::section& section,
     245           const std::string&          sec_name,
     246           const std::string&          rec_name,
     247           rld::strings&               items,
     248           bool                        split = true,
     249           int                         depth = 0)
     250    {
     251      if (depth > 32)
     252        throw rld::error ("too deep", "parsing: " + sec_name + '/' + rec_name);
     253
     254      rld::config::parse_items (section, rec_name, items, false, false, split);
     255
     256      rld::strings sl;
     257
     258      rld::config::parse_items (section, sec_name, sl);
     259
     260      for (rld::strings::iterator sli = sl.begin ();
     261           sli != sl.end ();
     262           ++sli)
     263      {
     264        const rld::config::section& sec = config.get_section (*sli);
     265        parse (config, sec, sec_name, rec_name, items, split, depth + 1);
     266      }
     267
     268      /*
     269       * Make the items unique.
     270       */
     271      rld::strings::iterator ii;
     272      ii = std::unique (items.begin (), items.end ());
     273      items.resize (std::distance (items.begin (), ii));
     274    }
     275
     276    signature::signature ()
     277    {
     278    }
     279
     280    signature::signature (const rld::config::record& record)
    228281    {
    229282      /*
     
    231284       */
    232285      if (!record.single ())
    233         throw rld::error ("duplicate", "function signature: " + record.name);
     286        throw rld::error ("duplicate", "signature: " + record.name);
    234287
    235288      name = record.name;
    236289
    237290      /*
    238        * Function signatures are defined as the return value then the arguments
     291       * Signatures are defined as the return value then the arguments
    239292       * delimited by a comma and white space. No checking is made of the
    240293       * return value or arguments.
     
    244297
    245298      if (si.size () == 0)
    246         throw rld::error ("no return value", "function signature: " + record.name);
     299        throw rld::error ("no return value", "signature: " + record.name);
    247300      if (si.size () == 1)
    248           throw rld::error ("no arguments", "function signature: " + record.name);
     301          throw rld::error ("no arguments", "signature: " + record.name);
    249302
    250303      ret = si[0];
     
    253306    }
    254307
    255     function_sig::function_sig (const function_sig& orig)
    256       : name (orig.name),
    257         args (orig.args),
    258         ret (orig.ret)
    259     {
    260     }
    261 
    262308    const std::string
    263     function_sig::decl () const
     309    signature::decl () const
    264310    {
    265311      std::string ds = ret + ' ' + name + '(';
     
    277323    }
    278324
    279     wrapper::wrapper (const std::string&   name,
    280                       rld::strings&        code,
    281                       rld::config::config& config)
    282       : name (name),
    283         code (code)
     325    function::function (rld::config::config& config,
     326                        const std::string&   name)
     327      : name (name)
    284328    {
    285329      /*
    286        * A wrapper section optionally contain one or more records of:
     330       * A function section optionally contain one or more records of:
    287331       *
    288        * # trace      A list of functions to trace.
    289        * # generator  The name of the generator section. Defaults if not present.
    290        * # headers    A list of sections containing headers or header records.
    291        * # header     A list of include string that are single or double quoted.
    292        * # defines    A list of sections containing defines or define record.
    293        * # defines    A list of define string that are single or double quoted.
    294        * # signatures A list of section names of function signatures.
     332       * # headers     A list of sections containing headers or header records.
     333       * # header      A list of include string that are single or double quoted.
     334       * # defines     A list of sections containing defines or define record.
     335       * # defines     A list of define string that are single or double quoted.
     336       * # signatures  A list of section names of signatures.
     337       * # includes    A list of files to include.
    295338       *
    296339       * @note The quoting and list spliting is a little weak because a delimiter
     
    299342      const rld::config::section& section = config.get_section (name);
    300343
     344      config.includes (section);
     345
    301346      parse (config, section, "headers", "header", headers);
    302347      parse (config, section, "defines", "define", defines);
    303348
    304       parse_generator (config, section);
    305 
    306349      rld::strings sig_list;
    307 
    308       rld::config::parse_items (section, "signatures", sig_list);
     350      section.get_record_items ("signatures", sig_list);
    309351
    310352      for (rld::strings::const_iterator sli = sig_list.begin ();
     
    313355      {
    314356        const rld::config::section& sig_sec = config.get_section (*sli);
    315         for (rld::config::records::const_iterator ri = sig_sec.recs.begin ();
    316              ri != sig_sec.recs.end ();
    317              ++ri)
     357        for (rld::config::records::const_iterator si = sig_sec.recs.begin ();
     358             si != sig_sec.recs.end ();
     359             ++si)
    318360        {
    319           function_sig func (*ri);
    320           sigs[func.name] = func;
     361          signature sig (*si);
     362          signatures_[sig.name] = sig;
    321363        }
    322364      }
     
    324366
    325367    void
    326     wrapper::parse_generator (rld::config::config& config,
    327                               const rld::config::section& section)
    328     {
    329       const rld::config::record* rec = 0;
    330       try
    331       {
    332         const rld::config::record& record = section.get_record ("generator");
    333         rec = &record;
    334       }
    335       catch (rld::error re)
    336       {
    337         /*
    338          * No error, continue.
    339          */
    340       }
    341 
    342       std::string gen_section;
    343 
    344       if (rec)
    345       {
    346         if (!rec->single ())
    347           throw rld::error ("duplicate", "generator: " + section.name + "/generator");
    348         gen_section = rec->items[0].text;
    349       }
    350       else
    351       {
    352         gen_section = config.get_section ("default-generator").get_record_item ("generator");
    353       }
    354 
    355       const rld::config::section& sec = config.get_section (gen_section);
    356 
    357       map_sym_prefix = sec.get_record_item ("map-sym-prefix");
    358       arg_trace = rld::dequote (sec.get_record_item ("arg-trace"));
    359       ret_trace = rld::dequote (sec.get_record_item ("ret-trace"));
    360 
     368    function::dump (std::ostream& out) const
     369    {
     370      out << "   Function: " << name << std::endl
     371          << "    Headers: " << headers.size () << std::endl;
     372      for (rld::strings::const_iterator hi = headers.begin ();
     373           hi != headers.end ();
     374           ++hi)
     375      {
     376        out << "     " << (*hi) << std::endl;
     377      }
     378      out << "   Defines: " << defines.size () << std::endl;
     379      for (rld::strings::const_iterator di = defines.begin ();
     380           di != defines.end ();
     381           ++di)
     382      {
     383        out << "     " << (*di) << std::endl;
     384      }
     385      out << "   Signatures: " << signatures_.size () << std::endl;
     386      for (signatures::const_iterator si = signatures_.begin ();
     387           si != signatures_.end ();
     388           ++si)
     389      {
     390        const signature& sig = (*si).second;
     391        out << "     " << sig.name << ": " << sig.decl () << ';' << std::endl;
     392      }
     393    }
     394
     395    generator::generator ()
     396    {
     397    }
     398
     399    generator::generator (rld::config::config& config,
     400                          const std::string&   name)
     401      : name (name)
     402    {
    361403      /*
    362        * The code block, if present is placed in the code conttainer if unique.
    363        * If referenced by more than wrapper and duplicated a compiler error
    364        * will be generated.
    365        */
    366       rld::strings::iterator ci;
    367       code.push_back (rld::dequote (sec.get_record_item ("code")));
    368       ci = std::unique (code.begin (), code.end ());
    369       code.resize (std::distance (code.begin (), ci));
    370     }
    371 
    372     void
    373     wrapper::parse (rld::config::config&        config,
    374                     const rld::config::section& section,
    375                     const std::string&          sec_name,
    376                     const std::string&          rec_name,
    377                     rld::strings&               items,
    378                     int                         depth)
    379     {
    380       if (depth > 32)
    381         throw rld::error ("too deep", "parsing: " + sec_name + '/' + rec_name);
    382 
    383       rld::config::parse_items (section, rec_name, items);
    384 
    385       rld::strings sl;
    386 
    387       rld::config::parse_items (section, sec_name, sl);
    388 
    389       for (rld::strings::const_iterator sli = sl.begin ();
    390            sli != sl.end ();
    391            ++sli)
    392       {
    393         const rld::config::section& sec = config.get_section (*sli);
    394         parse (config, sec, sec_name, rec_name, items, depth + 1);
    395       }
    396     }
    397 
    398     void
    399     wrapper::dump (std::ostream& out) const
    400     {
    401       out << "  Wrapper: " << name << std::endl
     404       * A generator section optionally contain one or more records of:
     405       *
     406       * # headers     A list of sections containing headers or header records.
     407       * # header      A list of include string that are single or double quoted.
     408       * # defines     A list of sections containing defines or define record.
     409       * # defines     A list of define string that are single or double quoted.
     410       * # code-blocks A list of section names of code blocks.
     411       * # includes    A list of files to include.
     412       *
     413       * @note The quoting and list spliting is a little weak because a delimiter
     414       *       in a quote should not be seen as a delimiter.
     415       */
     416      const rld::config::section& section = config.get_section (name);
     417
     418      config.includes (section);
     419
     420      parse (config, section, "headers",     "header", headers);
     421      parse (config, section, "defines",     "define", defines);
     422      parse (config, section, "code-blocks", "code",   code, false);
     423
     424      map_sym_prefix = section.get_record_item ("map-sym-prefix");
     425      arg_trace = rld::dequote (section.get_record_item ("arg-trace"));
     426      ret_trace = rld::dequote (section.get_record_item ("ret-trace"));
     427    }
     428
     429    void
     430    generator::dump (std::ostream& out) const
     431    {
     432      out << "  Generator: " << name << std::endl
    402433          << "   Headers: " << headers.size () << std::endl;
    403434      for (rld::strings::const_iterator hi = headers.begin ();
     
    417448          << "   Arg Trace Code: " << arg_trace << std::endl
    418449          << "   Return Trace Code: " << ret_trace << std::endl
    419           << "   Function Signatures: " << sigs.size () << std::endl;
    420       for (function_sigs::const_iterator si = sigs.begin ();
    421            si != sigs.end ();
    422            ++si)
    423       {
    424         const function_sig& sig = (*si).second;
    425         out << "    " << sig.name << ": " << sig.decl () << ';' << std::endl;
     450          << "   Code blocks: " << std::endl;
     451      for (rld::strings::const_iterator ci = code.begin ();
     452           ci != code.end ();
     453           ++ci)
     454      {
     455        out << "      > "
     456            << rld::find_replace (*ci, "\n", "\n      | ") << std::endl;
    426457      }
    427458    }
     
    433464    void
    434465    tracer::load (rld::config::config& config,
    435                   const std::string&   section)
     466                  const std::string&   tname)
    436467    {
    437468      /*
    438        * The configuration must contain a "trace" section. This is the top level
    439        * configuration and must the following fields:
     469       * The configuration must contain a "section" section. This is the top level
     470       * configuration and may contain:
    440471       *
    441        *  # name    The name of trace being linked.
    442        *  # trace   The list of sections containing functions to trace.
    443        *  # wrapper The list of sections containing wrapping details.
     472       *  # name      The name of trace being linked.
     473       *  # bsp       The architecture/bsp name of the BSP.
     474       *  # options   A list of options as per the long command line args.
     475       *  # traces    The list of sections containing function lists to trace.
     476       *  # functions The list of sections containing function details.
     477       *  # include   The list of files to include.
    444478       *
    445        * The following record are optional:
     479       * The following records are required:
    446480       *
    447        *  # bdp     The BSP the executable is for. Can be supplied on the command
    448        *            line.
    449        *  # include Include the INI file.
    450        *
    451        * The following will throw an error is the section or records are not
    452        * found.
    453        */
    454       rld::strings ss;
    455 
    456       const rld::config::section& tsec = config.get_section (section);
    457       const rld::config::record&  nrec = tsec.get_record ("name");
    458       const rld::config::record&  brec = tsec.get_record ("bsp");
    459       const rld::config::record&  trec = tsec.get_record ("trace");
    460       const rld::config::record&  wrec = tsec.get_record ("wrapper");
    461 
    462       if (!nrec.single ())
    463         throw rld::error ("duplicate", "trace names");
    464       name = nrec.items[0].text;
    465 
    466       if (!brec.single ())
    467         throw rld::error ("duplicate", "trace bsp");
    468       bsp = brec.items[0].text;
    469 
    470       /*
    471        * Include any files.
    472        */
    473       config.includes (tsec);
    474 
    475       /*
    476        * Load the wrappers.
    477        */
    478       rld::strings wi;
    479       rld::config::parse_items (wrec, wi);
    480       for (rld::strings::const_iterator wsi = wi.begin ();
    481            wsi != wi.end ();
    482            ++wsi)
    483       {
    484         wrappers.push_back (wrapper (*wsi, code, config));
    485       }
    486 
    487       /*
    488        * Load the trace functions.
    489        */
    490       rld::strings ti;
    491       rld::config::parse_items (trec, ti);
    492       for (rld::strings::const_iterator tsi = ti.begin ();
    493            tsi != ti.end ();
    494            ++tsi)
    495       {
    496         rld::config::parse_items (config, *tsi, "trace", traces, true);
    497       }
    498 
     481       *  # name
     482       *  # bsp
     483       *  # trace
     484       *  # functions
     485       */
     486      const rld::config::section& section = config.get_section (tname);
     487
     488      config.includes (section);
     489
     490      name = section.get_record_item ("name");
     491      bsp  = section.get_record_item ("bsp");
     492
     493      load_functions (config, section);
     494      load_traces (config, section);
     495    }
     496
     497    void
     498    tracer::load_functions (rld::config::config&        config,
     499                            const rld::config::section& section)
     500    {
     501      rld::strings fl;
     502      rld::config::parse_items (section, "functions", fl, true);
     503      for (rld::strings::const_iterator fli = fl.begin ();
     504           fli != fl.end ();
     505           ++fli)
     506      {
     507        functions_.push_back (function (config, *fli));
     508      }
     509    }
     510
     511    void
     512    tracer::load_traces (rld::config::config&        config,
     513                         const rld::config::section& section)
     514    {
     515      parse (config, section, "traces", "trace", traces);
     516
     517      rld::strings gens;
     518      std::string  gen;
     519
     520      parse (config, section, "traces", "generator", gens);
     521
     522      if (gens.size () > 1)
     523        throw rld::error ("duplicate generators", "tracer: " + section.name);
     524
     525      if (gens.size () == 0)
     526      {
     527        gen =
     528          config.get_section ("default-generator").get_record_item ("generator");
     529      }
     530      else
     531      {
     532        gen = gens[0];
     533      }
     534
     535      generator_ = generator (config, gen);
    499536    }
    500537
     
    516553        c.write_line (" */");
    517554
    518         for (wrappers::const_iterator wi = wrappers.begin ();
    519              wi != wrappers.end ();
    520              ++wi)
    521         {
    522           const wrapper& wrap = *wi;
    523           c.write_line ("");
    524           c.write_line ("/*");
    525           c.write_line (" * Wrapper: " + wrap.name);
    526           c.write_line (" */");
    527           c.write_lines (wrap.defines);
    528           c.write_lines (wrap.headers);
    529         }
    530 
    531555        c.write_line ("");
    532556        c.write_line ("/*");
    533         c.write_line (" * Code blocks");
     557        c.write_line (" * Generator: " + generator_.name);
    534558        c.write_line (" */");
    535         c.write_lines (code);
     559        c.write_lines (generator_.defines);
     560        c.write_lines (generator_.headers);
     561        c.write_line ("");
     562        c.write_lines (generator_.code);
    536563
    537564        generate_traces (c);
     
    549576    tracer::generate_traces (rld::process::tempfile& c)
    550577    {
     578      for (functions::const_iterator fi = functions_.begin ();
     579           fi != functions_.end ();
     580           ++fi)
     581      {
     582        const function& funcs = *fi;
     583
     584        for (rld::strings::const_iterator ti = traces.begin ();
     585             ti != traces.end ();
     586             ++ti)
     587        {
     588          const std::string&         trace = *ti;
     589          signatures::const_iterator si = funcs.signatures_.find (trace);
     590
     591          if (si != funcs.signatures_.end ())
     592          {
     593            c.write_line ("");
     594            c.write_line ("/*");
     595            c.write_line (" * Function: " + funcs.name);
     596            c.write_line (" */");
     597            c.write_lines (funcs.defines);
     598            c.write_lines (funcs.headers);
     599            break;
     600          }
     601        }
     602      }
     603
     604      c.write_line ("");
     605      c.write_line ("/*");
     606      c.write_line (" * Wrappers.");
     607      c.write_line (" */");
     608
    551609      for (rld::strings::const_iterator ti = traces.begin ();
    552610           ti != traces.end ();
    553611           ++ti)
    554612      {
    555         const std::string& func = *ti;
     613        const std::string& trace = *ti;
    556614        bool               found = false;
    557615
    558         for (wrappers::const_iterator wi = wrappers.begin ();
    559              wi != wrappers.end ();
    560              ++wi)
     616        for (functions::const_iterator fi = functions_.begin ();
     617             fi != functions_.end ();
     618             ++fi)
    561619        {
    562           const wrapper&                wrap = *wi;
    563           function_sigs::const_iterator fsi = wrap.sigs.find (func);
    564 
    565           if (fsi != wrap.sigs.end ())
     620          const function&            funcs = *fi;
     621          signatures::const_iterator si = funcs.signatures_.find (trace);
     622
     623          if (si != funcs.signatures_.end ())
    566624          {
    567625            found = true;
    568626
    569             const function_sig& fs = (*fsi).second;
     627            const signature& sig = (*si).second;
    570628
    571629            c.write_line("");
    572             c.write_line(fs.decl ());
     630            c.write_line(sig.decl ());
    573631            c.write_line("{");
    574632
     
    579637             *       processing is required.
    580638             */
    581             if (fs.ret != "void")
     639            if (sig.ret != "void")
    582640            {
    583               c.write_line(" " + fs.ret + " ret;");
     641              c.write_line(" " + sig.ret + " ret;");
    584642              l = " ret =";
    585643            }
    586644
    587             l += " " + wrap.map_sym_prefix + fs.name + '(';
    588             for (size_t a = 0; a < fs.args.size (); ++a)
     645            l += " " + generator_.map_sym_prefix + sig.name + '(';
     646            for (size_t a = 0; a < sig.args.size (); ++a)
    589647            {
    590648              if (a)
     
    595653            c.write_line(l);
    596654
    597             if (fs.ret != "void")
     655            if (sig.ret != "void")
    598656            {
    599657              c.write_line(" return ret;");
     
    605663
    606664        if (!found)
    607           throw rld::error ("not found", "trace function: " + func);
     665          throw rld::error ("not found", "trace function: " + trace);
    608666      }
    609667    }
     
    613671    {
    614672      out << " Tracer: " << name << std::endl
    615           << "  BSP: " << bsp << std::endl;
    616       for (wrappers::const_iterator wi = wrappers.begin ();
    617            wi != wrappers.end ();
    618            ++wi)
    619       {
    620         (*wi).dump (out);
    621       }
    622       out << "  Code blocks: " << std::endl;
    623       for (rld::strings::const_iterator ci = code.begin ();
    624            ci != code.end ();
    625            ++ci)
    626       {
    627         out << "    > "
    628             << rld::find_replace (*ci, "\n", "\n    | ") << std::endl;
    629       }
     673          << "  BSP: " << bsp << std::endl
     674          << "  Traces: " << traces.size () << std::endl;
     675      for (rld::strings::const_iterator ti = traces.begin ();
     676           ti != traces.end ();
     677           ++ti)
     678      {
     679        out << "   " << (*ti) << std::endl;
     680      }
     681      out << "  Functions: " << functions_.size () << std::endl;
     682      for (functions::const_iterator fi = functions_.begin ();
     683           fi != functions_.end ();
     684           ++fi)
     685      {
     686        (*fi).dump (out);
     687      }
     688      out << "  Generator: " << std::endl;
     689      generator_.dump (out);
    630690    }
    631691
     
    640700      config.clear ();
    641701      config.load (path);
    642       tracer.load (config, trace);
     702      tracer_.load (config, trace);
    643703    }
    644704
     
    646706    linker::generate_wrapper ()
    647707    {
    648       tracer.generate ();
     708      tracer_.generate ();
    649709    }
    650710
     
    661721      }
    662722
    663       tracer.dump (out);
     723      tracer_.dump (out);
    664724    }
    665725  }
  • linkers/rtld-base.ini

    r4fd758e r097f1fd  
    66
    77;
    8 ; The default generartor is used if a wrapper does provide a generator record.
     8; The default generartor is used if a function set does provide a generator record.
    99;
    1010[default-generator]
     
    3333CODE
    3434
    35 [base-generator-headers]
     35[printf-generator-headers]
    3636header = "#include <stdio.h>"
  • linkers/test-trace.ini

    r4fd758e r097f1fd  
    1212; The BSP.
    1313;
    14 bsp = sis
     14bsp = sparc/sis
     15;
     16; Options can be defined here or on the command line.
     17;
     18options = all-funcs, verbose
    1519;
    1620; Functions to trace.
    1721;
    18 trace = test-trace, test-trace-funcs, rtems-api-task
     22traces = test-trace, test-trace-funcs, rtems-api-task
    1923;
    20 ; Define the wrapper.
     24; Define the function sets. These are the function's that can be
     25; added to the trace lists.
    2126;
    22 wrapper = test-trace, rtems-api
     27functions = test-trace-funcs, rtems-api
    2328;
    2429; Include RTEMS Trace support.
     
    2934; User application trace example.
    3035;
     36[test-trace]
     37generator = printf-generator
     38; Just here for testing.
     39trace = test_trace_3
     40
    3141[test-trace-funcs]
     42; Parsed via the 'function-set', not parse as a 'trace'.
     43headers = test-headers
     44header = '#include "test-trace-2.h"'
     45defines = test-defines
     46define = "#define TEST_TRACE_2 2"
     47signatures = test-signatures
     48; Parsed via the 'trace', not parsed as a function-set
    3249trace = test_trace_1, test_trace_2
    3350
    34 [test-trace]
    35 trace = test_trace_3
    36 header = '#include "test-trace.h"'
    37 define = "#define TEST_TRACE 1"
    38 signatures = test-signatures
    39 generator = printf-generator
    40 
    4151[test-headers]
    42 header = '#include "test-trace.h"'
     52header = '#include "test-trace-1.h"'
    4353
    4454[test-defines]
    45 define = "#define TEST_TRACE 1"
     55define = "#define TEST_TRACE_1 1"
    4656
    4757[test-signatures]
Note: See TracChangeset for help on using the changeset viewer.