Changeset 8807135 in rtems-tools


Ignore:
Timestamp:
Sep 6, 2014, 10:19:45 AM (5 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
c4c8218
Parents:
a916fa4
Message:

Refactor the CC flags. Fix the various linkers. The trace linker is compiling.

Location:
linkers
Files:
2 added
10 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-cc.cpp

    ra916fa4 r8807135  
    2727  namespace cc
    2828  {
    29     std::string cc;
    30     std::string cc_name = "gcc";
    31     std::string exec_prefix;
    32     std::string cppflags;
    33     std::string cflags;
    34     std::string cxxflags;
    35     std::string ldflags;
    36     std::string warning_cflags;
    37     std::string include_cflags;
    38     std::string machine_cflags;
    39     std::string spec_cflags;
    40     std::string install_path;
    41     std::string programs_path;
    42     std::string libraries_path;
     29    static std::string cc;              //< The CC executable as absolute path.
     30    static bool        cc_set;          //< True when the CC has been set.
     31    static std::string cc_name = "gcc"; //< The CC name, ie gcc, clang.
     32    static std::string exec_prefix;     //< The CC executable prefix.
     33
     34    static std::string cppflags;        //< The CPP flags.
     35    static std::string cflags;          //< The CC flags.
     36    static std::string cxxflags;        //< The CXX flags.
     37    static std::string ldflags;         //< The LD flags.
     38
     39    static std::string warning_cflags;  //< The warning flags in cflags.
     40    static std::string include_cflags;  //< The include flags in cflags.
     41    static std::string machine_cflags;  //< The machine flags in cflags.
     42    static std::string spec_cflags;     //< The spec flags in cflags.
     43
     44    static std::string install_path;    //< The CC reported install path.
     45    static std::string programs_path;   //< The CC reported programs path.
     46    static std::string libraries_path;  //< The CC reported libraries path.
    4347
    4448    /**
     
    4852    static const char* std_lib_c         = "libgcc.a" RPS "libssp.a" RPS "libc.a";
    4953    static const char* std_lib_cplusplus = "libstdc++.a";
    50 
    51     void
    52     make_cc_command (rld::process::arg_container& args)
    53     {
    54       /*
    55        * Use the absolute path to CC if provided.
    56        */
    57       if (!cc.empty ())
    58         args.push_back (cc);
    59       else
    60       {
    61         std::string cmd = cc_name;
    62         if (!exec_prefix.empty ())
    63           cmd = exec_prefix + "-rtems" + rld::rtems_version () + '-' + cmd;
    64         args.push_back (cmd);
    65       }
    66     }
    67 
    68     void
    69     add_cppflags (rld::process::arg_container& args)
    70     {
    71       if (!cppflags.empty ())
    72         args.push_back (cppflags);
    73     }
    74 
    75     void
    76     add_cflags (rld::process::arg_container& args)
    77     {
    78       if (!cflags.empty ())
    79         args.push_back (cflags);
    80     }
    81 
    82     void
    83     add_cxxflags (rld::process::arg_container& args)
    84     {
    85       if (!cxxflags.empty ())
    86         args.push_back (cxxflags);
    87     }
    88 
    89     void
    90     add_ldflags (rld::process::arg_container& args)
    91     {
    92       if (!ldflags.empty ())
    93         args.push_back (ldflags);
    94     }
    9554
    9655    const std::string
     
    271230    }
    272231
     232    void
     233    set_cc (const std::string& cc_)
     234    {
     235      cc = cc_;
     236      cc_set = true;
     237    }
     238
     239    const std::string
     240    get_cc ()
     241    {
     242      return cc;
     243    }
     244
     245    bool
     246    is_cc_set ()
     247    {
     248      return cc_set;
     249    }
     250
     251    void
     252    set_exec_prefix (const std::string& exec_prefix_)
     253    {
     254      exec_prefix = exec_prefix_;
     255    }
     256
     257    const std::string
     258    get_exec_prefix ()
     259    {
     260      return exec_prefix;
     261    }
     262
     263    bool is_exec_prefix_set ()
     264    {
     265      return !exec_prefix.empty ();
     266    }
     267
     268    void
     269    set_flags (const std::string& flags,
     270               const std::string& arch,
     271               const std::string& path,
     272               flag_type          type)
     273    {
     274      std::string* oflags;
     275      switch (type)
     276      {
     277        case ft_cppflags:
     278          oflags = &cppflags;
     279          break;
     280        case ft_cflags:
     281          oflags = &cflags;
     282          break;
     283        case ft_cxxflags:
     284          oflags = &cxxflags;
     285          break;
     286        case ft_ldflags:
     287          oflags = &ldflags;
     288          break;
     289        default:
     290          throw rld::error ("Invalid flag type", "CC set flags");
     291      }
     292      (*oflags) = filter_flags (flags, arch, path, type);
     293    }
     294
     295    void
     296    set_flags (const std::string& flags, flag_type type)
     297    {
     298      std::string arch;
     299      std::string path;
     300      set_flags (flags, arch, path, type);
     301    }
     302
     303    void
     304    append_flags (const std::string& flags,
     305                  const std::string& arch,
     306                  const std::string& path,
     307                  flag_type          type)
     308    {
     309      std::string* oflags;
     310      switch (type)
     311      {
     312        case ft_cppflags:
     313          oflags = &cppflags;
     314          break;
     315        case ft_cflags:
     316          oflags = &cflags;
     317          break;
     318        case ft_cxxflags:
     319          oflags = &cxxflags;
     320          break;
     321        case ft_ldflags:
     322          oflags = &ldflags;
     323          break;
     324        default:
     325          throw rld::error ("Invalid flag type", "CC set flags");
     326      }
     327      if (oflags->empty ())
     328        *oflags += filter_flags (flags, arch, path, type);
     329      else
     330        *oflags += ' ' + filter_flags (flags, arch, path, type);
     331    }
     332
     333    void
     334    append_flags (const std::string& flags, flag_type type)
     335    {
     336      std::string arch;
     337      std::string path;
     338      append_flags (flags, arch, path, type);
     339    }
     340
     341    const std::string
     342    get_flags (flag_type type)
     343    {
     344      std::string* flags;
     345      switch (type)
     346      {
     347        case ft_cppflags:
     348          flags = &cppflags;
     349          break;
     350        case ft_cflags:
     351          flags = &cflags;
     352          break;
     353        case ft_cxxflags:
     354          flags = &cxxflags;
     355          break;
     356        case ft_ldflags:
     357          flags = &ldflags;
     358          break;
     359        default:
     360          throw rld::error ("Invalid flag type", "CC get flags");
     361      }
     362      return *flags;
     363    }
     364
     365    const std::string
     366    get_flags (flag_group group)
     367    {
     368      std::string* flags;
     369      switch (group)
     370      {
     371        case fg_warning_flags:
     372          flags = &warning_cflags;
     373          break;
     374        case fg_include_flags:
     375          flags = &include_cflags;
     376          break;
     377        case fg_machine_flags:
     378          flags = &machine_cflags;
     379          break;
     380        case fg_spec_flags:
     381          flags = &spec_cflags;
     382          break;
     383        default:
     384          throw rld::error ("Invalid flag group", "CC get flags");
     385      }
     386      return *flags;
     387    }
     388
     389    void
     390    append_flags (flag_type type, rld::process::arg_container& args)
     391    {
     392      const std::string* flags = 0;
     393      switch (type)
     394      {
     395        case ft_cppflags:
     396          flags = &cppflags;
     397          break;
     398        case ft_cflags:
     399          flags = &cflags;
     400          break;
     401        case ft_cxxflags:
     402          flags = &cxxflags;
     403          break;
     404        case ft_ldflags:
     405          flags = &ldflags;
     406          break;
     407        default:
     408          throw rld::error ("Invalid flag type", "CC append flags");
     409      }
     410      if (!flags->empty ())
     411        rld::process::args_append (args, *flags);
     412    }
     413
     414    void
     415    make_cc_command (rld::process::arg_container& args)
     416    {
     417      /*
     418       * Use the absolute path to CC if provided.
     419       */
     420      if (!cc.empty ())
     421        args.push_back (cc);
     422      else
     423      {
     424        std::string cmd = cc_name;
     425        if (!exec_prefix.empty ())
     426          cmd = exec_prefix + "-rtems" + rld::rtems_version () + '-' + cmd;
     427        args.push_back (cmd);
     428      }
     429    }
     430
    273431    static bool
    274432    match_and_trim (const char* prefix, std::string& line, std::string& result)
     
    291449
    292450      make_cc_command (args);
    293       add_cppflags (args);
    294       add_cflags (args);
     451      append_flags (ft_cppflags, args);
     452      append_flags (ft_cflags, args);
    295453      args.push_back ("-print-search-dirs");
    296454
     
    340498
    341499      make_cc_command (args);
    342       add_cflags (args);
    343       add_ldflags (args);
     500      append_flags (ft_cppflags, args);
     501      append_flags (ft_cflags, args);
    344502      args.push_back ("-print-file-name=" + name);
    345503
     
    371529    {
    372530      search_dirs ();
    373       rld::split (libraries_path, libpaths, RLD_PATHSTR_SEPARATOR);
     531      rld::split (libpaths, libraries_path, RLD_PATHSTR_SEPARATOR);
    374532    }
    375533
     
    381539      strings libnames;
    382540
    383       rld::split (std_lib_c, libnames, RLD_PATHSTR_SEPARATOR);
     541      rld::split (libnames, std_lib_c, RLD_PATHSTR_SEPARATOR);
    384542      if (cplusplus)
    385543        rld::path::path_split (std_lib_cplusplus, libnames);
  • linkers/rld-cc.h

    ra916fa4 r8807135  
    3636  {
    3737    /*
    38      * Defintion of flags to be filtered.
     38     * The type of flags.
    3939     */
    4040    enum flag_type
     
    4646    };
    4747
    48     extern std::string cc;             //< The CC executable as absolute path.
    49     extern std::string cc_name;        //< The CC name, ie gcc, clang.
    50     extern std::string exec_prefix;    //< The CC executable prefix.
    51 
    52     extern std::string cppflags;       //< The CPP flags.
    53     extern std::string cflags;         //< The CC flags.
    54     extern std::string cxxflags;       //< The CXX flags.
    55     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.
    61 
    62     extern std::string install_path;   //< The CC reported install path.
    63     extern std::string programs_path;  //< The CC reported programs path.
    64     extern std::string libraries_path; //< The CC reported libraries path.
    65 
    66     /**
    67      * Make a CC command from the set arguments.
     48    /*
     49     * Flags groups.
    6850     */
    69     void make_cc_command (rld::process::arg_container& args);
    70 
    71     /**
    72      * If the cppflags has been set append to the arguments.
    73      */
    74     void add_cppflags (rld::process::arg_container& args);
    75 
    76     /**
    77      * If the cflags has been set append to the arguments.
    78      */
    79     void add_cflags (rld::process::arg_container& args);
    80 
    81     /**
    82      * If the cxxflags has been set append to the arguments.
    83      */
    84     void add_cxxflags (rld::process::arg_container& args);
    85 
    86     /**
    87      * If the ldflags has been set append to the arguments.
    88      */
    89     void add_ldflags (rld::process::arg_container& args);
     51    enum flag_group
     52    {
     53      fg_warning_flags,
     54      fg_include_flags,
     55      fg_machine_flags,
     56      fg_spec_flags
     57    };
    9058
    9159    /**
     
    139107
    140108    /**
     109     * Set CC. The exec-prefix is ignored if this is set.
     110     */
     111    void set_cc (const std::string& cc);
     112
     113    /**
     114     * Get the CC.
     115     */
     116    const std::string get_cc ();
     117
     118    /**
     119     * Is the CC set ?
     120     */
     121    bool is_cc_set ();
     122
     123    /**
     124     * Set the exec-prefix. If CC is set the exec-prefix is ignored.
     125     */
     126    void set_exec_prefix (const std::string& exec_prefix);
     127
     128    /**
     129     * Get the exec-prefix.
     130     */
     131    const std::string get_exec_prefix ();
     132
     133    /**
     134     * Is exec-prefix set ?
     135     */
     136    bool is_exec_prefix_set ();
     137
     138    /**
     139     * Set the flags with a specific arch and include path.
     140     */
     141    void set_flags (const std::string& flags,
     142                    const std::string& arch,
     143                    const std::string& path,
     144                    flag_type          type);
     145
     146    /**
     147     * Set the flags.
     148     */
     149    void set_flags (const std::string& flags, flag_type type);
     150
     151    /**
     152     * Append the flags with a specific arch and include path.
     153     */
     154    void append_flags (const std::string& flags,
     155                       const std::string& arch,
     156                       const std::string& path,
     157                       flag_type          type);
     158
     159    /**
     160     * Append the flags.
     161     */
     162    void append_flags (const std::string& flags, flag_type type);
     163
     164    /**
     165     * Get the flags.
     166     */
     167    const std::string get_flags (flag_type type);
     168    const std::string get_flags (flag_group group);
     169
     170    /**
     171     * Append the flags if set.
     172     */
     173    void append_flags (flag_type type, rld::process::arg_container& args);
     174
     175    /**
     176     * Make a CC command from the set arguments.
     177     */
     178    void make_cc_command (rld::process::arg_container& args);
     179
     180    /**
    141181     * Get the standard libraries paths from the compiler.
    142182     */
  • linkers/rld-process.cpp

    ra916fa4 r8807135  
    8888
    8989      std::string name = temp;
     90
     91      name = rld::find_replace (name,
     92                                RLD_PATH_SEPARATOR_STR RLD_PATH_SEPARATOR_STR,
     93                                RLD_PATH_SEPARATOR_STR);
    9094
    9195      tempfiles.push_back (name);
     
    335339    }
    336340
     341    void
     342    args_append (arg_container& args, const std::string& str)
     343    {
     344      rld::strings ss;
     345      rld::split (ss, str);
     346      for (rld::strings::iterator ssi = ss.begin ();
     347           ssi != ss.end ();
     348           ++ssi)
     349      {
     350        args.push_back (*ssi);
     351      }
     352    }
     353
    337354    status
    338355    execute (const std::string& pname,
  • linkers/rld-process.h

    ra916fa4 r8807135  
    181181
    182182    /**
     183     * Split a string and append to the arguments.
     184     */
     185    void args_append (arg_container& args, const std::string& str);
     186
     187    /**
    183188     * Execute result.
    184189     */
  • linkers/rld-rtems.cpp

    ra916fa4 r8807135  
    4949
    5050    const std::string
    51     rtems_bsp (const std::string& ab)
     51    rtems_arch_prefix (const std::string& ab)
    5252    {
    53       const std::string a = arch (ab);
    54       const std::string b = bsp (ab);
    55       return a + "-rtems" + version + '-' + b;
     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);
    5660    }
    5761
     
    6670        throw rld::error ("Not set; see -r", "RTEMS path");
    6771
    68       bsp = rtems_bsp (arch_bsp);
     72      bsp = rtems_arch_bsp (arch_bsp);
    6973
    7074      parts.push_back ("lib");
     
    8791      pkgconfig::package pkg (rtems_pkgconfig);
    8892
     93      /*
     94       * Check the pc file matches what we ask for.
     95       */
     96      std::string name;
     97      if (!pkg.get ("name", name))
     98        throw rld::error ("RTEMS BSP no name in pkgconfig file", arch_bsp);
     99
     100      if (name != bsp)
     101        throw rld::error ("RTEMS BSP does not match the name in pkgconfig file", arch_bsp);
     102
    89103      std::string flags;
    90104
    91105      if (pkg.get ("CPPFLAGS", flags))
    92106      {
    93         rld::cc::cppflags = rld::cc::filter_flags (flags,
    94                                                    arch_bsp,
    95                                                    path,
    96                                                    rld::cc::ft_cppflags);
     107        rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_cppflags);
    97108        if (rld::verbose () >= RLD_VERBOSE_INFO)
    98109          std::cout << " rtems: " << arch_bsp
    99                     << ": CPPFLAGS=" << rld::cc::cppflags << std::endl;
     110                    << ": CPPFLAGS="
     111                    << rld::cc::get_flags (rld::cc::ft_cppflags)
     112                    << std::endl;
    100113      }
    101114
    102115      if (pkg.get ("CFLAGS", flags))
    103116      {
    104         rld::cc::cflags = rld::cc::filter_flags (flags,
    105                                                  arch_bsp,
    106                                                  path,
    107                                                  rld::cc::ft_cflags);
     117        rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_cflags);
    108118        if (rld::verbose () >= RLD_VERBOSE_INFO)
    109119        {
    110120          std::cout << " rtems: " << arch_bsp
    111                     << ": CFLAGS=" << rld::cc::cflags << std::endl;
     121                    << ": CFLAGS=" << rld::cc::get_flags (rld::cc::ft_cflags)
     122                    << std::endl;
    112123          std::cout << " rtems: " << arch_bsp
    113                     << ": WARNINGS=" << rld::cc::warning_cflags << std::endl;
     124                    << ": WARNINGS=" << rld::cc::get_flags (rld::cc::fg_warning_flags)
     125                    << std::endl;
    114126          std::cout << " rtems: " << arch_bsp
    115                     << ": INCLUDES=" << rld::cc::include_cflags << std::endl;
     127                    << ": INCLUDES=" << rld::cc::get_flags (rld::cc::fg_include_flags)
     128                    << std::endl;
    116129          std::cout << " rtems: " << arch_bsp
    117                     << ": MACHINES=" << rld::cc::machine_cflags << std::endl;
     130                    << ": MACHINES=" << rld::cc::get_flags (rld::cc::fg_machine_flags)
     131                    << std::endl;
    118132          std::cout << " rtems: " << arch_bsp
    119                     << ": SPECS=" << rld::cc::spec_cflags << std::endl;
     133                    << ": SPECS=" << rld::cc::get_flags (rld::cc::fg_spec_flags)
     134                    << std::endl;
    120135        }
    121136      }
     
    123138      if (pkg.get ("CXXFLAGS", flags))
    124139      {
    125         rld::cc::cxxflags = rld::cc::filter_flags (flags,
    126                                                    arch_bsp,
    127                                                    path,
    128                                                    rld::cc::ft_cxxflags);
     140        rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_cxxflags);
    129141        if (rld::verbose () >= RLD_VERBOSE_INFO)
    130142          std::cout << " rtems: " << arch_bsp
    131                     << ": CXXFLAGS=" << rld::cc::cxxflags << std::endl;
     143                    << ": CXXFLAGS=" << rld::cc::get_flags (rld::cc::ft_cxxflags)
     144                    << std::endl;
    132145      }
    133146
    134147      if (pkg.get ("LDFLAGS", flags))
    135148      {
    136         rld::cc::ldflags = rld::cc::filter_flags (flags,
    137                                                   arch_bsp,
    138                                                   path,
    139                                                   rld::cc::ft_ldflags);
     149        rld::cc::append_flags (flags, arch (arch_bsp), path, rld::cc::ft_ldflags);
    140150        if (rld::verbose () >= RLD_VERBOSE_INFO)
    141151          std::cout << " rtems: " << arch_bsp
    142                     << ": LDFLAGS=" << rld::cc::ldflags << std::endl;
     152                    << ": LDFLAGS=" << rld::cc::get_flags (rld::cc::ft_ldflags)
     153                    << std::endl;
    143154      }
     155
     156      rld::cc::set_exec_prefix (arch (arch_bsp));
    144157    }
    145158  }
  • linkers/rtems-ld.cpp

    ra916fa4 r8807135  
    191191    std::string          outra;
    192192    std::string          base_name;
    193     std::string          cc_name;
    194193    std::string          output_type = "rap";
    195194    bool                 standard_libs = true;
    196     bool                 exec_prefix_set = false;
    197195    bool                 map = false;
    198196    bool                 warnings = false;
     
    269267
    270268        case 'C':
    271           if (exec_prefix_set == true)
     269          if (rld::cc::is_exec_prefix_set ())
    272270            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
    273           rld::cc::cc = optarg;
     271          rld::cc::set_cc (optarg);
    274272          break;
    275273
    276274        case 'E':
    277           exec_prefix_set = true;
    278           rld::cc::exec_prefix = optarg;
     275          if (rld::cc::is_cc_set ())
     276            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
     277          rld::cc::set_exec_prefix (optarg);
    279278          break;
    280279
    281280        case 'c':
    282           rld::cc::cflags = optarg;
     281          rld::cc::set_flags (optarg, rld::cc::ft_cflags);
    283282          break;
    284283
     
    398397     * are used when detecting.
    399398     */
    400     if (rld::cc::cc.empty () && !exec_prefix_set)
    401       rld::cc::exec_prefix = rld::elf::machine_type ();
     399    if (!rld::cc::is_cc_set () && !rld::cc::is_exec_prefix_set ())
     400      rld::cc::set_exec_prefix (rld::elf::machine_type ());
    402401
    403402    /*
  • linkers/rtems-ra.cpp

    ra916fa4 r8807135  
    168168    std::string             output = "a.ra";
    169169    bool                    standard_libs = true;
    170     bool                    exec_prefix_set = false;
    171170    bool                    convert = true;
    172171    rld::files::object_list dependents;
     
    242241
    243242        case 'C':
    244           if (exec_prefix_set == true)
     243          if (rld::cc::is_exec_prefix_set ())
    245244            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
    246           rld::cc::cc = optarg;
     245          rld::cc::set_cc (optarg);
    247246          break;
    248247
    249248        case 'E':
    250           exec_prefix_set = true;
    251           rld::cc::exec_prefix = optarg;
     249          if (rld::cc::is_cc_set ())
     250            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
     251          rld::cc::set_exec_prefix (optarg);
    252252          break;
    253253
    254254        case 'c':
    255           rld::cc::cflags = optarg;
     255          rld::cc::set_flags (optarg, rld::cc::ft_cflags);
    256256          break;
    257257
     
    297297     * are used when detecting.
    298298     */
    299     if (rld::cc::cc.empty () && !exec_prefix_set)
    300       rld::cc::exec_prefix = rld::elf::machine_type ();
     299    if (!rld::cc::is_cc_set () && !rld::cc::is_exec_prefix_set ())
     300      rld::cc::set_exec_prefix (rld::elf::machine_type ());
    301301
    302302    if (convert)
  • linkers/rtems-syms.cpp

    ra916fa4 r8807135  
    139139    std::string         cc_name;
    140140    bool                standard_libs = false;
    141     bool                exec_prefix_set = false;
    142141#if HAVE_WARNINGS
    143142    bool                warnings = false;
     
    189188
    190189        case 'C':
    191           if (exec_prefix_set == true)
     190          if (rld::cc::is_exec_prefix_set ())
    192191            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
    193           rld::cc::cc = optarg;
     192          rld::cc::set_cc (optarg);
    194193          break;
    195194
    196195        case 'E':
    197           exec_prefix_set = true;
    198           rld::cc::exec_prefix = optarg;
     196          if (rld::cc::is_cc_set ())
     197            std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
     198          rld::cc::set_exec_prefix (optarg);
    199199          break;
    200200
    201201        case 'c':
    202           rld::cc::cflags = optarg;
     202          rld::cc::set_flags (optarg, rld::cc::ft_cflags);
    203203          break;
    204204
     
    247247     * are used when detecting.
    248248     */
    249     if (rld::cc::cc.empty () && !exec_prefix_set)
    250       rld::cc::exec_prefix = rld::elf::machine_type ();
     249    if (!rld::cc::is_cc_set () && !rld::cc::is_exec_prefix_set ())
     250      rld::cc::set_exec_prefix (rld::elf::machine_type ());
    251251
    252252    /*
  • linkers/rtems-tld.cpp

    ra916fa4 r8807135  
    187187       * Generate the wrapper object file.
    188188       */
    189       void generate ();
     189      const std::string generate ();
    190190
    191191      /**
     
    228228
    229229      /**
     230       * Compile the C file.
     231       */
     232      void compile_wrapper ();
     233
     234      /**
    230235       * Dump the linker.
    231236       */
     
    234239    private:
    235240
    236       rld::config::config config;   /**< User configuration. */
    237       tracer              tracer_;  /**< The tracer */
     241      rld::config::config config;     /**< User configuration. */
     242      tracer              tracer_;    /**< The tracer */
     243      std::string         wrapper_c;  /**< Wrapper C source file. */
     244      std::string         wrapper_o;  /**< Wrapper object file. */
    238245    };
    239246
     
    537544    }
    538545
    539     void
     546    const std::string
    540547    tracer::generate ()
    541548    {
     
    572579
    573580      c.close ();
     581
     582      return c.name ();
    574583    }
    575584
     
    707716    linker::generate_wrapper ()
    708717    {
    709       tracer_.generate ();
     718      wrapper_c = tracer_.generate ();
     719    }
     720
     721    void
     722    linker::compile_wrapper ()
     723    {
     724     rld::process::arg_container args;
     725
     726      rld::process::tempfile o (".o");
     727
     728      if (rld::verbose ())
     729        std::cout << "wrapper O file: " << o.name () << std::endl;
     730
     731      rld::cc::make_cc_command (args);
     732      rld::cc::append_flags (rld::cc::ft_cflags, args);
     733
     734      args.push_back ("-c");
     735      args.push_back ("-o ");
     736      args.push_back (o.name ());
     737      args.push_back (wrapper_c);
     738
     739      rld::process::tempfile out;
     740      rld::process::tempfile err;
     741      rld::process::status   status;
     742
     743      status = rld::process::execute (rld::cc::get_cc (),
     744                                      args,
     745                                      out.name (),
     746                                      err.name ());
     747
     748      if ((status.type != rld::process::status::normal) ||
     749          (status.code != 0))
     750      {
     751        err.output (rld::cc::get_cc (), std::cout);
     752        throw rld::error ("Compiler error", "compiling wrapper");
     753      }
     754
     755      wrapper_o = o.name ();
    710756    }
    711757
     
    812858    std::string        configuration;
    813859    std::string        trace = "tracer";
    814     bool               exec_prefix_set = false;
    815860    bool               arch_bsp_load = false;
    816861
     
    844889
    845890        case 'E':
    846           exec_prefix_set = true;
    847           rld::cc::exec_prefix = optarg;
     891          rld::cc::set_exec_prefix (optarg);
    848892          break;
    849893
    850894        case 'c':
    851           rld::cc::cflags = optarg;
     895          rld::cc::append_flags (optarg, rld::cc::ft_cflags);
    852896          break;
    853897
     
    910954      linker.load_config (configuration, trace);
    911955      linker.generate_wrapper ();
     956      linker.compile_wrapper ();
    912957
    913958      if (rld::verbose ())
  • linkers/rtld-base.ini

    ra916fa4 r8807135  
    2323                                     const  char* arg_type,
    2424                                     int    arg_size,
    25                                      void*  arg
     25                                     void*  arg)
    2626{
    2727  const char* p = arg;
Note: See TracChangeset for help on using the changeset viewer.