mirror of
https://git.rtems.org/rtems-tools/
synced 2025-05-16 11:16:38 +08:00
39f48c9047
This change added the object file details to the RAP format so aid debugging support. The information can be optionally stripped for production images not needed this information if space is an issue,with '--rap-strip' assigned to rtems-ld.
499 lines
15 KiB
C++
499 lines
15 KiB
C++
/*
|
|
* Copyright (c) 2011-2012, Chris Johns <chrisj@rtems.org>
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
/**
|
|
* @file
|
|
*
|
|
* @ingroup rtems_rld
|
|
*
|
|
* @brief RTEMS Linker Main manages opions, sequence of operations and exceptions.
|
|
*
|
|
*/
|
|
|
|
#if HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <iostream>
|
|
|
|
#include <cxxabi.h>
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <getopt.h>
|
|
|
|
#include <rld.h>
|
|
#include <rld-cc.h>
|
|
#include <rld-rap.h>
|
|
#include <rld-outputter.h>
|
|
#include <rld-process.h>
|
|
#include <rld-resolver.h>
|
|
|
|
#ifndef HAVE_KILL
|
|
#define kill(p,s) raise(s)
|
|
#endif
|
|
|
|
/**
|
|
* RTEMS Linker options. This needs to be rewritten to be like cc where only a
|
|
* single '-' and long options is present.
|
|
*/
|
|
static struct option rld_opts[] = {
|
|
{ "help", no_argument, NULL, 'h' },
|
|
{ "version", no_argument, NULL, 'V' },
|
|
{ "verbose", no_argument, NULL, 'v' },
|
|
{ "warn", no_argument, NULL, 'w' },
|
|
{ "map", no_argument, NULL, 'M' },
|
|
{ "output", required_argument, NULL, 'o' },
|
|
{ "out-format", required_argument, NULL, 'O' },
|
|
{ "lib-path", required_argument, NULL, 'L' },
|
|
{ "lib", required_argument, NULL, 'l' },
|
|
{ "no-stdlibs", no_argument, NULL, 'n' },
|
|
{ "entry", required_argument, NULL, 'e' },
|
|
{ "define", required_argument, NULL, 'd' },
|
|
{ "undefined", required_argument, NULL, 'u' },
|
|
{ "base", required_argument, NULL, 'b' },
|
|
{ "cc", required_argument, NULL, 'C' },
|
|
{ "exec-prefix", required_argument, NULL, 'E' },
|
|
{ "march", required_argument, NULL, 'a' },
|
|
{ "mcpu", required_argument, NULL, 'c' },
|
|
{ "rap-strip", no_argument, NULL, 'S' },
|
|
{ NULL, 0, NULL, 0 }
|
|
};
|
|
|
|
#if TO_BE_USED_FOR_THE_UNDEFINES
|
|
void
|
|
split_on_equals (const std::string& opt, std::string& left, std::string& right)
|
|
{
|
|
std::string::size_type eq = opt.find_first_of('=');
|
|
}
|
|
#endif
|
|
|
|
void
|
|
usage (int exit_code)
|
|
{
|
|
std::cout << "rtems-ld [options] objects" << std::endl
|
|
<< "Options and arguments:" << std::endl
|
|
<< " -h : help (also --help)" << std::endl
|
|
<< " -V : print linker version number and exit (also --version)" << std::endl
|
|
<< " -v : verbose (trace import parts), can supply multiple times" << std::endl
|
|
<< " to increase verbosity (also --verbose)" << std::endl
|
|
<< " -w : generate warnings (also --warn)" << std::endl
|
|
<< " -M : generate map output (also --map)" << std::endl
|
|
<< " -o file : linker output is written to file (also --output)" << std::endl
|
|
<< " -O format : linker output format, default is 'rap' (also --out-format)" << std::endl
|
|
<< " -L path : path to a library, add multiple for more than" << std::endl
|
|
<< " one path (also --lib-path)" << std::endl
|
|
<< " -l lib : add lib to the libraries searched, add multiple" << std::endl
|
|
<< " for more than one library (also --lib)" << std::endl
|
|
<< " -n : do not search standard libraries (also --no-stdlibs)" << std::endl
|
|
<< " -e entry : entry point symbol (also --entry)" << std::endl
|
|
<< " -d sym : add the symbol definition, add multiple with" << std::endl
|
|
<< " more than one define (also --define)" << std::endl
|
|
<< " -u sym : add the undefined symbol definition, add multiple" << std::endl
|
|
<< " for more than one undefined symbol (also --undefined)" << std::endl
|
|
<< " -b elf : read the ELF file symbols as the base RTEMS kernel" << std::endl
|
|
<< " image (also --base)" << std::endl
|
|
<< " -C file : execute file as the target C compiler (also --cc)" << std::endl
|
|
<< " -E prefix : the RTEMS tool prefix (also --exec-prefix)" << std::endl
|
|
<< " -a march : machine architecture (also --march)" << std::endl
|
|
<< " -c cpu : machine architecture's CPU (also --mcpu)" << std::endl
|
|
<< " -S : do not include file details (also --rap-strip)" << std::endl
|
|
<< " -Wl,opts : link compatible flags, ignored" << std::endl
|
|
<< "Output Formats:" << std::endl
|
|
<< " rap - RTEMS application (LZ77, single image)" << std::endl
|
|
<< " elf - ELF application (script, ELF files)" << std::endl
|
|
<< " script - Script format (list of object files)" << std::endl
|
|
<< " archive - Archive format (collection of ELF files)" << std::endl;
|
|
::exit (exit_code);
|
|
}
|
|
|
|
static void
|
|
fatal_signal (int signum)
|
|
{
|
|
signal (signum, SIG_DFL);
|
|
|
|
rld::process::temporaries.clean_up ();
|
|
|
|
/*
|
|
* Get the same signal again, this time not handled, so its normal effect
|
|
* occurs.
|
|
*/
|
|
kill (getpid (), signum);
|
|
}
|
|
|
|
static void
|
|
setup_signals (void)
|
|
{
|
|
if (signal (SIGINT, SIG_IGN) != SIG_IGN)
|
|
signal (SIGINT, fatal_signal);
|
|
#ifdef SIGHUP
|
|
if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
|
|
signal (SIGHUP, fatal_signal);
|
|
#endif
|
|
if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
|
|
signal (SIGTERM, fatal_signal);
|
|
#ifdef SIGPIPE
|
|
if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
|
|
signal (SIGPIPE, fatal_signal);
|
|
#endif
|
|
#ifdef SIGCHLD
|
|
signal (SIGCHLD, SIG_DFL);
|
|
#endif
|
|
}
|
|
|
|
int
|
|
main (int argc, char* argv[])
|
|
{
|
|
int ec = 0;
|
|
|
|
setup_signals ();
|
|
|
|
try
|
|
{
|
|
rld::files::cache cache;
|
|
rld::files::cache base;
|
|
rld::files::paths libpaths;
|
|
rld::files::paths libs;
|
|
rld::files::paths objects;
|
|
rld::files::paths libraries;
|
|
rld::symbols::bucket defines;
|
|
rld::symbols::bucket undefines;
|
|
rld::symbols::table base_symbols;
|
|
rld::symbols::table symbols;
|
|
rld::symbols::symtab undefined;
|
|
std::string entry = "rtems";
|
|
std::string exit;
|
|
std::string output = "a.out";
|
|
std::string base_name;
|
|
std::string cc_name;
|
|
std::string output_type = "rap";
|
|
bool standard_libs = true;
|
|
bool exec_prefix_set = false;
|
|
bool map = false;
|
|
bool warnings = false;
|
|
|
|
libpaths.push_back (".");
|
|
|
|
while (true)
|
|
{
|
|
int opt = ::getopt_long (argc, argv, "hvwVMnb:E:o:O:L:l:a:c:e:d:u:C:W:", rld_opts, NULL);
|
|
if (opt < 0)
|
|
break;
|
|
|
|
switch (opt)
|
|
{
|
|
case 'V':
|
|
std::cout << "rtems-ld (RTEMS Linker) " << rld::version ()
|
|
<< std::endl;
|
|
::exit (0);
|
|
break;
|
|
|
|
case 'v':
|
|
rld::verbose_inc ();
|
|
break;
|
|
|
|
case 'M':
|
|
map = true;
|
|
break;
|
|
|
|
case 'w':
|
|
warnings = true;
|
|
break;
|
|
|
|
case 'o':
|
|
if (output != "a.out")
|
|
std::cerr << "warning: output already set" << std::endl;
|
|
output = optarg;
|
|
break;
|
|
|
|
case 'O':
|
|
output_type = optarg;
|
|
break;
|
|
|
|
case 'l':
|
|
/*
|
|
* The order is important. It is the search order.
|
|
*/
|
|
libs.push_back (optarg);
|
|
break;
|
|
|
|
case 'L':
|
|
if ((optarg[::strlen (optarg) - 1] == '/') ||
|
|
(optarg[::strlen (optarg) - 1] == '\\'))
|
|
optarg[::strlen (optarg) - 1] = '\0';
|
|
libpaths.push_back (optarg);
|
|
break;
|
|
|
|
case 'n':
|
|
standard_libs = false;
|
|
break;
|
|
|
|
case 'C':
|
|
if (exec_prefix_set == true)
|
|
std::cerr << "warning: exec-prefix ignored when CC provided" << std::endl;
|
|
rld::cc::cc = optarg;
|
|
break;
|
|
|
|
case 'E':
|
|
exec_prefix_set = true;
|
|
rld::cc::exec_prefix = optarg;
|
|
break;
|
|
|
|
case 'a':
|
|
rld::cc::march = optarg;
|
|
break;
|
|
|
|
case 'c':
|
|
rld::cc::mcpu = optarg;
|
|
break;
|
|
|
|
case 'e':
|
|
entry = optarg;
|
|
break;
|
|
|
|
case 'd':
|
|
defines.push_back (rld::symbols::symbol (optarg));
|
|
break;
|
|
|
|
case 'u':
|
|
undefines.push_back (rld::symbols::symbol (optarg));
|
|
break;
|
|
|
|
case 'b':
|
|
base_name = optarg;
|
|
break;
|
|
|
|
case 'S':
|
|
rld::rap::add_obj_details = false;
|
|
break;
|
|
|
|
case 'W':
|
|
/* ignore linker compatiable flags */
|
|
break;
|
|
|
|
case '?':
|
|
usage (3);
|
|
break;
|
|
|
|
case 'h':
|
|
usage (0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (rld::verbose () || map)
|
|
std::cout << "RTEMS Linker " << rld::version () << std::endl;
|
|
|
|
/*
|
|
* If there are no object files there is nothing to link.
|
|
*/
|
|
if ((argc == 0) && !map)
|
|
throw rld::error ("no object files", "options");
|
|
|
|
/*
|
|
* Check the output format is valid.
|
|
*/
|
|
if ((output_type != "rap") &&
|
|
(output_type != "elf") &&
|
|
(output_type != "script") &&
|
|
(output_type != "archive"))
|
|
throw rld::error ("invalid output format", "options");
|
|
|
|
/*
|
|
* Load the remaining command line arguments into the cache as object
|
|
* files.
|
|
*/
|
|
while (argc--)
|
|
objects.push_back (*argv++);
|
|
|
|
/*
|
|
* The 'entry' point symbol needs to be added to the undefines so it is
|
|
* resolved.
|
|
*/
|
|
undefines.push_back (rld::symbols::symbol (entry));
|
|
|
|
/*
|
|
* Load the symbol table with the defined symbols from the defines bucket.
|
|
*/
|
|
rld::symbols::load (defines, symbols);
|
|
|
|
/*
|
|
* Load the undefined table with the undefined symbols from the undefines
|
|
* bucket.
|
|
*/
|
|
rld::symbols::load (undefines, undefined);
|
|
|
|
/*
|
|
* Add the object files to the cache.
|
|
*/
|
|
cache.add (objects);
|
|
|
|
/*
|
|
* Open the cache.
|
|
*/
|
|
cache.open ();
|
|
|
|
/*
|
|
* If the full path to CC is not provided and the exec-prefix is not set by
|
|
* the command line see if it can be detected from the object file
|
|
* types. This must be after we have added the object files because they
|
|
* are used when detecting.
|
|
*/
|
|
if (rld::cc::cc.empty () && !exec_prefix_set)
|
|
rld::cc::exec_prefix = rld::elf::machine_type ();
|
|
|
|
/*
|
|
* If we have a base image add it.
|
|
*/
|
|
if (base_name.length ())
|
|
{
|
|
if (rld::verbose ())
|
|
std::cout << "base-image: " << base_name << std::endl;
|
|
base.open ();
|
|
base.add (base_name);
|
|
base.load_symbols (base_symbols, true);
|
|
}
|
|
|
|
/*
|
|
* Get the standard library paths
|
|
*/
|
|
if (standard_libs)
|
|
rld::cc::get_standard_libpaths (libpaths);
|
|
|
|
/*
|
|
* Get the command line libraries.
|
|
*/
|
|
rld::files::find_libraries (libraries, libpaths, libs);
|
|
|
|
/*
|
|
* Are we to load standard libraries ?
|
|
*/
|
|
if (standard_libs)
|
|
rld::cc::get_standard_libs (libraries, libpaths);
|
|
|
|
/*
|
|
* Load the library to the cache.
|
|
*/
|
|
cache.add_libraries (libraries);
|
|
|
|
/*
|
|
* Begin the archive session. This opens the archives and leaves them open
|
|
* while we the symbol table is being used. The symbols reference object
|
|
* files and the object files may reference archives and it is assumed they
|
|
* are open and available. It is also assumed the number of library
|
|
* archives being managed is less than the maximum file handles this
|
|
* process can have open at any one time. If this is not the case this
|
|
* approach would need to be reconsidered and the overhead of opening and
|
|
* closing archives added.
|
|
*/
|
|
try
|
|
{
|
|
cache.archives_begin ();
|
|
|
|
/*
|
|
* Load the symbol table.
|
|
*/
|
|
cache.load_symbols (symbols);
|
|
|
|
/*
|
|
* Map ?
|
|
*/
|
|
if (map)
|
|
{
|
|
if (base_name.length ())
|
|
rld::map (base, base_symbols);
|
|
rld::map (cache, symbols);
|
|
}
|
|
|
|
if (cache.path_count ())
|
|
{
|
|
/*
|
|
* This structure allows us to add different operations with the same
|
|
* structure.
|
|
*/
|
|
rld::files::object_list dependents;
|
|
rld::resolver::resolve (dependents, cache,
|
|
base_symbols, symbols, undefined);
|
|
|
|
/**
|
|
* Output the file.
|
|
*/
|
|
if (output_type == "script")
|
|
rld::outputter::script (output, entry, exit, dependents, cache);
|
|
else if (output_type == "archive")
|
|
rld::outputter::archive (output, entry, exit, dependents, cache);
|
|
else if (output_type == "elf")
|
|
rld::outputter::elf_application (output, entry, exit,
|
|
dependents, cache);
|
|
else if (output_type == "rap")
|
|
rld::outputter::application (output, entry, exit,
|
|
dependents, cache, symbols);
|
|
else
|
|
throw rld::error ("invalid output type", "output");
|
|
|
|
/**
|
|
* Check for warnings.
|
|
*/
|
|
if (warnings)
|
|
{
|
|
rld::warn_unused_externals (dependents);
|
|
}
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
cache.archives_end ();
|
|
throw;
|
|
}
|
|
|
|
cache.archives_end ();
|
|
}
|
|
catch (rld::error re)
|
|
{
|
|
std::cerr << "error: "
|
|
<< re.where << ": " << re.what
|
|
<< std::endl;
|
|
ec = 10;
|
|
}
|
|
catch (std::exception e)
|
|
{
|
|
int status;
|
|
char* realname;
|
|
realname = abi::__cxa_demangle (e.what(), 0, 0, &status);
|
|
std::cerr << "error: exception: " << realname << " [";
|
|
::free (realname);
|
|
const std::type_info &ti = typeid (e);
|
|
realname = abi::__cxa_demangle (ti.name(), 0, 0, &status);
|
|
std::cerr << realname << "] " << e.what () << std::endl << std::flush;
|
|
::free (realname);
|
|
ec = 11;
|
|
}
|
|
catch (...)
|
|
{
|
|
/*
|
|
* Helps to know if this happens.
|
|
*/
|
|
std::cerr << "error: unhandled exception" << std::endl;
|
|
ec = 12;
|
|
}
|
|
|
|
return ec;
|
|
}
|