Changeset b28e8b3 in rtems-tools


Ignore:
Timestamp:
Sep 7, 2014, 4:31:18 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
6506aa1
Parents:
32cd4fc
Message:

Refactor the rld-rtems support to remove the globals.

Location:
linkers
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-cc.cpp

    r32cd4fc rb28e8b3  
    2222#include <rld-cc.h>
    2323#include <rld-process.h>
     24#include <rld-rtems.h>
    2425
    2526namespace rld
     
    424425        std::string cmd = cc_name;
    425426        if (!exec_prefix.empty ())
    426           cmd = exec_prefix + "-rtems" + rld::rtems_version () + '-' + cmd;
     427          cmd = exec_prefix + "-rtems" + rld::rtems::version () + '-' + cmd;
    427428        args.push_back (cmd);
    428429      }
  • linkers/rld-rtems.cpp

    r32cd4fc rb28e8b3  
    1717#include <rld.h>
    1818#include <rld-cc.h>
     19#include <rld-rtems.h>
    1920
    2021#include <pkgconfig.h>
     
    2425  namespace rtems
    2526  {
    26     std::string version = "4.11";
    27     std::string path;
    28     bool        installed;
    29     std::string arch_bsp;
    30 
    31     const std::string
    32     arch (const std::string& ab)
    33     {
    34       std::string::size_type slash = ab.find_first_of ('/');
    35       if (slash == std::string::npos)
    36         throw rld::error ("Invalid BSP name", ab);
    37       return ab.substr (0, slash);
    38       std::string bsp  = ab.substr (slash + 1);
    39     }
    40 
    41     const std::string
    42     bsp (const std::string& ab)
    43     {
    44       std::string::size_type slash = ab.find_first_of ('/');
    45       if (slash == std::string::npos)
    46         throw rld::error ("Invalid BSP name", ab);
    47       return ab.substr (slash + 1);
    48     }
    49 
    50     const std::string
    51     rtems_arch_prefix (const std::string& ab)
    52     {
    53       return arch (ab) + "-rtems" + version;
    54     }
    55 
    56     const std::string
    57     rtems_arch_bsp (const std::string& ab)
    58     {
    59       return rtems_arch_prefix (ab) + '-' + bsp (ab);
    60     }
    61 
    62     void
     27    static std::string _version = "4.11";
     28    static std::string _path;
     29    static std::string _arch_bsp;
     30
     31    static void
    6332    load_cc ()
    6433    {
     
    6736      std::string bsp;
    6837
    69       if (path.empty ())
    70         throw rld::error ("Not set; see -r", "RTEMS path");
    71 
    72       bsp = rtems_arch_bsp (arch_bsp);
     38      if (_path.empty ())
     39        throw rld::error ("Not set", "RTEMS path");
     40
     41      bsp = rtems_arch_bsp ();
    7342
    7443      parts.push_back ("lib");
    7544      parts.push_back ("pkgconfig");
    7645
    77       rld::path::path_join (path, parts, rtems_pkgconfig);
     46      rld::path::path_join (path (), parts, rtems_pkgconfig);
    7847
    7948      if (!path::check_directory (rtems_pkgconfig))
    80         throw rld::error ("Invalid RTEMS path", path);
     49        throw rld::error ("Invalid RTEMS path", path ());
    8150
    8251      rld::path::path_join (rtems_pkgconfig, bsp + ".pc", rtems_pkgconfig);
    8352
    8453      if (!path::check_file (rtems_pkgconfig))
    85         throw rld::error ("RTEMS BSP not found", arch_bsp);
     54        throw rld::error ("RTEMS BSP not found", arch_bsp ());
    8655
    8756      if (rld::verbose () >= RLD_VERBOSE_INFO)
    88         std::cout << " rtems: " << arch_bsp << ": "
     57        std::cout << " rtems: " << _arch_bsp << ": "
    8958                  << rtems_pkgconfig << std::endl;
    9059
     
    9665      std::string name;
    9766      if (!pkg.get ("name", name))
    98         throw rld::error ("RTEMS BSP no name in pkgconfig file", arch_bsp);
     67        throw rld::error ("RTEMS BSP no name in pkgconfig file", _arch_bsp);
    9968
    10069      if (name != bsp)
    101         throw rld::error ("RTEMS BSP does not match the name in pkgconfig file", arch_bsp);
     70        throw rld::error ("RTEMS BSP does not match the name in pkgconfig file",
     71                          _arch_bsp);
    10272
    10373      std::string flags;
     
    10575      if (pkg.get ("CPPFLAGS", flags))
    10676      {
    107         rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_cppflags);
    108         if (rld::verbose () >= RLD_VERBOSE_INFO)
    109           std::cout << " rtems: " << arch_bsp
     77        rld::cc::append_flags (flags, arch (), path (), rld::cc::ft_cppflags);
     78        if (rld::verbose () >= RLD_VERBOSE_INFO)
     79          std::cout << " rtems: " << arch_bsp ()
    11080                    << ": CPPFLAGS="
    11181                    << rld::cc::get_flags (rld::cc::ft_cppflags)
     
    11585      if (pkg.get ("CFLAGS", flags))
    11686      {
    117         rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_cflags);
     87        rld::cc::append_flags (flags, arch (), path (), rld::cc::ft_cflags);
    11888        if (rld::verbose () >= RLD_VERBOSE_INFO)
    11989        {
    120           std::cout << " rtems: " << arch_bsp
     90          std::cout << " rtems: " << arch_bsp ()
    12191                    << ": CFLAGS=" << rld::cc::get_flags (rld::cc::ft_cflags)
    12292                    << std::endl;
    123           std::cout << " rtems: " << arch_bsp
     93          std::cout << " rtems: " << _arch_bsp
    12494                    << ": WARNINGS=" << rld::cc::get_flags (rld::cc::fg_warning_flags)
    12595                    << std::endl;
    126           std::cout << " rtems: " << arch_bsp
     96          std::cout << " rtems: " << arch_bsp ()
    12797                    << ": INCLUDES=" << rld::cc::get_flags (rld::cc::fg_include_flags)
    12898                    << std::endl;
    129           std::cout << " rtems: " << arch_bsp
     99          std::cout << " rtems: " << arch_bsp ()
    130100                    << ": MACHINES=" << rld::cc::get_flags (rld::cc::fg_machine_flags)
    131101                    << std::endl;
    132           std::cout << " rtems: " << arch_bsp
     102          std::cout << " rtems: " << arch_bsp ()
    133103                    << ": SPECS=" << rld::cc::get_flags (rld::cc::fg_spec_flags)
    134104                    << std::endl;
     
    138108      if (pkg.get ("CXXFLAGS", flags))
    139109      {
    140         rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_cxxflags);
    141         if (rld::verbose () >= RLD_VERBOSE_INFO)
    142           std::cout << " rtems: " << arch_bsp
     110        rld::cc::append_flags (flags, arch (), path (), rld::cc::ft_cxxflags);
     111        if (rld::verbose () >= RLD_VERBOSE_INFO)
     112          std::cout << " rtems: " << arch_bsp ()
    143113                    << ": CXXFLAGS=" << rld::cc::get_flags (rld::cc::ft_cxxflags)
    144114                    << std::endl;
     
    147117      if (pkg.get ("LDFLAGS", flags))
    148118      {
    149         rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_ldflags);
    150         if (rld::verbose () >= RLD_VERBOSE_INFO)
    151           std::cout << " rtems: " << arch_bsp
     119        rld::cc::append_flags (flags, arch (), path (), rld::cc::ft_ldflags);
     120        if (rld::verbose () >= RLD_VERBOSE_INFO)
     121          std::cout << " rtems: " << arch_bsp ()
    152122                    << ": LDFLAGS=" << rld::cc::get_flags (rld::cc::ft_ldflags)
    153123                    << std::endl;
    154124      }
    155125
    156       rld::cc::set_exec_prefix (arch (arch_bsp));
    157     }
     126      rld::cc::set_exec_prefix (arch ());
     127    }
     128
     129    void
     130    set_version (const std::string& version_)
     131    {
     132      _version = version_;
     133    }
     134
     135    void
     136    set_arch_bsp (const std::string& arch_bsp_)
     137    {
     138      _arch_bsp = arch_bsp_;
     139      if (!_path.empty ())
     140        load_cc ();
     141    }
     142
     143    void
     144    set_path (const std::string& path_)
     145    {
     146      _path = path_;
     147      if (!_arch_bsp.empty ())
     148        load_cc ();
     149    }
     150
     151    const std::string
     152    version ()
     153    {
     154      return _version;
     155    }
     156
     157    const std::string
     158    arch_bsp ()
     159    {
     160      return _arch_bsp;
     161    }
     162
     163    const std::string
     164    arch ()
     165    {
     166      if (_arch_bsp.empty ())
     167        throw rld::error ("No arch/bsp name", "rtems: arch");
     168      std::string::size_type slash = _arch_bsp.find_first_of ('/');
     169      if (slash == std::string::npos)
     170        throw rld::error ("Invalid BSP name", _arch_bsp);
     171      return _arch_bsp.substr (0, slash);
     172      std::string bsp  = _arch_bsp.substr (slash + 1);
     173    }
     174
     175    const std::string
     176    bsp ()
     177    {
     178      if (_arch_bsp.empty ())
     179        throw rld::error ("No arch/bsp name", "rtems: bsp");
     180      std::string::size_type slash = _arch_bsp.find_first_of ('/');
     181      if (slash == std::string::npos)
     182        throw rld::error ("Invalid BSP name", _arch_bsp);
     183      return _arch_bsp.substr (slash + 1);
     184    }
     185
     186    const std::string
     187    path ()
     188    {
     189      return _path;
     190    }
     191
     192    const std::string
     193    rtems_arch_prefix ()
     194    {
     195      return arch () + "-rtems" + version ();
     196    }
     197
     198    const std::string
     199    rtems_arch_bsp ()
     200    {
     201      return rtems_arch_prefix () + '-' + bsp ();
     202    }
     203
    158204  }
    159205}
  • linkers/rld-rtems.h

    r32cd4fc rb28e8b3  
    3333  {
    3434    /**
    35      * The RTEMS default version.
     35     * Set the RTEMS version.
    3636     */
    37     extern std::string version;
     37    void set_version (const std::string& version);
    3838
    3939    /**
    40      * The path to RTEMS.
     40     * Set the arch/bsp string.
    4141     */
    42     extern std::string path;
     42    void set_arch_bsp (const std::string& arch_bsp);
    4343
    4444    /**
    45      * Is the RTEMS installed.
     45     * Set the path to RTEMS.
    4646     */
    47     extern bool installed;
     47    void set_path (const std::string& path);
    4848
    4949    /**
    50      * The BSP name.
     50     * Get the RTEMS version.
    5151     */
    52     extern std::string arch_bsp;
     52    const std::string version ();
     53
     54    /**
     55     * Return the arch/bsp string.
     56     */
     57    const std::string arch_bsp ();
    5358
    5459    /**
    5560     * Return the architecture given an arch/bsp string.
    5661     */
    57     const std::string arch (const std::string& ab);
     62    const std::string arch ();
    5863
    5964    /**
    6065     * Return the bsp given an arch/bsp string.
    6166     */
    62     const std::string bsp (const std::string& ab);
     67    const std::string bsp ();
    6368
    6469    /**
    65      * Return the RTEMS bsp string given an arch/bsp string.
     70     * Get the RTEMS path.
    6671     */
    67     const std::string rtems_bsp (const std::string& ab);
     72    const std::string path ();
    6873
    6974    /**
    70      * Load the configuration. Set the various values via the command or a
    71      * configuration file then check the configuration.
     75     * Return the RTEMS BSP prefix.
    7276     */
    73     void load_cc ();
     77    const std::string rtems_arch_prefix ();
    7478
    7579    /**
    76      * Process the BSP name updating the various CC flags.
     80     * Return the arch/bsp as an RTEMS prefix and BSP string.
    7781     */
    78     void set_cc (void);
     82    const std::string rtems_arch_bsp ();
    7983  }
    8084}
  • linkers/rld.h

    r32cd4fc rb28e8b3  
    273273
    274274  /**
    275    * The RTEMS version string. @todo move to rld-rtems.
    276    */
    277   const std::string rtems_version ();
    278 
    279   /**
    280275   * Container of strings to hold the results of a split.
    281276   */
  • linkers/rtems-ld.cpp

    r32cd4fc rb28e8b3  
    186186    rld::symbols::table  symbols;
    187187    rld::symbols::symtab undefined;
     188    std::string          rtems_path;
     189    std::string          rtems_arch_bsp;
    188190    std::string          entry = "rtems";
    189191    std::string          exit;
     
    196198    bool                 warnings = false;
    197199    bool                 one_file = false;
    198     bool                 arch_bsp_load = false;
    199200
    200201    libpaths.push_back (".");
     
    312313
    313314        case 'r':
    314           rld::rtems::path = optarg;
     315          rtems_path = optarg;
    315316          break;
    316317
    317318        case 'B':
    318           rld::rtems::arch_bsp = optarg;
    319           arch_bsp_load = true;
     319          rtems_arch_bsp = optarg;
    320320          break;
    321321
     
    354354     * Load the arch/bsp value if provided.
    355355     */
    356     if (arch_bsp_load)
    357       rld::rtems::load_cc ();
     356    if (!rtems_arch_bsp.empty ())
     357    {
     358      if (rtems_path.empty ())
     359        throw rld::error ("arch/bsp provide and no RTEMS path", "options");
     360      rld::rtems::set_path (rtems_path);
     361      rld::rtems::set_arch_bsp (rtems_arch_bsp);
     362    }
    358363
    359364    /*
  • linkers/rtems-tld.cpp

    r32cd4fc rb28e8b3  
    234234
    235235      /**
     236       * Link the application.
     237       */
     238      void link (rld::process::tempfile& o,
     239                 const std::string&      ld_cmds);
     240
     241      /**
    236242       * Dump the linker.
    237243       */
     
    753759
    754760    void
     761    linker::link (rld::process::tempfile& o,
     762                  const std::string&      ld_cmds)
     763    {
     764
     765    }
     766
     767    void
    755768    linker::dump (std::ostream& out) const
    756769    {
     
    780793  { "warn",        no_argument,            NULL,           'w' },
    781794  { "keep",        no_argument,            NULL,           'k' },
     795  { "linker",      required_argument,      NULL,           'l' },
    782796  { "exec-prefix", required_argument,      NULL,           'E' },
    783797  { "cflags",      required_argument,      NULL,           'c' },
     
    800814            << " -w         : generate warnings (also --warn)" << std::endl
    801815            << " -k         : keep temporary files (also --keep)" << std::endl
     816            << " -l linker  : target linker is not standard (also --linker)" << std::endl
    802817            << " -E prefix  : the RTEMS tool prefix (also --exec-prefix)" << std::endl
    803818            << " -c cflags  : C compiler flags (also --cflags)" << std::endl
    804819            << " -r path    : RTEMS path (also --rtems)" << std::endl
    805820            << " -B bsp     : RTEMS arch/bsp (also --rtems-bsp)" << std::endl
    806             << " -W wrapper : Wrapper file name without ext (also --wrapper)" << std::endl
     821            << " -W wrapper : wrapper file name without ext (also --wrapper)" << std::endl
    807822            << " -C ini     : user configuration INI file (also --config)" << std::endl;
    808823  ::exit (exit_code);
     
    853868  {
    854869    rld::trace::linker linker;
     870    std::string        ld;
    855871    std::string        ld_cmd;
    856872    std::string        configuration;
    857873    std::string        trace = "tracer";
    858874    std::string        wrapper;
    859     bool               arch_bsp_load = false;
     875    std::string        rtems_path;
     876    std::string        rtems_arch_bsp;
    860877
    861878    while (true)
    862879    {
    863       int opt = ::getopt_long (argc, argv, "hvwkVE:c:C:r:B:W:", rld_opts, NULL);
     880      int opt = ::getopt_long (argc, argv, "hvwkVl:E:c:C:r:B:W:", rld_opts, NULL);
    864881      if (opt < 0)
    865882        break;
     
    887904          break;
    888905
     906        case 'l':
     907          ld = optarg;
     908          break;
     909
    889910        case 'E':
    890911          rld::cc::set_exec_prefix (optarg);
     
    896917
    897918        case 'r':
    898           rld::rtems::path = optarg;
     919          rtems_path = optarg;
    899920          break;
    900921
    901922        case 'B':
    902           rld::rtems::arch_bsp = optarg;
    903           arch_bsp_load = true;
     923          rtems_arch_bsp = optarg;
    904924          break;
    905925
     
    931951     * Load the arch/bsp value if provided.
    932952     */
    933     if (arch_bsp_load)
    934       rld::rtems::load_cc ();
     953    if (!rtems_arch_bsp.empty ())
     954    {
     955      if (rtems_path.empty ())
     956        throw rld::error ("arch/bsp provide and no RTEMS path", "options");
     957      rld::rtems::set_path (rtems_path);
     958      rld::rtems::set_arch_bsp (rtems_arch_bsp);
     959    }
    935960
    936961    /*
     
    938963     */
    939964    while (argc--)
    940     {
    941       if (ld_cmd.length () != 0)
    942         ld_cmd += " ";
    943       ld_cmd += *argv++;
    944     }
     965      ld_cmd += ' ' + *argv++;
     966    ld_cmd = rld::trim (ld_cmd);
    945967
    946968    /*
     
    970992      linker.generate_wrapper (c);
    971993      linker.compile_wrapper (c, o);
     994      linker.link (o, ld_cmd);
    972995
    973996      if (rld::verbose ())
Note: See TracChangeset for help on using the changeset viewer.