Changeset 5025439 in rtems-tools for linkers/rtems-tld.cpp


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.

File:
1 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);
Note: See TracChangeset for help on using the changeset viewer.