Changeset 7ccb670 in rtems-tools


Ignore:
Timestamp:
Sep 5, 2014, 8:16:40 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
31bf375
Parents:
2f48445
Message:

Add support for RTEMS BSP or user supplied CFLAGS. Remove march/mcpu.

Added support to read an RTEMS BSP pkgconfig file and ste the CC
flags.

Location:
linkers
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-cc.cpp

    r2f48445 r7ccb670  
    3434    std::string cxxflags;
    3535    std::string ldflags;
     36    std::string warning_cflags;
     37    std::string include_cflags;
     38    std::string machine_cflags;
     39    std::string spec_cflags;
    3640    std::string install_path;
    3741    std::string programs_path;
     
    8892      if (!ldflags.empty ())
    8993        args.push_back (ldflags);
     94    }
     95
     96    const std::string
     97    strip_cflags (const std::string& flags)
     98    {
     99      std::string  oflags;
     100      rld::strings flags_;
     101      rld::split (flags_, flags);
     102
     103      for (rld::strings::iterator si = flags_.begin ();
     104           si != flags_.end ();
     105           ++si)
     106      {
     107        if (!rld::starts_with ((*si), "-O") && !rld::starts_with ((*si), "-g"))
     108          oflags += ' ' + *si;
     109      }
     110
     111      return rld::trim (oflags);
     112    }
     113
     114    const std::string
     115    filter_flags (const std::string& flags,
     116                  const std::string& ,
     117                  const std::string& ,
     118                  flag_type          type,
     119                  std::string&       warnings,
     120                  std::string&       includes,
     121                  std::string&       machines,
     122                  std::string&       specs)
     123    {
     124      /*
     125       * Defintion of flags to be filtered.
     126       */
     127      enum flag_group
     128      {
     129        fg_warning,
     130        fg_include,
     131        fg_machine,
     132        fg_specs
     133      };
     134      struct flag_def
     135      {
     136        flag_group  group;  ///< The group this flag belong to.
     137        const char* opt;    ///< Option start.
     138        int         count;  ///< Number of arguments with the option.
     139        bool        path;   ///< Is this a path ?
     140        int         out;    ///< If the flag type is set drop the opt..
     141      };
     142      const flag_def flag_defs[] =
     143        {
     144          { fg_warning, "-W",       1, false, ft_cppflags | ft_cflags | ft_ldflags },
     145          { fg_include, "-I",       2, true,  0 },
     146          { fg_include, "-isystem", 2, true,  0 },
     147          { fg_include, "-sysroot", 2, true,  0 },
     148          { fg_machine, "-O",       1, false, 0 },
     149          { fg_machine, "-m",       1, false, 0 },
     150          { fg_machine, "-f",       1, false, 0 },
     151          { fg_specs,   "-q",       1, false, 0 },
     152          { fg_specs,   "-B",       2, true,  0 },
     153          { fg_specs,   "--specs",  2, false, 0 }
     154        };
     155      const int flag_def_size = sizeof (flag_defs) / sizeof (flag_def);
     156
     157      std::string  oflags;
     158      rld::strings flags_;
     159
     160      rld::split (flags_, strip_cflags (flags));
     161
     162      warnings.clear ();
     163      includes.clear ();
     164      machines.clear ();
     165      specs.clear ();
     166
     167      for (rld::strings::iterator si = flags_.begin ();
     168           si != flags_.end ();
     169           ++si)
     170      {
     171        std::string  opts;
     172        std::string& opt = *(si);
     173        bool         in = true;
     174
     175        for (int fd = 0; fd < flag_def_size; ++fd)
     176        {
     177          if (rld::starts_with (opt, flag_defs[fd].opt))
     178          {
     179            int opt_count = flag_defs[fd].count;
     180            if (opt_count > 1)
     181            {
     182              /*
     183               * See if the flag is just the option. If is not take one less
     184               * because the option's argument is joined to the option.
     185               */
     186              if (opt != flag_defs[fd].opt)
     187              {
     188                opt_count -= 1;
     189                /*
     190                 * @todo Path processing here. Not sure what it is needed for.
     191                 */
     192              }
     193            }
     194            opts += ' ' + opt;
     195            while (opt_count > 1)
     196            {
     197              ++si;
     198              /*
     199               * @todo Path processing here. Not sure what it is needed for.
     200               */
     201              opts += ' ' + (*si);
     202              --opt_count;
     203            }
     204            switch (flag_defs[fd].group)
     205            {
     206              case fg_warning:
     207                warnings += ' ' + opts;
     208                break;
     209              case fg_include:
     210                includes += ' ' + opts;
     211                break;
     212              case fg_machine:
     213                machines += ' ' + opts;
     214                break;
     215              case fg_specs:
     216                specs += ' ' + opts;
     217                break;
     218              default:
     219                throw rld::error ("Invalid group", "flag group");
     220            }
     221            if ((flag_defs[fd].out & type) != 0)
     222              in = false;
     223            break;
     224          }
     225        }
     226
     227        if (in)
     228          oflags += ' ' + opts;
     229      }
     230
     231      rld::trim (warnings);
     232      rld::trim (includes);
     233      rld::trim (machines);
     234      rld::trim (specs);
     235
     236      return rld::trim (oflags);
     237    }
     238
     239    const std::string
     240    filter_flags (const std::string& flags,
     241                  const std::string& arch,
     242                  const std::string& path,
     243                  flag_type          type)
     244    {
     245      if (type != ft_cflags)
     246      {
     247        std::string warnings;
     248        std::string includes;
     249        std::string machines;
     250        std::string specs;
     251        return filter_flags (flags,
     252                             arch,
     253                             path,
     254                             type,
     255                             warnings,
     256                             includes,
     257                             machines,
     258                             specs);
     259      }
     260      else
     261      {
     262        return filter_flags (flags,
     263                             arch,
     264                             path,
     265                             type,
     266                             warning_cflags,
     267                             include_cflags,
     268                             machine_cflags,
     269                             spec_cflags);
     270      }
    90271    }
    91272
  • linkers/rld-cc.h

    r2f48445 r7ccb670  
    3535  namespace cc
    3636  {
     37    /*
     38     * Defintion of flags to be filtered.
     39     */
     40    enum flag_type
     41    {
     42      ft_cppflags = 1 << 0,
     43      ft_cflags   = 1 << 1,
     44      ft_cxxflags = 1 << 2,
     45      ft_ldflags  = 1 << 3
     46    };
     47
    3748    extern std::string cc;             //< The CC executable as absolute path.
    3849    extern std::string cc_name;        //< The CC name, ie gcc, clang.
     
    4354    extern std::string cxxflags;       //< The CXX flags.
    4455    extern std::string ldflags;        //< The LD flags.
     56
     57    extern std::string warning_cflags; //< The warning flags in cflags.
     58    extern std::string include_cflags; //< The include flags in cflags.
     59    extern std::string machine_cflags; //< The machine flags in cflags.
     60    extern std::string spec_cflags;    //< The spec flags in cflags.
    4561
    4662    extern std::string install_path;   //< The CC reported install path.
     
    7490
    7591    /**
     92     * Strip the flags of -O and -g options.
     93     *
     94     * @param flags The flags a space delimited list to strip.
     95     * @return const std::string The stripped flags.
     96     */
     97    const std::string strip_cflags (const std::string& flags);
     98
     99    /**
     100     * Filter the flags. Provide the type of flags being passed, the flags as a
     101     * space separated list, the architure, and a path. Provide strings
     102     * containers for the different flag groups so they can be sorted and
     103     * returned.
     104     *
     105     * @param flags The flags a space delimited list to strip.
     106     * @param arch The architecure per the OS specific name.
     107     * @param path A path to adjust based on the architecture.
     108     * @param type The type of flags being passed.
     109     * @param warnings Return warning flags in this string.
     110     * @param includes Return include flags in this string.
     111     * @param machines Return machine flags in this string.
     112     * @param specs Return spec flags in this string.
     113     * @return const std::string The filtered flags.
     114     */
     115    const std::string filter_flags (const std::string& flags,
     116                                    const std::string& arch,
     117                                    const std::string& path,
     118                                    flag_type          type,
     119                                    std::string&       warnings,
     120                                    std::string&       includes,
     121                                    std::string&       machines,
     122                                    std::string&       specs);
     123
     124    /**
     125     * Filter the cflags and update the warnings, includes, machines and specs
     126     * if the type of flags is cflags. Provide the cflags as a space separated
     127     * list, the architure, and a path.
     128     *
     129     * @param flags The flags a space delimited list to strip.
     130     * @param arch The architecure per the OS specific name.
     131     * @param path A path to adjust based on the architecture.
     132     * @param type The type of flags being passed.
     133     * @return const std::string The filtered flags.
     134     */
     135    const std::string filter_flags (const std::string& flags,
     136                                    const std::string& arch,
     137                                    const std::string& path,
     138                                    flag_type          type);
     139
     140    /**
    76141     * Get the standard libraries paths from the compiler.
    77142     */
  • linkers/rld-path.cpp

    r2f48445 r7ccb670  
    1919#endif
    2020
    21 #include <algorithm>
    22 
    23 #include <errno.h>
    24 #include <fcntl.h>
    25 #include <stdio.h>
    26 #include <string.h>
    2721#include <sys/stat.h>
    28 #include <unistd.h>
    2922
    3023#include <rld.h>
     
    7972
    8073    void
    81     path_join (const std::string& path_, const std::string& file_, std::string& joined)
     74    path_join (const std::string& base, const std::string& part, std::string& joined)
    8275    {
    83       if ((path_[path_.size () - 1] != RLD_PATH_SEPARATOR) &&
    84           (file_[0] != RLD_PATH_SEPARATOR))
    85         joined = path_ + RLD_PATH_SEPARATOR + file_;
    86       else if ((path_[path_.size () - 1] == RLD_PATH_SEPARATOR) &&
    87                (file_[0] == RLD_PATH_SEPARATOR))
    88         joined = path_ + &file_[1];
     76      if ((base[base.size () - 1] != RLD_PATH_SEPARATOR) &&
     77          (part[0] != RLD_PATH_SEPARATOR))
     78        joined = base + RLD_PATH_SEPARATOR + part;
     79      else if ((base[base.size () - 1] == RLD_PATH_SEPARATOR) &&
     80               (part[0] == RLD_PATH_SEPARATOR))
     81        joined = base + &part[1];
    8982      else
    90         joined = path_ + file_;
     83        joined = base + part;
     84    }
     85
     86    void path_join (const std::string& base, const paths& parts, std::string& joined)
     87    {
     88      joined = base;
     89      for (paths::const_iterator pi = parts.begin ();
     90           pi != parts.end ();
     91           ++pi)
     92      {
     93        path_join (joined, *pi, joined);
     94      }
    9195    }
    9296
  • linkers/rld-path.h

    r2f48445 r7ccb670  
    7878
    7979    /**
    80      * Make a path by joining the parts with required separator.
     80     * Make a path by joining the base and part with required separator.
    8181     *
    82      * @param path_ The path component to be joined.
    83      * @param file_ The file name to add to the path.
     82     * @param base The path component to be joined.
     83     * @param part The file name to add to the path.
    8484     * @param joined The joined path and file name with a path separator.
    8585     */
    86     void path_join (const std::string& path_,
    87                     const std::string& file_,
     86    void path_join (const std::string& base,
     87                    const std::string& part,
     88                    std::string&       joined);
     89
     90    /**
     91     * Make a path by joining the parts with the base and the required
     92     * separator.
     93     *
     94     * @param base The path component to be joined.
     95     * @param parts The files to add to the path.
     96     * @param joined The joined path and file name with a path separator.
     97     */
     98    void path_join (const std::string& base,
     99                    const paths&       parts,
    88100                    std::string&       joined);
    89101
  • linkers/rld.h

    r2f48445 r7ccb670  
    123123
    124124  /**
     125   * Does a string start with another string ?
     126   */
     127  inline bool starts_with(const std::string& s1, const std::string& s2)
     128  {
     129    return s2.size () <= s1.size () && s1.compare (0, s2.size (), s2) == 0;
     130  }
     131
     132  /**
    125133   * Trim from start.
    126134   */
     
    196204  inline strings& split (strings&           se,
    197205                         const std::string& s,
    198                          char               delimiter,
     206                         char               delimiter = ' ',
    199207                         bool               strip_quotes = true,
    200208                         bool               strip_whitespace = true,
     
    237245
    238246  /**
     247   * Convert a string to lower case.
     248   */
     249  inline std::string tolower (const std::string& sin)
     250  {
     251    std::string s = sin;
     252    std::transform (s.begin (), s.end (), s.begin (), ::tolower);
     253    return s;
     254  }
     255
     256  /**
    239257   * Increment the verbose level.
    240258   */
Note: See TracChangeset for help on using the changeset viewer.