|
 |
2bd749 |
/*******************************************************************/
|
|
|
2bd749 |
/* slibtool: a skinny libtool implementation, written in C */
|
|
|
6803d8 |
/* Copyright (C) 2016--2018 Z. Gilboa */
|
|
|
2bd749 |
/* Released under the Standard MIT License; see COPYING.SLIBTOOL. */
|
|
|
2bd749 |
/*******************************************************************/
|
|
|
2bd749 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
#include <stdarg.h>
|
|
|
8b7d50 |
#include <stdlib.h>
|
|
|
f0d5f3 |
#include <stdio.h>
|
|
|
2bd749 |
#include <string.h>
|
|
|
2bd749 |
#include <stdbool.h>
|
|
|
2bd749 |
#include <fcntl.h>
|
|
|
2bd749 |
#include <errno.h>
|
|
|
2bd749 |
#include <sys/stat.h>
|
|
|
2bd749 |
|
|
|
2bd749 |
#include <slibtool/slibtool.h>
|
|
|
2bd749 |
#include "slibtool_spawn_impl.h"
|
|
|
3895af |
#include "slibtool_mkdir_impl.h"
|
|
|
9706fa |
#include "slibtool_driver_impl.h"
|
|
|
c178e3 |
#include "slibtool_dprintf_impl.h"
|
|
|
9c9f28 |
#include "slibtool_errinfo_impl.h"
|
|
|
05ea52 |
#include "slibtool_mapfile_impl.h"
|
|
|
a9cfe4 |
#include "slibtool_metafile_impl.h"
|
|
|
50b6ef |
#include "slibtool_readlink_impl.h"
|
|
|
6529aa |
#include "slibtool_symlink_impl.h"
|
|
|
2bd749 |
|
|
|
8b7d50 |
struct slbt_deps_meta {
|
|
|
8b7d50 |
char ** altv;
|
|
|
8b7d50 |
char * args;
|
|
|
8b7d50 |
int depscnt;
|
|
|
8b7d50 |
int infolen;
|
|
|
8b7d50 |
};
|
|
|
8b7d50 |
|
|
|
5cc3b3 |
/*******************************************************************/
|
|
|
5cc3b3 |
/* */
|
|
|
5cc3b3 |
/* -o <ltlib> switches input result */
|
|
|
5cc3b3 |
/* ---------- --------------------- ----- ------ */
|
|
|
b07789 |
/* libfoo.a [-shared|-static] bar.lo libfoo.a */
|
|
|
5cc3b3 |
/* */
|
|
|
0330cf |
/* ar crs libfoo.a bar.o */
|
|
|
5cc3b3 |
/* */
|
|
|
5cc3b3 |
/*******************************************************************/
|
|
|
5cc3b3 |
|
|
|
a0c318 |
/*******************************************************************/
|
|
|
a0c318 |
/* */
|
|
|
a0c318 |
/* -o <ltlib> switches input result */
|
|
|
a0c318 |
/* ---------- --------------------- ----- ------ */
|
|
|
a0c318 |
/* libfoo.la -shared bar.lo libfoo.la */
|
|
|
a0c318 |
/* .libs/libfoo.a */
|
|
|
a0c318 |
/* .libs/libfoo.la (lnk) */
|
|
|
a0c318 |
/* */
|
|
|
0330cf |
/* ar crs .libs/libfoo.a .libs/bar.o */
|
|
|
a0c318 |
/* (generate libfoo.la) */
|
|
|
a0c318 |
/* ln -s ../libfoo.la .libs/libfoo.la */
|
|
|
f730ac |
/* */
|
|
|
f730ac |
/*******************************************************************/
|
|
|
f730ac |
|
|
|
f730ac |
/*******************************************************************/
|
|
|
f730ac |
/* */
|
|
|
f730ac |
/* -o <ltlib> switches input result */
|
|
|
f730ac |
/* ---------- --------------------- ----- ------ */
|
|
|
f730ac |
/* libfoo.la -static bar.lo libfoo.la */
|
|
|
f730ac |
/* .libs/libfoo.a */
|
|
|
f730ac |
/* .libs/libfoo.la (lnk) */
|
|
|
f730ac |
/* */
|
|
|
0330cf |
/* ar crs .libs/libfoo.a bar.o */
|
|
|
f730ac |
/* (generate libfoo.la) */
|
|
|
f730ac |
/* ln -s ../libfoo.la .libs/libfoo.la */
|
|
|
a0c318 |
/* */
|
|
|
a0c318 |
/*******************************************************************/
|
|
|
a0c318 |
|
|
|
3be47d |
static int slbt_exec_link_exit(
|
|
|
3be47d |
struct slbt_deps_meta * depsmeta,
|
|
|
3be47d |
int ret)
|
|
|
3be47d |
{
|
|
|
3be47d |
if (depsmeta->altv)
|
|
|
3be47d |
free(depsmeta->altv);
|
|
|
3be47d |
|
|
|
3be47d |
if (depsmeta->args)
|
|
|
3be47d |
free(depsmeta->args);
|
|
|
3be47d |
|
|
|
3be47d |
return ret;
|
|
|
3be47d |
}
|
|
|
3be47d |
|
|
|
8b7d50 |
static int slbt_get_deps_meta(
|
|
|
9c9f28 |
const struct slbt_driver_ctx * dctx,
|
|
|
ba8a74 |
char * libfilename,
|
|
|
ba8a74 |
int fexternal,
|
|
|
ba8a74 |
struct slbt_deps_meta * depsmeta)
|
|
|
8b7d50 |
{
|
|
|
5fac6c |
int fdcwd;
|
|
|
05ea52 |
char * ch;
|
|
|
05ea52 |
char * cap;
|
|
|
05ea52 |
char * base;
|
|
|
05ea52 |
size_t libexlen;
|
|
|
05ea52 |
struct stat st;
|
|
|
05ea52 |
struct slbt_map_info * mapinfo;
|
|
|
05ea52 |
char depfile[PATH_MAX];
|
|
|
9c9f28 |
|
|
|
7ae5c1 |
/* fdcwd */
|
|
|
7ae5c1 |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
7ae5c1 |
|
|
|
0f5ca7 |
/* -rpath */
|
|
|
05ea52 |
if ((size_t)snprintf(depfile,sizeof(depfile),
|
|
|
05ea52 |
"%s.slibtool.rpath",
|
|
|
0f5ca7 |
libfilename)
|
|
|
0f5ca7 |
>= sizeof(depfile))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
0f5ca7 |
|
|
|
05ea52 |
/* -Wl,%s */
|
|
|
7ae5c1 |
if (!fstatat(fdcwd,depfile,&st,AT_SYMLINK_NOFOLLOW)) {
|
|
|
0f5ca7 |
depsmeta->infolen += st.st_size + 4;
|
|
|
0f5ca7 |
depsmeta->infolen++;
|
|
|
0f5ca7 |
}
|
|
|
0f5ca7 |
|
|
|
0f5ca7 |
/* .deps */
|
|
|
05ea52 |
if ((size_t)snprintf(depfile,sizeof(depfile),
|
|
|
05ea52 |
"%s.slibtool.deps",
|
|
|
8b7d50 |
libfilename)
|
|
|
8b7d50 |
>= sizeof(depfile))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
8b7d50 |
|
|
|
05ea52 |
/* mapinfo */
|
|
|
5fac6c |
if (!(mapinfo = slbt_map_file(fdcwd,depfile,SLBT_MAP_INPUT)))
|
|
|
ba8a74 |
return (fexternal && (errno == ENOENT))
|
|
|
6beda1 |
? 0 : SLBT_SYSTEM_ERROR(dctx,depfile);
|
|
|
8b7d50 |
|
|
|
05ea52 |
/* copied length */
|
|
|
05ea52 |
depsmeta->infolen += mapinfo->size;
|
|
|
8b7d50 |
depsmeta->infolen++;
|
|
|
8b7d50 |
|
|
|
05ea52 |
/* libexlen */
|
|
|
05ea52 |
libexlen = (base = strrchr(libfilename,'/'))
|
|
|
05ea52 |
? strlen(depfile) + 2 + (base - libfilename)
|
|
|
05ea52 |
: strlen(depfile) + 2;
|
|
|
e64108 |
|
|
|
05ea52 |
/* iterate */
|
|
|
05ea52 |
ch = mapinfo->addr;
|
|
|
05ea52 |
cap = mapinfo->cap;
|
|
|
6fda2b |
|
|
|
05ea52 |
for (; ch
|
|
|
86b72f |
if (*ch++ == '\n') {
|
|
|
05ea52 |
depsmeta->infolen += libexlen;
|
|
|
05ea52 |
depsmeta->depscnt++;
|
|
|
05ea52 |
}
|
|
|
78abd7 |
}
|
|
|
8b7d50 |
|
|
|
05ea52 |
slbt_unmap_file(mapinfo);
|
|
|
085f3a |
|
|
|
05ea52 |
return 0;
|
|
|
8b7d50 |
}
|
|
|
8b7d50 |
|
|
|
932031 |
static bool slbt_adjust_object_argument(
|
|
|
14d60a |
char * arg,
|
|
|
2fd6a3 |
bool fpic,
|
|
|
2fd6a3 |
bool fany,
|
|
|
2fd6a3 |
int fdcwd)
|
|
|
5cc3b3 |
{
|
|
|
53aa85 |
char * slash;
|
|
|
5cc3b3 |
char * dot;
|
|
|
53aa85 |
char base[PATH_MAX];
|
|
|
5cc3b3 |
|
|
|
5cc3b3 |
if (*arg == '-')
|
|
|
5cc3b3 |
return false;
|
|
|
5cc3b3 |
|
|
|
2fd6a3 |
/* object argument: foo.lo or foo.o */
|
|
|
5cc3b3 |
if (!(dot = strrchr(arg,'.')))
|
|
|
5cc3b3 |
return false;
|
|
|
5cc3b3 |
|
|
|
2fd6a3 |
if ((dot[1]=='l') && (dot[2]=='o') && !dot[3]) {
|
|
|
2fd6a3 |
dot[1] = 'o';
|
|
|
2fd6a3 |
dot[2] = 0;
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
} else if ((dot[1]=='o') && !dot[2]) {
|
|
|
2fd6a3 |
(void)0;
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
} else {
|
|
|
5cc3b3 |
return false;
|
|
|
2fd6a3 |
}
|
|
|
5cc3b3 |
|
|
|
2fd6a3 |
/* foo.o requested and is present? */
|
|
|
2fd6a3 |
if (!fpic && !faccessat(fdcwd,arg,0,0))
|
|
|
2fd6a3 |
return true;
|
|
|
53aa85 |
|
|
|
2fd6a3 |
/* .libs/foo.o */
|
|
|
2fd6a3 |
if ((slash = strrchr(arg,'/')))
|
|
|
2fd6a3 |
slash++;
|
|
|
2fd6a3 |
else
|
|
|
2fd6a3 |
slash = arg;
|
|
|
53aa85 |
|
|
|
2fd6a3 |
if ((size_t)snprintf(base,sizeof(base),"%s",
|
|
|
2fd6a3 |
slash) >= sizeof(base))
|
|
|
2fd6a3 |
return false;
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
sprintf(slash,".libs/%s",base);
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
if (!faccessat(fdcwd,arg,0,0))
|
|
|
2fd6a3 |
return true;
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
/* foo.o requested and neither is present? */
|
|
|
2fd6a3 |
if (!fpic) {
|
|
|
2fd6a3 |
strcpy(slash,base);
|
|
|
2fd6a3 |
return true;
|
|
|
5cc3b3 |
}
|
|
|
53aa85 |
|
|
|
2fd6a3 |
/* .libs/foo.o explicitly requested and is not present? */
|
|
|
2fd6a3 |
if (!fany)
|
|
|
2fd6a3 |
return true;
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
/* use foo.o in place of .libs/foo.o */
|
|
|
2fd6a3 |
strcpy(slash,base);
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
if (faccessat(fdcwd,arg,0,0))
|
|
|
2fd6a3 |
sprintf(slash,".libs/%s",base);
|
|
|
2fd6a3 |
|
|
|
932031 |
return true;
|
|
|
932031 |
}
|
|
|
932031 |
|
|
|
932031 |
static bool slbt_adjust_wrapper_argument(
|
|
|
932031 |
char * arg,
|
|
|
932031 |
bool fpic)
|
|
|
932031 |
{
|
|
|
932031 |
char * slash;
|
|
|
932031 |
char * dot;
|
|
|
932031 |
char base[PATH_MAX];
|
|
|
932031 |
|
|
|
932031 |
if (*arg == '-')
|
|
|
932031 |
return false;
|
|
|
932031 |
|
|
|
932031 |
if (!(dot = strrchr(arg,'.')))
|
|
|
932031 |
return false;
|
|
|
932031 |
|
|
|
932031 |
if (strcmp(dot,".la"))
|
|
|
932031 |
return false;
|
|
|
932031 |
|
|
|
932031 |
if (fpic) {
|
|
|
932031 |
if ((slash = strrchr(arg,'/')))
|
|
|
932031 |
slash++;
|
|
|
932031 |
else
|
|
|
932031 |
slash = arg;
|
|
|
932031 |
|
|
|
932031 |
if ((size_t)snprintf(base,sizeof(base),"%s",
|
|
|
932031 |
slash) >= sizeof(base))
|
|
|
932031 |
return false;
|
|
|
932031 |
|
|
|
932031 |
sprintf(slash,".libs/%s",base);
|
|
|
932031 |
dot = strrchr(arg,'.');
|
|
|
932031 |
}
|
|
|
932031 |
|
|
|
932031 |
strcpy(dot,".a");
|
|
|
53aa85 |
return true;
|
|
|
5cc3b3 |
}
|
|
|
5cc3b3 |
|
|
|
afaba2 |
static int slbt_adjust_linker_argument(
|
|
|
9c9f28 |
const struct slbt_driver_ctx * dctx,
|
|
|
618537 |
char * arg,
|
|
|
46aa6f |
char ** xarg,
|
|
|
618537 |
bool fpic,
|
|
|
618537 |
const char * dsosuffix,
|
|
|
618537 |
const char * arsuffix,
|
|
|
618537 |
struct slbt_deps_meta * depsmeta)
|
|
|
b3940a |
{
|
|
|
cb9119 |
int fdcwd;
|
|
|
b3940a |
int fdlib;
|
|
|
b3940a |
char * slash;
|
|
|
b3940a |
char * dot;
|
|
|
b3940a |
char base[PATH_MAX];
|
|
|
b3940a |
|
|
|
b3940a |
if (*arg == '-')
|
|
|
afaba2 |
return 0;
|
|
|
b3940a |
|
|
|
b3940a |
if (!(dot = strrchr(arg,'.')))
|
|
|
afaba2 |
return 0;
|
|
|
b3940a |
|
|
|
46aa6f |
if (!(strcmp(dot,arsuffix))) {
|
|
|
46aa6f |
*xarg = arg;
|
|
|
ba8a74 |
return slbt_get_deps_meta(dctx,arg,1,depsmeta);
|
|
|
46aa6f |
}
|
|
|
6a1ae7 |
|
|
|
6a1ae7 |
if (!(strcmp(dot,dsosuffix)))
|
|
|
ba8a74 |
return slbt_get_deps_meta(dctx,arg,1,depsmeta);
|
|
|
6a1ae7 |
|
|
|
b3940a |
if (strcmp(dot,".la"))
|
|
|
afaba2 |
return 0;
|
|
|
b3940a |
|
|
|
b3940a |
if (fpic) {
|
|
|
b3940a |
if ((slash = strrchr(arg,'/')))
|
|
|
b3940a |
slash++;
|
|
|
b3940a |
else
|
|
|
b3940a |
slash = arg;
|
|
|
b3940a |
|
|
|
b3940a |
if ((size_t)snprintf(base,sizeof(base),"%s",
|
|
|
b3940a |
slash) >= sizeof(base))
|
|
|
afaba2 |
return 0;
|
|
|
b3940a |
|
|
|
b3940a |
sprintf(slash,".libs/%s",base);
|
|
|
b3940a |
dot = strrchr(arg,'.');
|
|
|
b3940a |
}
|
|
|
b3940a |
|
|
|
cb9119 |
/* fdcwd */
|
|
|
cb9119 |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
cb9119 |
|
|
|
b3940a |
/* shared library dependency? */
|
|
|
b3940a |
if (fpic) {
|
|
|
b3940a |
sprintf(dot,"%s",dsosuffix);
|
|
|
b3940a |
|
|
|
c81d16 |
if (slbt_symlink_is_a_placeholder(fdcwd,arg))
|
|
|
50b6ef |
sprintf(dot,"%s",arsuffix);
|
|
|
cb9119 |
else if ((fdlib = openat(fdcwd,arg,O_RDONLY)) >= 0)
|
|
|
b3940a |
close(fdlib);
|
|
|
b3940a |
else
|
|
|
b3940a |
sprintf(dot,"%s",arsuffix);
|
|
|
b3940a |
|
|
|
ba8a74 |
return slbt_get_deps_meta(dctx,arg,0,depsmeta);
|
|
|
b3940a |
}
|
|
|
b3940a |
|
|
|
b3940a |
/* input archive */
|
|
|
b3940a |
sprintf(dot,"%s",arsuffix);
|
|
|
ba8a74 |
return slbt_get_deps_meta(dctx,arg,0,depsmeta);
|
|
|
b3940a |
}
|
|
|
b3940a |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
static int slbt_emit_fdwrap_amend_dl_path(
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
const struct slbt_driver_ctx * dctx,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
struct slbt_exec_ctx * ectx,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
struct slbt_deps_meta * depsmeta,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
const char * fmt,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
...)
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
{
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
va_list ap;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char * buf;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
int cnt;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char dlpathbuf[2048];
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
int fdwrap;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
const char * fdwrap_fmt;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
int size;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
va_start(ap,fmt);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
size = sizeof(dlpathbuf);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
buf = ((cnt = vsnprintf(dlpathbuf,size,fmt,ap)) < size)
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
? dlpathbuf : malloc((size = cnt + 1));
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
va_end(ap);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if (buf == dlpathbuf) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
(void)0;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
} else if (buf) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
va_start(ap,fmt);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
vsprintf(buf,fmt,ap);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
va_end(ap);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
} else {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
return slbt_exec_link_exit(
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
depsmeta,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
SLBT_SYSTEM_ERROR(dctx,0));
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if ((fdwrap = slbt_exec_get_fdwrapper(ectx)) >= 0) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if (buf[0] == '/') {
|
|
|
430d5a |
fdwrap_fmt =
|
|
|
430d5a |
"DL_PATH=\"${DL_PATH}${COLON}%s\"\n"
|
|
|
430d5a |
"COLON=':'\n\n";
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
} else {
|
|
|
430d5a |
fdwrap_fmt =
|
|
|
430d5a |
"DL_PATH=\"${DL_PATH}${COLON}${DL_PATH_FIXUP}%s\"\n"
|
|
|
430d5a |
"COLON=':'\n\n";
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if (slbt_dprintf(fdwrap,fdwrap_fmt,buf) < 0) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
return slbt_exec_link_exit(
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
depsmeta,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
SLBT_SYSTEM_ERROR(dctx,0));
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
return 0;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
static void slbt_emit_fdwrap_dl_path_fixup(
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char * cwd,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char * dpfixup,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
size_t dpfixup_size,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char * wrapper)
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
{
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char * p;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char * q;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char * wrapper_dname;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
/* obtain cwd-relative directory name of wrapper */
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
for (p=cwd,q=wrapper; *p && *q && (*p==*q); p++,q++)
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
(void)0;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
wrapper_dname = (*q == '/') ? (q + 1) : q;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
dpfixup[0] = 0; strncat(dpfixup,"${0%/*}",dpfixup_size - 1);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
/* append parent directory fixup for each level of depth in wrapper_dname */
|
|
|
bd56f8 |
for (p=wrapper_dname,q=0; *p; ) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if ((p[0] == '.') && (p[1] == '/')) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
p++; p++;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
} else if ((q = strchr(p, '/'))) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
strncat(dpfixup,"/..",dpfixup_size-1); p = (q + 1);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
} else {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
break;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
strncat(dpfixup,"/",dpfixup_size-1);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
}
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
|
2ef5be |
static int slbt_exec_link_adjust_argument_vector(
|
|
|
2ef5be |
const struct slbt_driver_ctx * dctx,
|
|
|
2ef5be |
struct slbt_exec_ctx * ectx,
|
|
|
3be47d |
struct slbt_deps_meta * depsmeta,
|
|
|
79c501 |
const char * cwd,
|
|
|
2ef5be |
bool flibrary)
|
|
|
2ef5be |
{
|
|
|
9ae217 |
int fd;
|
|
|
5fac6c |
int fdcwd;
|
|
|
9ae217 |
char ** carg;
|
|
|
9ae217 |
char ** aarg;
|
|
|
9ae217 |
char * ldir;
|
|
|
9ae217 |
char * slash;
|
|
|
9ae217 |
char * mark;
|
|
|
9ae217 |
char * darg;
|
|
|
9ae217 |
char * dot;
|
|
|
9ae217 |
char * base;
|
|
|
9ae217 |
char * dpath;
|
|
|
9ae217 |
int argc;
|
|
|
9ae217 |
char arg[PATH_MAX];
|
|
|
9ae217 |
char lib[PATH_MAX];
|
|
|
9ae217 |
char depdir [PATH_MAX];
|
|
|
9ae217 |
char rpathdir[PATH_MAX];
|
|
|
9ae217 |
char rpathlnk[PATH_MAX];
|
|
|
9ae217 |
struct stat st;
|
|
|
9ae217 |
size_t size;
|
|
|
9ae217 |
size_t dlen;
|
|
|
9ae217 |
struct slbt_map_info * mapinfo;
|
|
|
9ae217 |
bool fwholearchive = false;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
int ret;
|
|
|
2ef5be |
|
|
|
3be47d |
for (argc=0,carg=ectx->cargv; *carg; carg++)
|
|
|
3be47d |
argc++;
|
|
|
3be47d |
|
|
|
3be47d |
if (!(depsmeta->args = calloc(1,depsmeta->infolen)))
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
3be47d |
|
|
|
3be47d |
argc *= 3;
|
|
|
3be47d |
argc += depsmeta->depscnt;
|
|
|
3be47d |
|
|
|
3be47d |
if (!(depsmeta->altv = calloc(argc,sizeof(char *))))
|
|
|
b332ad |
return slbt_exec_link_exit(
|
|
|
b332ad |
depsmeta,
|
|
|
6beda1 |
SLBT_SYSTEM_ERROR(dctx,0));
|
|
|
3be47d |
|
|
|
5fac6c |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
5fac6c |
|
|
|
2ef5be |
carg = ectx->cargv;
|
|
|
3be47d |
aarg = depsmeta->altv;
|
|
|
3be47d |
darg = depsmeta->args;
|
|
|
9ae217 |
size = depsmeta->infolen;
|
|
|
2ef5be |
|
|
|
2ef5be |
for (; *carg; ) {
|
|
|
3be47d |
dpath = 0;
|
|
|
3be47d |
|
|
|
2ef5be |
if (!strcmp(*carg,"-Wl,--whole-archive"))
|
|
|
2ef5be |
fwholearchive = true;
|
|
|
2ef5be |
else if (!strcmp(*carg,"-Wl,--no-whole-archive"))
|
|
|
2ef5be |
fwholearchive = false;
|
|
|
2ef5be |
|
|
|
2ef5be |
|
|
|
2ef5be |
|
|
|
df07fb |
/* output annotation */
|
|
|
df07fb |
if (carg == ectx->lout[0]) {
|
|
|
df07fb |
ectx->mout[0] = &aarg[0];
|
|
|
df07fb |
ectx->mout[1] = &aarg[1];
|
|
|
df07fb |
}
|
|
|
df07fb |
|
|
|
df07fb |
/* argument translation */
|
|
|
738321 |
mark = *carg;
|
|
|
738321 |
|
|
|
738321 |
if ((mark[0] == '-') && (mark[1] == 'L')) {
|
|
|
738321 |
if (mark[2]) {
|
|
|
738321 |
ldir = &mark[2];
|
|
|
738321 |
} else {
|
|
|
738321 |
*aarg++ = *carg++;
|
|
|
738321 |
ldir = *carg;
|
|
|
738321 |
}
|
|
|
738321 |
|
|
|
738321 |
mark = ldir + strlen(ldir);
|
|
|
738321 |
|
|
|
738321 |
if (mark[-1] == '/')
|
|
|
738321 |
strcpy(mark,".libs");
|
|
|
738321 |
else
|
|
|
738321 |
strcpy(mark,"/.libs");
|
|
|
738321 |
|
|
|
cb9119 |
if ((fd = openat(fdcwd,ldir,O_DIRECTORY,0)) < 0)
|
|
|
738321 |
*mark = 0;
|
|
Lucio Andrés Illanes Albornoz |
bdfc62 |
else {
|
|
|
738321 |
close(fd);
|
|
|
738321 |
|
|
Lucio Andrés Illanes Albornoz |
bdfc62 |
if ((ret = slbt_emit_fdwrap_amend_dl_path(
|
|
|
430d5a |
dctx,ectx,depsmeta,
|
|
|
430d5a |
"%s",ldir)) < 0)
|
|
Lucio Andrés Illanes Albornoz |
bdfc62 |
return ret;
|
|
Lucio Andrés Illanes Albornoz |
bdfc62 |
}
|
|
Lucio Andrés Illanes Albornoz |
bdfc62 |
|
|
|
738321 |
*aarg++ = *carg++;
|
|
|
738321 |
|
|
|
738321 |
} else if (**carg == '-') {
|
|
|
2ef5be |
*aarg++ = *carg++;
|
|
|
2ef5be |
|
|
|
2ef5be |
} else if (!(dot = strrchr(*carg,'.'))) {
|
|
|
2ef5be |
*aarg++ = *carg++;
|
|
|
2ef5be |
|
|
|
46aa6f |
} else if (ectx->xargv[carg - ectx->cargv]) {
|
|
|
46aa6f |
*aarg++ = *carg++;
|
|
|
46aa6f |
|
|
|
2ef5be |
} else if (!(strcmp(dot,".a"))) {
|
|
|
2ef5be |
if (flibrary && !fwholearchive)
|
|
|
2ef5be |
*aarg++ = "-Wl,--whole-archive";
|
|
|
2ef5be |
|
|
|
3be47d |
dpath = lib;
|
|
|
3be47d |
sprintf(lib,"%s.slibtool.deps",*carg);
|
|
|
2ef5be |
*aarg++ = *carg++;
|
|
|
2ef5be |
|
|
|
2ef5be |
if (flibrary && !fwholearchive)
|
|
|
2ef5be |
*aarg++ = "-Wl,--no-whole-archive";
|
|
|
2ef5be |
|
|
|
2ef5be |
} else if (strcmp(dot,dctx->cctx->settings.dsosuffix)) {
|
|
|
2ef5be |
*aarg++ = *carg++;
|
|
|
2ef5be |
|
|
|
867d1e |
} else if (carg == ectx->lout[1]) {
|
|
|
867d1e |
/* ^^^hoppla^^^ */
|
|
|
867d1e |
*aarg++ = *carg++;
|
|
|
2ef5be |
} else {
|
|
|
0f5ca7 |
/* -rpath */
|
|
|
0f5ca7 |
sprintf(rpathlnk,"%s.slibtool.rpath",*carg);
|
|
|
0f5ca7 |
|
|
|
7ae5c1 |
if (!fstatat(fdcwd,rpathlnk,&st,AT_SYMLINK_NOFOLLOW)) {
|
|
|
c81d16 |
if (slbt_readlinkat(
|
|
|
c81d16 |
fdcwd,
|
|
|
c81d16 |
rpathlnk,
|
|
|
0f5ca7 |
rpathdir,
|
|
|
0f5ca7 |
sizeof(rpathdir)))
|
|
|
b332ad |
return slbt_exec_link_exit(
|
|
|
b332ad |
depsmeta,
|
|
|
6beda1 |
SLBT_SYSTEM_ERROR(dctx,rpathlnk));
|
|
|
0f5ca7 |
|
|
|
0f5ca7 |
sprintf(darg,"-Wl,%s",rpathdir);
|
|
|
0f5ca7 |
*aarg++ = "-Wl,-rpath";
|
|
|
0f5ca7 |
*aarg++ = darg;
|
|
|
0f5ca7 |
darg += strlen(darg);
|
|
|
0f5ca7 |
darg++;
|
|
|
0f5ca7 |
}
|
|
|
0f5ca7 |
|
|
|
3be47d |
dpath = lib;
|
|
|
3be47d |
sprintf(lib,"%s.slibtool.deps",*carg);
|
|
|
3be47d |
|
|
|
2ef5be |
/* account for {'-','L','-','l'} */
|
|
|
b332ad |
if ((size_t)snprintf(arg,sizeof(arg),
|
|
|
b332ad |
"%s",*carg)
|
|
|
b332ad |
>= (sizeof(arg) - 4))
|
|
|
b332ad |
return slbt_exec_link_exit(
|
|
|
b332ad |
depsmeta,
|
|
|
b332ad |
SLBT_BUFFER_ERROR(dctx));
|
|
|
2ef5be |
|
|
|
2ef5be |
if ((slash = strrchr(arg,'/'))) {
|
|
|
2ef5be |
sprintf(*carg,"-L%s",arg);
|
|
|
2ef5be |
|
|
|
2ef5be |
mark = strrchr(*carg,'/');
|
|
|
5b792c |
*mark = 0;
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
*slash = 0;
|
|
|
430d5a |
|
|
|
430d5a |
if ((ret = slbt_emit_fdwrap_amend_dl_path(
|
|
|
430d5a |
dctx,ectx,depsmeta,
|
|
|
430d5a |
"%s%s%s",
|
|
|
430d5a |
((arg[0] == '/') ? "" : cwd),
|
|
|
430d5a |
((arg[0] == '/') ? "" : "/"),
|
|
|
430d5a |
arg)) < 0) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
return ret;
|
|
|
5ee0d1 |
}
|
|
|
5ee0d1 |
|
|
|
9c5ba5 |
dlen = strlen(dctx->cctx->settings.dsoprefix);
|
|
|
9c5ba5 |
|
|
|
9c5ba5 |
/* -module? (todo: non-portable usage, display warning) */
|
|
|
9c5ba5 |
if (strncmp(++slash,dctx->cctx->settings.dsoprefix,dlen)) {
|
|
|
9c5ba5 |
*--slash = '/';
|
|
|
9c5ba5 |
strcpy(*carg,arg);
|
|
|
9c5ba5 |
*aarg++ = *carg++;
|
|
|
9c5ba5 |
} else {
|
|
|
9c5ba5 |
*aarg++ = *carg++;
|
|
|
9c5ba5 |
*aarg++ = ++mark;
|
|
|
9c5ba5 |
|
|
|
9c5ba5 |
slash += dlen;
|
|
|
9c5ba5 |
|
|
|
9c5ba5 |
sprintf(mark,"-l%s",slash);
|
|
|
9c5ba5 |
dot = strrchr(mark,'.');
|
|
|
9c5ba5 |
*dot = 0;
|
|
|
9c5ba5 |
}
|
|
|
2ef5be |
} else {
|
|
|
2ef5be |
*aarg++ = *carg++;
|
|
|
2ef5be |
}
|
|
|
2ef5be |
}
|
|
|
3be47d |
|
|
|
7ae5c1 |
if (dpath && !fstatat(fdcwd,dpath,&st,0)) {
|
|
|
9ae217 |
if (!(mapinfo = slbt_map_file(
|
|
|
5fac6c |
fdcwd,dpath,
|
|
|
9ae217 |
SLBT_MAP_INPUT)))
|
|
|
9ae217 |
return slbt_exec_link_exit(
|
|
|
9ae217 |
depsmeta,
|
|
|
6beda1 |
SLBT_SYSTEM_ERROR(dctx,dpath));
|
|
|
9ae217 |
|
|
|
9ae217 |
if (!(strncmp(lib,".libs/",6))) {
|
|
|
9ae217 |
*aarg++ = "-L.libs";
|
|
|
9ae217 |
lib[1] = 0;
|
|
|
9ae217 |
} else if ((base = strrchr(lib,'/'))) {
|
|
|
9ae217 |
if (base - lib == 5) {
|
|
|
9ae217 |
if (!(strncmp(&base[-5],".libs/",6)))
|
|
|
9ae217 |
base -= 4;
|
|
|
9ae217 |
|
|
|
9ae217 |
} else if (base - lib >= 6) {
|
|
|
9ae217 |
if (!(strncmp(&base[-6],"/.libs/",7)))
|
|
|
9ae217 |
base -= 6;
|
|
|
94ae74 |
}
|
|
|
3be47d |
|
|
|
9ae217 |
*base = 0;
|
|
|
9ae217 |
} else {
|
|
|
9ae217 |
lib[0] = '.';
|
|
|
9ae217 |
lib[1] = 0;
|
|
|
9ae217 |
}
|
|
|
b332ad |
|
|
|
9ae217 |
while (mapinfo->mark < mapinfo->cap) {
|
|
|
9ae217 |
if (slbt_mapped_readline(dctx,mapinfo,darg,size))
|
|
|
b332ad |
return slbt_exec_link_exit(
|
|
|
b332ad |
depsmeta,
|
|
|
9ae217 |
SLBT_NESTED_ERROR(dctx));
|
|
|
b332ad |
|
|
|
9ae217 |
*aarg++ = darg;
|
|
|
9ae217 |
mark = darg;
|
|
|
9ae217 |
|
|
|
9ae217 |
dlen = strlen(darg);
|
|
|
9ae217 |
size -= dlen;
|
|
|
9ae217 |
darg += dlen;
|
|
|
9ae217 |
darg[-1] = 0;
|
|
|
9ae217 |
|
|
|
9ae217 |
/* handle -L... as needed */
|
|
|
9ae217 |
if ((mark[0] == '-')
|
|
|
9ae217 |
&& (mark[1] == 'L')
|
|
|
9ae217 |
&& (mark[2] != '/')) {
|
|
|
9ae217 |
if (strlen(mark) >= sizeof(depdir) - 1)
|
|
|
9ae217 |
return slbt_exec_link_exit(
|
|
|
9ae217 |
depsmeta,
|
|
|
9ae217 |
SLBT_BUFFER_ERROR(dctx));
|
|
|
9ae217 |
|
|
|
9ae217 |
darg = mark;
|
|
|
9ae217 |
strcpy(depdir,&mark[2]);
|
|
|
9ae217 |
sprintf(darg,"-L%s/%s",lib,depdir);
|
|
|
9ae217 |
|
|
|
9ae217 |
darg += strlen(darg);
|
|
|
9ae217 |
darg++;
|
|
Lucio Andrés Illanes Albornoz |
2a100f |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if ((ret = slbt_emit_fdwrap_amend_dl_path(
|
|
|
430d5a |
dctx,ectx,depsmeta,
|
|
|
430d5a |
"%s/%s",lib,depdir)) < 0)
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
return ret;
|
|
|
430d5a |
|
|
Lucio Andrés Illanes Albornoz |
2a100f |
} else if ((mark[0] == '-') && (mark[1] == 'L')) {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if ((ret = slbt_emit_fdwrap_amend_dl_path(
|
|
|
430d5a |
dctx,ectx,depsmeta,
|
|
|
430d5a |
"%s",&mark[2])) < 0)
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
return ret;
|
|
|
9ae217 |
}
|
|
|
3be47d |
}
|
|
|
3be47d |
}
|
|
|
2ef5be |
}
|
|
|
2ef5be |
|
|
|
f5983e |
if (dctx->cctx->drvflags & SLBT_DRIVER_EXPORT_DYNAMIC)
|
|
|
f5983e |
*aarg++ = "-Wl,--export-dynamic";
|
|
|
f5983e |
|
|
|
2ef5be |
return 0;
|
|
|
2ef5be |
}
|
|
|
2ef5be |
|
|
|
671454 |
static int slbt_exec_link_finalize_argument_vector(
|
|
|
671454 |
const struct slbt_driver_ctx * dctx,
|
|
|
671454 |
struct slbt_exec_ctx * ectx)
|
|
|
671454 |
{
|
|
|
671454 |
char * sargv[1024];
|
|
|
671454 |
char ** sargvbuf;
|
|
|
671454 |
char ** base;
|
|
|
c6d4dc |
char ** parg;
|
|
|
c6d4dc |
char ** aarg;
|
|
|
c6d4dc |
char ** oarg;
|
|
|
2480bd |
char ** larg;
|
|
|
2480bd |
char ** darg;
|
|
|
2480bd |
char ** earg;
|
|
|
2480bd |
char ** rarg;
|
|
|
c6d4dc |
char ** aargv;
|
|
|
c6d4dc |
char ** oargv;
|
|
|
c6d4dc |
char ** cap;
|
|
|
c6d4dc |
char ** src;
|
|
|
c6d4dc |
char ** dst;
|
|
|
671454 |
char * arg;
|
|
|
671454 |
char * dot;
|
|
|
34988f |
char * ccwrap;
|
|
|
c6d4dc |
const char * arsuffix;
|
|
|
671454 |
|
|
|
c6d4dc |
/* vector size */
|
|
|
c6d4dc |
base = ectx->argv;
|
|
|
c6d4dc |
arsuffix = dctx->cctx->settings.arsuffix;
|
|
|
671454 |
|
|
|
c6d4dc |
for (parg=base; *parg; parg++)
|
|
|
c6d4dc |
(void)0;
|
|
|
671454 |
|
|
|
671454 |
/* buffer */
|
|
|
c6d4dc |
if (parg - base < 512) {
|
|
|
c6d4dc |
aargv = &sargv[0];
|
|
|
c6d4dc |
oargv = &sargv[512];
|
|
|
c6d4dc |
aarg = aargv;
|
|
|
c6d4dc |
oarg = oargv;
|
|
|
671454 |
sargvbuf = 0;
|
|
|
671454 |
|
|
|
c6d4dc |
} else if (!(sargvbuf = calloc(2*(parg-base+1),sizeof(char *)))) {
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
671454 |
|
|
|
671454 |
} else {
|
|
|
c6d4dc |
aargv = &sargvbuf[0];
|
|
|
c6d4dc |
oargv = &sargvbuf[parg-base+1];
|
|
|
c6d4dc |
aarg = aargv;
|
|
|
c6d4dc |
oarg = oargv;
|
|
|
671454 |
}
|
|
|
671454 |
|
|
|
c6d4dc |
/* (program name) */
|
|
|
c6d4dc |
parg = &base[1];
|
|
|
c6d4dc |
|
|
|
2480bd |
/* split object args from all other args, record output */
|
|
|
2480bd |
/* annotation, and remove redundant -l arguments */
|
|
|
c6d4dc |
for (; *parg; ) {
|
|
|
c6d4dc |
if (ectx->lout[0] == parg) {
|
|
|
c6d4dc |
ectx->lout[0] = &aarg[0];
|
|
|
c6d4dc |
ectx->lout[1] = &aarg[1];
|
|
|
c6d4dc |
}
|
|
|
c6d4dc |
|
|
|
c6d4dc |
if (ectx->mout[0] == parg) {
|
|
|
208722 |
ectx->mout[0] = &aarg[0];
|
|
|
208722 |
ectx->mout[1] = &aarg[1];
|
|
|
c6d4dc |
}
|
|
|
c6d4dc |
|
|
|
c6d4dc |
arg = *parg;
|
|
|
c6d4dc |
dot = strrchr(arg,'.');
|
|
|
671454 |
|
|
|
890281 |
/* object input argument? */
|
|
|
c6d4dc |
if (dot && (!strcmp(dot,".o") || !strcmp(dot,".lo"))) {
|
|
|
c6d4dc |
*oarg++ = *parg++;
|
|
|
671454 |
|
|
|
890281 |
/* --whole-archive input argument? */
|
|
|
c6d4dc |
} else if ((arg[0] == '-')
|
|
|
c6d4dc |
&& (arg[1] == 'W')
|
|
|
c6d4dc |
&& (arg[2] == 'l')
|
|
|
c6d4dc |
&& (arg[3] == ',')
|
|
|
c6d4dc |
&& !strcmp(&arg[4],"--whole-archive")
|
|
|
c6d4dc |
&& parg[1] && parg[2]
|
|
|
c6d4dc |
&& !strcmp(parg[2],"-Wl,--no-whole-archive")
|
|
|
c6d4dc |
&& (dot = strrchr(parg[1],'.'))
|
|
|
c6d4dc |
&& !strcmp(dot,arsuffix)) {
|
|
|
c6d4dc |
*oarg++ = *parg++;
|
|
|
c6d4dc |
*oarg++ = *parg++;
|
|
|
c6d4dc |
*oarg++ = *parg++;
|
|
|
dc48ad |
|
|
|
890281 |
/* local archive input argument? */
|
|
|
dc48ad |
} else if (dot && !strcmp(dot,arsuffix)) {
|
|
|
dc48ad |
*oarg++ = *parg++;
|
|
|
dc48ad |
|
|
|
890281 |
/* -l argument? */
|
|
|
890281 |
} else if ((parg[0][0] == '-') && (parg[0][1] == 'l')) {
|
|
|
890281 |
/* find the previous occurence of this -l argument */
|
|
|
890281 |
for (rarg=0, larg=&aarg[-1]; !rarg && (larg>=aargv); larg--)
|
|
|
890281 |
if (!strcmp(*larg,*parg))
|
|
|
890281 |
rarg = larg;
|
|
|
2480bd |
|
|
|
890281 |
/* first occurence of this specific -l argument? */
|
|
|
890281 |
if (!rarg) {
|
|
|
890281 |
*aarg++ = *parg++;
|
|
|
2480bd |
|
|
|
890281 |
} else {
|
|
|
890281 |
larg = rarg;
|
|
|
890281 |
|
|
|
890281 |
/* if all -l arguments following the previous */
|
|
|
890281 |
/* occurence had already appeared before the */
|
|
|
890281 |
/* previous argument, then the current */
|
|
|
890281 |
/* occurence is redundant. */
|
|
|
890281 |
|
|
|
890281 |
for (darg=&larg[1]; rarg && darg
|
|
|
890281 |
/* only test -l arguments */
|
|
|
890281 |
if ((darg[0][0] == '-') && (darg[0][1] == 'l')) {
|
|
|
890281 |
for (rarg=0, earg=aargv; !rarg && earg
|
|
|
890281 |
if (!strcmp(*earg,*darg))
|
|
|
890281 |
rarg = darg;
|
|
|
2480bd |
}
|
|
|
890281 |
}
|
|
|
2480bd |
|
|
|
890281 |
/* final verdict: repeated -l argument? */
|
|
|
890281 |
if (rarg) {
|
|
|
890281 |
parg++;
|
|
|
2480bd |
|
|
|
890281 |
} else {
|
|
|
890281 |
*aarg++ = *parg++;
|
|
|
2480bd |
}
|
|
|
2480bd |
}
|
|
|
890281 |
|
|
|
85f619 |
/* -L argument? */
|
|
|
85f619 |
} else if ((parg[0][0] == '-') && (parg[0][1] == 'L')) {
|
|
|
85f619 |
/* find a previous occurence of this -L argument */
|
|
|
85f619 |
for (rarg=0, larg=aargv; !rarg && (larg
|
|
|
85f619 |
if (!strcmp(*larg,*parg))
|
|
|
85f619 |
rarg = larg;
|
|
|
85f619 |
|
|
|
85f619 |
/* repeated -L argument? */
|
|
|
85f619 |
if (rarg) {
|
|
|
85f619 |
parg++;
|
|
|
85f619 |
} else {
|
|
|
85f619 |
*aarg++ = *parg++;
|
|
|
85f619 |
}
|
|
|
85f619 |
|
|
|
890281 |
/* placeholder argument? */
|
|
|
890281 |
} else if (!strncmp(*parg,"-USLIBTOOL_PLACEHOLDER_",23)) {
|
|
|
890281 |
parg++;
|
|
|
890281 |
|
|
|
890281 |
/* all other arguments */
|
|
|
890281 |
} else {
|
|
|
890281 |
*aarg++ = *parg++;
|
|
|
c6d4dc |
}
|
|
|
c6d4dc |
}
|
|
|
671454 |
|
|
|
34988f |
/* program name, ccwrap */
|
|
|
34988f |
if ((ccwrap = (char *)dctx->cctx->ccwrap)) {
|
|
|
34988f |
base[1] = base[0];
|
|
|
34988f |
base[0] = ccwrap;
|
|
|
34988f |
base++;
|
|
|
34988f |
}
|
|
|
671454 |
|
|
|
c6d4dc |
/* join object args */
|
|
|
c6d4dc |
src = oargv;
|
|
|
c6d4dc |
cap = oarg;
|
|
|
34988f |
dst = &base[1];
|
|
|
671454 |
|
|
|
c6d4dc |
for (; src
|
|
|
c6d4dc |
*dst++ = *src++;
|
|
|
671454 |
|
|
|
c6d4dc |
/* join all other args */
|
|
|
c6d4dc |
src = aargv;
|
|
|
c6d4dc |
cap = aarg;
|
|
|
671454 |
|
|
|
c6d4dc |
for (; src
|
|
|
c6d4dc |
*dst++ = *src++;
|
|
|
671454 |
|
|
|
2480bd |
/* properly null-terminate argv, accounting for redundant -l arguments */
|
|
|
2480bd |
*dst = 0;
|
|
|
2480bd |
|
|
|
671454 |
/* output annotation */
|
|
|
c6d4dc |
if (ectx->lout[0]) {
|
|
|
c6d4dc |
ectx->lout[0] = &base[1] + (oarg - oargv) + (ectx->lout[0] - aargv);
|
|
|
c6d4dc |
ectx->lout[1] = ectx->lout[0] + 1;
|
|
|
671454 |
}
|
|
|
671454 |
|
|
|
c6d4dc |
if (ectx->mout[0]) {
|
|
|
c6d4dc |
ectx->mout[0] = &base[1] + (oarg - oargv) + (ectx->mout[0] - aargv);
|
|
|
c6d4dc |
ectx->mout[1] = ectx->mout[0] + 1;
|
|
|
671454 |
}
|
|
|
671454 |
|
|
|
671454 |
/* all done */
|
|
|
671454 |
if (sargvbuf)
|
|
|
671454 |
free(sargvbuf);
|
|
|
671454 |
|
|
|
671454 |
return 0;
|
|
|
671454 |
}
|
|
|
671454 |
|
|
|
628cde |
static int slbt_exec_link_remove_file(
|
|
|
628cde |
const struct slbt_driver_ctx * dctx,
|
|
|
628cde |
struct slbt_exec_ctx * ectx,
|
|
|
628cde |
const char * target)
|
|
|
628cde |
{
|
|
|
d38565 |
int fdcwd;
|
|
|
d38565 |
|
|
|
d3ca02 |
(void)ectx;
|
|
|
d3ca02 |
|
|
|
d38565 |
/* fdcwd */
|
|
|
d38565 |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
d38565 |
|
|
|
628cde |
/* remove target (if any) */
|
|
|
d38565 |
if (!unlinkat(fdcwd,target,0) || (errno == ENOENT))
|
|
|
628cde |
return 0;
|
|
|
628cde |
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
628cde |
}
|
|
|
628cde |
|
|
|
0913c3 |
static int slbt_exec_link_create_dep_file(
|
|
|
9c9f28 |
const struct slbt_driver_ctx * dctx,
|
|
|
618537 |
struct slbt_exec_ctx * ectx,
|
|
|
618537 |
char ** altv,
|
|
|
618537 |
const char * libfilename,
|
|
|
618537 |
bool farchive)
|
|
|
0913c3 |
{
|
|
|
c178e3 |
int ret;
|
|
|
c178e3 |
int deps;
|
|
|
5fac6c |
int fdcwd;
|
|
|
c178e3 |
char ** parg;
|
|
|
c178e3 |
char * popt;
|
|
|
c178e3 |
char * plib;
|
|
|
c178e3 |
char * path;
|
|
|
c178e3 |
char * mark;
|
|
|
c178e3 |
char * base;
|
|
|
c178e3 |
size_t size;
|
|
|
c178e3 |
size_t slen;
|
|
|
c178e3 |
char deplib [PATH_MAX];
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
bool is_reladir;
|
|
|
c178e3 |
char reladir[PATH_MAX];
|
|
|
c178e3 |
char depfile[PATH_MAX];
|
|
|
c178e3 |
struct stat st;
|
|
|
c178e3 |
int ldepth;
|
|
|
c178e3 |
int fdyndep;
|
|
|
c178e3 |
struct slbt_map_info * mapinfo;
|
|
|
0913c3 |
|
|
|
5fac6c |
/* fdcwd */
|
|
|
5fac6c |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
5fac6c |
|
|
|
c178e3 |
/* depfile */
|
|
|
c178e3 |
slen = snprintf(depfile,sizeof(depfile),
|
|
|
c178e3 |
"%s.slibtool.deps",
|
|
|
c178e3 |
libfilename);
|
|
|
c178e3 |
|
|
|
c178e3 |
if (slen >= sizeof(depfile))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
0913c3 |
|
|
|
c178e3 |
/* deps */
|
|
|
5fac6c |
if ((deps = openat(fdcwd,depfile,O_RDWR|O_CREAT|O_TRUNC,0644)) < 0)
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,depfile);
|
|
|
0913c3 |
|
|
|
c178e3 |
/* iterate */
|
|
|
0913c3 |
for (parg=altv; *parg; parg++) {
|
|
|
c178e3 |
popt = 0;
|
|
|
c178e3 |
plib = 0;
|
|
|
c178e3 |
path = 0;
|
|
|
c178e3 |
mapinfo = 0;
|
|
|
0913c3 |
|
|
|
ecd300 |
if (!strncmp(*parg,"-l",2)) {
|
|
|
0913c3 |
popt = *parg;
|
|
|
0913c3 |
plib = popt + 2;
|
|
|
ecd300 |
|
|
|
40a467 |
} else if (!strncmp(*parg,"-L",2)) {
|
|
|
40a467 |
popt = *parg;
|
|
|
40a467 |
path = popt + 2;
|
|
|
ecd300 |
|
|
|
4f56fd |
} else if (!strncmp(*parg,"-f",2)) {
|
|
|
4f56fd |
(void)0;
|
|
|
ecd300 |
|
|
|
fe97e7 |
} else if ((popt = strrchr(*parg,'.')) && !strcmp(popt,".la")) {
|
|
|
fe97e7 |
/* import dependency list */
|
|
|
fe97e7 |
if ((base = strrchr(*parg,'/')))
|
|
|
fe97e7 |
base++;
|
|
|
fe97e7 |
else
|
|
|
fe97e7 |
base = *parg;
|
|
|
fe97e7 |
|
|
|
6fda2b |
/* [relative .la directory] */
|
|
|
6fda2b |
if (base > *parg) {
|
|
|
c178e3 |
slen = snprintf(reladir,sizeof(reladir),
|
|
|
c178e3 |
"%s",*parg);
|
|
|
c178e3 |
|
|
|
c178e3 |
if (slen >= sizeof(reladir)) {
|
|
|
c178e3 |
close(deps);
|
|
|
c178e3 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
c178e3 |
}
|
|
|
6fda2b |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
is_reladir = true;
|
|
|
6fda2b |
reladir[base - *parg - 1] = 0;
|
|
|
6fda2b |
} else {
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
is_reladir = false;
|
|
|
6fda2b |
reladir[0] = '.';
|
|
|
6fda2b |
reladir[1] = 0;
|
|
|
6fda2b |
}
|
|
|
6fda2b |
|
|
|
39f31e |
|
|
|
39f31e |
/* dynamic library dependency? */
|
|
|
39f31e |
strcpy(depfile,*parg);
|
|
|
39f31e |
mark = depfile + (base - *parg);
|
|
|
39f31e |
size = sizeof(depfile) - (base - *parg);
|
|
|
c178e3 |
slen = snprintf(mark,size,".libs/%s",base);
|
|
|
39f31e |
|
|
|
c178e3 |
if (slen >= size) {
|
|
|
c178e3 |
close(deps);
|
|
|
39f31e |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
c178e3 |
}
|
|
|
39f31e |
|
|
|
39f31e |
mark = strrchr(mark,'.');
|
|
|
6527a9 |
strcpy(mark,dctx->cctx->settings.dsosuffix);
|
|
|
39f31e |
|
|
|
7ae5c1 |
fdyndep = !fstatat(fdcwd,depfile,&st,0);
|
|
|
39f31e |
|
|
|
6fda2b |
/* [-L... as needed] */
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if (fdyndep && (ectx->ldirdepth >= 0)) {
|
|
|
c178e3 |
if (slbt_dprintf(deps,"-L") < 0) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
c178e3 |
}
|
|
|
7f35de |
|
|
|
c178e3 |
for (ldepth=ectx->ldirdepth; ldepth; ldepth--) {
|
|
|
c178e3 |
if (slbt_dprintf(deps,"../") < 0) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
c178e3 |
}
|
|
|
c178e3 |
}
|
|
|
7f35de |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
if (slbt_dprintf(deps,"%s%s.libs\n",
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
(is_reladir ? reladir : ""),
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
(is_reladir ? "/" : "")) < 0) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
c178e3 |
}
|
|
|
6fda2b |
}
|
|
|
6fda2b |
|
|
|
09421c |
/* -ldeplib */
|
|
|
39f31e |
if (fdyndep) {
|
|
|
1a8018 |
*popt = 0;
|
|
|
1a8018 |
mark = base;
|
|
|
1a8018 |
mark += strlen(dctx->cctx->settings.dsoprefix);
|
|
|
09421c |
|
|
|
c178e3 |
if (slbt_dprintf(deps,"-l%s\n",mark) < 0) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
c178e3 |
}
|
|
|
09421c |
|
|
|
1a8018 |
*popt = '.';
|
|
|
1a8018 |
}
|
|
|
09421c |
|
|
|
6fda2b |
/* [open dependency list] */
|
|
|
fe97e7 |
strcpy(depfile,*parg);
|
|
|
fe97e7 |
mark = depfile + (base - *parg);
|
|
|
fe97e7 |
size = sizeof(depfile) - (base - *parg);
|
|
|
c178e3 |
slen = snprintf(mark,size,".libs/%s",base);
|
|
|
fe97e7 |
|
|
|
c178e3 |
if (slen >= size) {
|
|
|
c178e3 |
close(deps);
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
c178e3 |
}
|
|
|
fe97e7 |
|
|
|
bddb65 |
mapinfo = 0;
|
|
|
bddb65 |
|
|
|
fe97e7 |
mark = strrchr(mark,'.');
|
|
|
fe97e7 |
size = sizeof(depfile) - (mark - depfile);
|
|
|
fe97e7 |
|
|
|
1a8018 |
if (!farchive) {
|
|
|
c178e3 |
slen = snprintf(mark,size,
|
|
|
c178e3 |
"%s.slibtool.deps",
|
|
|
c178e3 |
dctx->cctx->settings.dsosuffix);
|
|
|
c178e3 |
|
|
|
c178e3 |
if (slen >= size) {
|
|
|
c178e3 |
close(deps);
|
|
|
1a8018 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
c178e3 |
}
|
|
|
1a8018 |
|
|
|
c178e3 |
mapinfo = slbt_map_file(
|
|
|
5fac6c |
fdcwd,depfile,
|
|
|
c178e3 |
SLBT_MAP_INPUT);
|
|
|
c178e3 |
|
|
|
c178e3 |
if (!mapinfo && (errno != ENOENT)) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
1a8018 |
}
|
|
|
bddb65 |
}
|
|
|
bddb65 |
|
|
|
bddb65 |
if (!mapinfo) {
|
|
|
c178e3 |
slen = snprintf(mark,size,
|
|
|
c178e3 |
".a.slibtool.deps");
|
|
|
c178e3 |
|
|
|
c178e3 |
if (slen >= size) {
|
|
|
c178e3 |
close(deps);
|
|
|
1a8018 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
c178e3 |
}
|
|
|
fe97e7 |
|
|
|
c178e3 |
mapinfo = slbt_map_file(
|
|
|
5fac6c |
fdcwd,depfile,
|
|
|
c178e3 |
SLBT_MAP_INPUT);
|
|
|
1a8018 |
|
|
|
c178e3 |
if (!mapinfo) {
|
|
|
d1da94 |
strcpy(mark,".a.disabled");
|
|
|
d1da94 |
|
|
|
d1da94 |
if (fstatat(fdcwd,depfile,&st,AT_SYMLINK_NOFOLLOW)) {
|
|
|
d1da94 |
close(deps);
|
|
|
d1da94 |
return SLBT_SYSTEM_ERROR(dctx,depfile);
|
|
|
d1da94 |
}
|
|
|
c178e3 |
}
|
|
|
1a8018 |
}
|
|
|
fe97e7 |
|
|
|
6fda2b |
/* [-l... as needed] */
|
|
|
c178e3 |
while (mapinfo && (mapinfo->mark < mapinfo->cap)) {
|
|
|
c178e3 |
ret = slbt_mapped_readline(
|
|
|
c178e3 |
dctx,mapinfo,
|
|
|
c178e3 |
deplib,sizeof(deplib));
|
|
|
c178e3 |
|
|
|
c178e3 |
if (ret) {
|
|
|
c178e3 |
close(deps);
|
|
|
c178e3 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
e49ee9 |
}
|
|
|
fe97e7 |
|
|
|
c178e3 |
ret = ((deplib[0] == '-')
|
|
|
c178e3 |
&& (deplib[1] == 'L')
|
|
|
c178e3 |
&& (deplib[2] != '/'))
|
|
|
c178e3 |
? slbt_dprintf(
|
|
|
c178e3 |
deps,"-L%s/%s",
|
|
|
c178e3 |
reladir,&deplib[2])
|
|
|
c178e3 |
: slbt_dprintf(
|
|
|
c178e3 |
deps,"%s",
|
|
|
c178e3 |
deplib);
|
|
|
c178e3 |
|
|
|
c178e3 |
if (ret < 0) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
c178e3 |
}
|
|
|
fe97e7 |
}
|
|
|
e49ee9 |
|
|
|
c178e3 |
if (mapinfo)
|
|
|
c178e3 |
slbt_unmap_file(mapinfo);
|
|
|
0913c3 |
}
|
|
|
0913c3 |
|
|
|
c178e3 |
if (plib && (slbt_dprintf(deps,"-l%s\n",plib) < 0)) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
c178e3 |
}
|
|
|
40a467 |
|
|
|
c178e3 |
if (path && (slbt_dprintf(deps,"-L%s\n",path) < 0)) {
|
|
|
c178e3 |
close(deps);
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
c178e3 |
}
|
|
|
0913c3 |
}
|
|
|
0913c3 |
|
|
|
0913c3 |
return 0;
|
|
|
0913c3 |
}
|
|
|
0913c3 |
|
|
|
9112ac |
static int slbt_exec_link_create_import_library(
|
|
|
9112ac |
const struct slbt_driver_ctx * dctx,
|
|
|
9112ac |
struct slbt_exec_ctx * ectx,
|
|
|
9112ac |
char * impfilename,
|
|
|
9112ac |
char * deffilename,
|
|
|
4fdf35 |
char * soname,
|
|
|
4fdf35 |
bool ftag)
|
|
|
9112ac |
{
|
|
|
bfe950 |
int fmdso;
|
|
|
4fdf35 |
char * slash;
|
|
|
bfe950 |
char * eargv[8];
|
|
|
9112ac |
char program[PATH_MAX];
|
|
|
4fdf35 |
char hosttag[PATH_MAX];
|
|
|
4fdf35 |
char hostlnk[PATH_MAX];
|
|
|
4fdf35 |
|
|
|
4fdf35 |
/* libfoo.so.def.{flavor} */
|
|
|
4fdf35 |
if (ftag) {
|
|
|
4fdf35 |
if ((size_t)snprintf(hosttag,sizeof(hosttag),"%s.%s",
|
|
|
4fdf35 |
deffilename,
|
|
|
4fdf35 |
dctx->cctx->host.flavor) >= sizeof(hosttag))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
4fdf35 |
|
|
|
4fdf35 |
if ((size_t)snprintf(hostlnk,sizeof(hostlnk),"%s.host",
|
|
|
4fdf35 |
deffilename) >= sizeof(hostlnk))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
4fdf35 |
|
|
|
4fdf35 |
/* libfoo.so.def is under .libs/ */
|
|
|
4fdf35 |
if (!(slash = strrchr(deffilename,'/')))
|
|
Kylie McClain |
7ce25c |
return SLBT_CUSTOM_ERROR(dctx,SLBT_ERR_LINK_FLOW);
|
|
|
4fdf35 |
|
|
|
4fdf35 |
if (slbt_create_symlink(
|
|
|
4fdf35 |
dctx,ectx,
|
|
|
4fdf35 |
deffilename,
|
|
|
4fdf35 |
hosttag,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
4fdf35 |
|
|
|
4fdf35 |
/* libfoo.so.def.{flavor} is under .libs/ */
|
|
|
4fdf35 |
if (!(slash = strrchr(hosttag,'/')))
|
|
Kylie McClain |
7ce25c |
return SLBT_CUSTOM_ERROR(dctx,SLBT_ERR_LINK_FLOW);
|
|
|
4fdf35 |
|
|
|
4fdf35 |
if (slbt_create_symlink(
|
|
|
4fdf35 |
dctx,ectx,
|
|
|
4fdf35 |
++slash,
|
|
|
4fdf35 |
hostlnk,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
4fdf35 |
}
|
|
|
9112ac |
|
|
|
bfe950 |
/* dlltool or mdso? */
|
|
|
bfe950 |
if (dctx->cctx->drvflags & SLBT_DRIVER_IMPLIB_DSOMETA)
|
|
|
bfe950 |
fmdso = 1;
|
|
|
bfe950 |
|
|
|
bfe950 |
else if (dctx->cctx->drvflags & SLBT_DRIVER_IMPLIB_DSOMETA)
|
|
|
bfe950 |
fmdso = 0;
|
|
|
bfe950 |
|
|
|
bfe950 |
else if (!(strcmp(dctx->cctx->host.flavor,"midipix")))
|
|
|
bfe950 |
fmdso = 1;
|
|
|
9112ac |
|
|
|
bfe950 |
else
|
|
|
bfe950 |
fmdso = 0;
|
|
|
bfe950 |
|
|
|
bfe950 |
/* eargv */
|
|
|
bfe950 |
if (fmdso) {
|
|
|
bfe950 |
if ((size_t)snprintf(program,sizeof(program),"%s",
|
|
|
bfe950 |
dctx->cctx->host.mdso) >= sizeof(program))
|
|
|
bfe950 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
bfe950 |
|
|
|
bfe950 |
eargv[0] = program;
|
|
|
bfe950 |
eargv[1] = "-i";
|
|
|
bfe950 |
eargv[2] = impfilename;
|
|
|
bfe950 |
eargv[3] = "-n";
|
|
|
bfe950 |
eargv[4] = soname;
|
|
|
bfe950 |
eargv[5] = deffilename;
|
|
|
bfe950 |
eargv[6] = 0;
|
|
|
bfe950 |
} else {
|
|
|
bfe950 |
if ((size_t)snprintf(program,sizeof(program),"%s",
|
|
|
bfe950 |
dctx->cctx->host.dlltool) >= sizeof(program))
|
|
|
bfe950 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
bfe950 |
|
|
|
bfe950 |
eargv[0] = program;
|
|
|
bfe950 |
eargv[1] = "-l";
|
|
|
bfe950 |
eargv[2] = impfilename;
|
|
|
bfe950 |
eargv[3] = "-d";
|
|
|
bfe950 |
eargv[4] = deffilename;
|
|
|
bfe950 |
eargv[5] = "-D";
|
|
|
bfe950 |
eargv[6] = soname;
|
|
|
bfe950 |
eargv[7] = 0;
|
|
|
bfe950 |
}
|
|
|
9112ac |
|
|
|
9112ac |
/* alternate argument vector */
|
|
|
bfe950 |
ectx->argv = eargv;
|
|
|
9112ac |
ectx->program = program;
|
|
|
9112ac |
|
|
|
9112ac |
/* step output */
|
|
|
9112ac |
if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
|
|
|
9112ac |
if (slbt_output_link(dctx,ectx))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
9112ac |
|
|
|
bfe950 |
/* dlltool/mdso spawn */
|
|
|
9112ac |
if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
|
|
|
9c9f28 |
return SLBT_SPAWN_ERROR(dctx);
|
|
|
9112ac |
|
|
|
9112ac |
return 0;
|
|
|
9112ac |
}
|
|
|
9112ac |
|
|
|
ec5e56 |
static int slbt_exec_link_create_noop_symlink(
|
|
|
ec5e56 |
const struct slbt_driver_ctx * dctx,
|
|
|
ec5e56 |
struct slbt_exec_ctx * ectx,
|
|
|
ec5e56 |
const char * arfilename)
|
|
|
ec5e56 |
{
|
|
|
ec5e56 |
struct stat st;
|
|
|
7ae5c1 |
int fdcwd;
|
|
|
7ae5c1 |
|
|
|
7ae5c1 |
/* fdcwd */
|
|
|
7ae5c1 |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
ec5e56 |
|
|
|
ec5e56 |
/* file exists? */
|
|
|
7ae5c1 |
if (!fstatat(fdcwd,arfilename,&st,AT_SYMLINK_NOFOLLOW))
|
|
|
ec5e56 |
return 0;
|
|
|
ec5e56 |
|
|
|
ec5e56 |
/* needed? */
|
|
|
ec5e56 |
if (errno == ENOENT) {
|
|
|
ec5e56 |
if (slbt_create_symlink(
|
|
|
ec5e56 |
dctx,ectx,
|
|
|
ec5e56 |
"/dev/null",
|
|
|
ec5e56 |
arfilename,
|
|
|
cc0827 |
SLBT_SYMLINK_LITERAL))
|
|
|
ec5e56 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
ec5e56 |
return 0;
|
|
|
ec5e56 |
}
|
|
|
ec5e56 |
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,arfilename);
|
|
|
ec5e56 |
}
|
|
|
ec5e56 |
|
|
|
3b5e3d |
static int slbt_exec_link_create_archive(
|
|
|
5cc3b3 |
const struct slbt_driver_ctx * dctx,
|
|
|
a51ace |
struct slbt_exec_ctx * ectx,
|
|
|
3b5e3d |
const char * arfilename,
|
|
|
02ae4d |
bool fpic,
|
|
|
02ae4d |
bool fprimary)
|
|
|
5cc3b3 |
{
|
|
|
2fd6a3 |
int fdcwd;
|
|
|
5cc3b3 |
char ** aarg;
|
|
|
5cc3b3 |
char ** parg;
|
|
|
02ae4d |
char * base;
|
|
|
02ae4d |
char * mark;
|
|
|
02ae4d |
char * slash;
|
|
|
3c594d |
char program[PATH_MAX];
|
|
|
3c594d |
char output [PATH_MAX];
|
|
|
02ae4d |
char arfile [PATH_MAX];
|
|
|
02ae4d |
char arlink [PATH_MAX];
|
|
|
5cc3b3 |
|
|
|
175362 |
/* -disable-static? */
|
|
|
175362 |
if (dctx->cctx->drvflags & SLBT_DRIVER_DISABLE_STATIC)
|
|
Felix Janda |
a64776 |
if (dctx->cctx->rpath)
|
|
|
ec5e56 |
return slbt_exec_link_create_noop_symlink(
|
|
|
ec5e56 |
dctx,ectx,arfilename);
|
|
|
175362 |
|
|
|
e7ddb2 |
/* initial state */
|
|
|
e7ddb2 |
slbt_reset_arguments(ectx);
|
|
|
e7ddb2 |
|
|
|
5cc3b3 |
/* placeholders */
|
|
|
5cc3b3 |
slbt_reset_placeholders(ectx);
|
|
|
5cc3b3 |
|
|
|
5cc3b3 |
/* alternate program (ar, ranlib) */
|
|
|
5cc3b3 |
ectx->program = program;
|
|
|
5cc3b3 |
|
|
|
a51ace |
/* output */
|
|
|
a51ace |
if ((size_t)snprintf(output,sizeof(output),"%s",
|
|
|
a51ace |
arfilename) >= sizeof(output))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
a51ace |
|
|
|
5cc3b3 |
/* ar alternate argument vector */
|
|
|
5cc3b3 |
if ((size_t)snprintf(program,sizeof(program),"%s",
|
|
|
5cc3b3 |
dctx->cctx->host.ar) >= sizeof(program))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
5cc3b3 |
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
/* fdcwd */
|
|
|
2fd6a3 |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
2fd6a3 |
|
|
|
2fd6a3 |
/* input argument adjustment */
|
|
|
5cc3b3 |
aarg = ectx->altv;
|
|
|
5cc3b3 |
*aarg++ = program;
|
|
|
0330cf |
*aarg++ = "crs";
|
|
|
a51ace |
*aarg++ = output;
|
|
|
5cc3b3 |
|
|
|
5cc3b3 |
for (parg=ectx->cargv; *parg; parg++)
|
|
|
2fd6a3 |
if (slbt_adjust_object_argument(*parg,fpic,!fpic,fdcwd))
|
|
|
5cc3b3 |
*aarg++ = *parg;
|
|
|
5cc3b3 |
|
|
|
5cc3b3 |
*aarg = 0;
|
|
|
5cc3b3 |
ectx->argv = ectx->altv;
|
|
|
5cc3b3 |
|
|
|
5cc3b3 |
/* step output */
|
|
|
5cc3b3 |
if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
|
|
|
5cc3b3 |
if (slbt_output_link(dctx,ectx))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
5cc3b3 |
|
|
|
628cde |
/* remove old archive as needed */
|
|
|
628cde |
if (slbt_exec_link_remove_file(dctx,ectx,output))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
628cde |
|
|
|
0913c3 |
/* .deps */
|
|
|
e3d03d |
if (slbt_exec_link_create_dep_file(
|
|
|
e3d03d |
dctx,ectx,ectx->cargv,
|
|
|
e3d03d |
arfilename,true))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
0913c3 |
|
|
|
5cc3b3 |
/* ar spawn */
|
|
|
5cc3b3 |
if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
|
|
|
9c9f28 |
return SLBT_SPAWN_ERROR(dctx);
|
|
|
69bc4a |
|
|
|
69bc4a |
/* input objects associated with .la archives */
|
|
|
69bc4a |
for (parg=ectx->cargv; *parg; parg++)
|
|
|
932031 |
if (slbt_adjust_wrapper_argument(*parg,true))
|
|
|
69bc4a |
if (slbt_archive_import(dctx,ectx,output,*parg))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
5cc3b3 |
|
|
|
02ae4d |
if (fprimary && (dctx->cctx->drvflags & SLBT_DRIVER_DISABLE_SHARED)) {
|
|
|
02ae4d |
strcpy(arlink,output);
|
|
|
02ae4d |
mark = strrchr(arlink,'/');
|
|
|
02ae4d |
*mark = 0;
|
|
|
02ae4d |
|
|
|
02ae4d |
base = output + (mark - arlink);
|
|
|
02ae4d |
base++;
|
|
|
02ae4d |
|
|
|
02ae4d |
if ((slash = strrchr(arlink,'/')))
|
|
|
02ae4d |
slash++;
|
|
|
02ae4d |
else
|
|
|
02ae4d |
slash = arlink;
|
|
|
02ae4d |
|
|
|
02ae4d |
strcpy(slash,base);
|
|
|
02ae4d |
sprintf(arfile,".libs/%s",base);
|
|
|
02ae4d |
|
|
|
02ae4d |
if (slbt_exec_link_remove_file(dctx,ectx,arlink))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
02ae4d |
|
|
|
cc0827 |
if (slbt_create_symlink(
|
|
|
cc0827 |
dctx,ectx,
|
|
|
cc0827 |
arfile,arlink,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
b8d3bb |
return SLBT_NESTED_ERROR(dctx);
|
|
|
02ae4d |
}
|
|
|
02ae4d |
|
|
|
5cc3b3 |
return 0;
|
|
|
5cc3b3 |
}
|
|
|
5cc3b3 |
|
|
|
b3940a |
static int slbt_exec_link_create_library(
|
|
|
b3940a |
const struct slbt_driver_ctx * dctx,
|
|
|
b3940a |
struct slbt_exec_ctx * ectx,
|
|
|
08f5f9 |
const char * dsobasename,
|
|
|
112a2b |
const char * dsofilename,
|
|
|
112a2b |
const char * relfilename)
|
|
|
b3940a |
{
|
|
|
dee1f2 |
int fdcwd;
|
|
|
dee1f2 |
char ** parg;
|
|
|
dee1f2 |
char ** xarg;
|
|
|
dee1f2 |
char * ccwrap;
|
|
|
ff7fb8 |
const char * laout;
|
|
|
ff7fb8 |
const char * dot;
|
|
|
dee1f2 |
char cwd [PATH_MAX];
|
|
|
dee1f2 |
char output [PATH_MAX];
|
|
|
dee1f2 |
char soname [PATH_MAX];
|
|
|
dee1f2 |
char symfile[PATH_MAX];
|
|
|
dee1f2 |
struct slbt_deps_meta depsmeta = {0,0,0,0};
|
|
|
b3940a |
|
|
|
b3940a |
/* initial state */
|
|
|
b3940a |
slbt_reset_arguments(ectx);
|
|
|
b3940a |
|
|
|
b3940a |
/* placeholders */
|
|
|
b3940a |
slbt_reset_placeholders(ectx);
|
|
|
b3940a |
|
|
|
2fd6a3 |
/* fdcwd */
|
|
|
2fd6a3 |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
2fd6a3 |
|
|
|
b3940a |
/* input argument adjustment */
|
|
|
b3940a |
for (parg=ectx->cargv; *parg; parg++)
|
|
|
2fd6a3 |
slbt_adjust_object_argument(*parg,true,false,fdcwd);
|
|
|
b3940a |
|
|
|
6fda2b |
/* .deps */
|
|
|
e3d03d |
if (slbt_exec_link_create_dep_file(
|
|
|
e3d03d |
dctx,ectx,ectx->cargv,
|
|
|
e3d03d |
dsofilename,false))
|
|
|
6fda2b |
return slbt_exec_link_exit(
|
|
|
6fda2b |
&depsmeta,
|
|
|
6fda2b |
SLBT_NESTED_ERROR(dctx));
|
|
|
6fda2b |
|
|
|
b3940a |
/* linker argument adjustment */
|
|
|
46aa6f |
for (parg=ectx->cargv, xarg=ectx->xargv; *parg; parg++, xarg++)
|
|
|
afaba2 |
if (slbt_adjust_linker_argument(
|
|
|
9c9f28 |
dctx,
|
|
|
46aa6f |
*parg,xarg,true,
|
|
|
afaba2 |
dctx->cctx->settings.dsosuffix,
|
|
|
8b7d50 |
dctx->cctx->settings.arsuffix,
|
|
|
8b7d50 |
&depsmeta) < 0)
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
b3940a |
|
|
|
b3940a |
/* --no-undefined */
|
|
|
b3940a |
if (dctx->cctx->drvflags & SLBT_DRIVER_NO_UNDEFINED)
|
|
|
b3940a |
*ectx->noundef = "-Wl,--no-undefined";
|
|
|
b3940a |
|
|
|
0f8591 |
/* -soname */
|
|
|
ff7fb8 |
dot = strrchr(dctx->cctx->output,'.');
|
|
|
ff7fb8 |
laout = (dot && !strcmp(dot,".la"))
|
|
|
ff7fb8 |
? dctx->cctx->output
|
|
|
ff7fb8 |
: 0;
|
|
|
ff7fb8 |
|
|
|
b1778b |
if ((dctx->cctx->drvflags & SLBT_DRIVER_IMAGE_MACHO)) {
|
|
|
b1778b |
(void)0;
|
|
|
600957 |
|
|
|
ff7fb8 |
} else if (!laout && (dctx->cctx->drvflags & SLBT_DRIVER_MODULE)) {
|
|
|
712060 |
if ((size_t)snprintf(soname,sizeof(soname),"-Wl,%s",
|
|
|
712060 |
dctx->cctx->output)
|
|
|
712060 |
>= sizeof(soname))
|
|
|
712060 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
712060 |
|
|
|
712060 |
*ectx->soname = "-Wl,-soname";
|
|
|
712060 |
*ectx->lsoname = soname;
|
|
|
712060 |
|
|
|
600957 |
} else if (relfilename && dctx->cctx->verinfo.verinfo) {
|
|
|
08f5f9 |
if ((size_t)snprintf(soname,sizeof(soname),"-Wl,%s%s-%s%s.%d%s",
|
|
|
2f9f52 |
ectx->sonameprefix,
|
|
|
867d1e |
dctx->cctx->libname,
|
|
|
600957 |
dctx->cctx->release,
|
|
|
08f5f9 |
dctx->cctx->settings.osdsuffix,
|
|
|
08f5f9 |
dctx->cctx->verinfo.major,
|
|
|
08f5f9 |
dctx->cctx->settings.osdfussix)
|
|
|
867d1e |
>= sizeof(soname))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
0f8591 |
|
|
|
867d1e |
*ectx->soname = "-Wl,-soname";
|
|
|
867d1e |
*ectx->lsoname = soname;
|
|
|
600957 |
|
|
|
112a2b |
} else if (relfilename) {
|
|
|
112a2b |
if ((size_t)snprintf(soname,sizeof(soname),"-Wl,%s%s-%s%s",
|
|
|
2f9f52 |
ectx->sonameprefix,
|
|
|
112a2b |
dctx->cctx->libname,
|
|
|
112a2b |
dctx->cctx->release,
|
|
|
112a2b |
dctx->cctx->settings.dsosuffix)
|
|
|
112a2b |
>= sizeof(soname))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
112a2b |
|
|
|
112a2b |
*ectx->soname = "-Wl,-soname";
|
|
|
112a2b |
*ectx->lsoname = soname;
|
|
|
600957 |
|
|
|
317432 |
} else if (dctx->cctx->drvflags & SLBT_DRIVER_AVOID_VERSION) {
|
|
|
317432 |
if ((size_t)snprintf(soname,sizeof(soname),"-Wl,%s%s%s",
|
|
|
317432 |
ectx->sonameprefix,
|
|
|
317432 |
dctx->cctx->libname,
|
|
|
317432 |
dctx->cctx->settings.dsosuffix)
|
|
|
317432 |
>= sizeof(soname))
|
|
|
317432 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
317432 |
|
|
|
317432 |
*ectx->soname = "-Wl,-soname";
|
|
|
317432 |
*ectx->lsoname = soname;
|
|
|
317432 |
|
|
|
317432 |
} else {
|
|
|
08f5f9 |
if ((size_t)snprintf(soname,sizeof(soname),"-Wl,%s%s%s.%d%s",
|
|
|
600957 |
ectx->sonameprefix,
|
|
|
600957 |
dctx->cctx->libname,
|
|
|
08f5f9 |
dctx->cctx->settings.osdsuffix,
|
|
|
08f5f9 |
dctx->cctx->verinfo.major,
|
|
|
08f5f9 |
dctx->cctx->settings.osdfussix)
|
|
|
600957 |
>= sizeof(soname))
|
|
|
600957 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
600957 |
|
|
|
600957 |
*ectx->soname = "-Wl,-soname";
|
|
|
600957 |
*ectx->lsoname = soname;
|
|
|
867d1e |
}
|
|
|
0f8591 |
|
|
|
fbb80b |
/* PE: --output-def */
|
|
|
fbb80b |
if (dctx->cctx->drvflags & SLBT_DRIVER_IMAGE_PE) {
|
|
|
fbb80b |
if ((size_t)snprintf(symfile,sizeof(symfile),"-Wl,%s",
|
|
|
fbb80b |
ectx->deffilename)
|
|
|
fbb80b |
>= sizeof(output))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
fbb80b |
|
|
|
fbb80b |
*ectx->symdefs = "-Wl,--output-def";
|
|
|
fbb80b |
*ectx->symfile = symfile;
|
|
|
fbb80b |
}
|
|
|
fbb80b |
|
|
|
372423 |
/* shared/static */
|
|
|
372423 |
if (dctx->cctx->drvflags & SLBT_DRIVER_ALL_STATIC) {
|
|
|
372423 |
*ectx->dpic = "-static";
|
|
|
11e277 |
} else if (dctx->cctx->settings.picswitch) {
|
|
|
11e277 |
*ectx->dpic = "-shared";
|
|
|
11e277 |
*ectx->fpic = dctx->cctx->settings.picswitch;
|
|
|
372423 |
} else {
|
|
|
372423 |
*ectx->dpic = "-shared";
|
|
|
372423 |
}
|
|
|
b3940a |
|
|
|
b3940a |
/* output */
|
|
|
ff7fb8 |
if (!laout && dctx->cctx->drvflags & SLBT_DRIVER_MODULE) {
|
|
|
712060 |
strcpy(output,dctx->cctx->output);
|
|
|
712060 |
} else if (relfilename) {
|
|
|
112a2b |
strcpy(output,relfilename);
|
|
|
112a2b |
} else if (dctx->cctx->drvflags & SLBT_DRIVER_AVOID_VERSION) {
|
|
|
867d1e |
strcpy(output,dsofilename);
|
|
|
867d1e |
} else {
|
|
|
08f5f9 |
if ((size_t)snprintf(output,sizeof(output),"%s%s.%d.%d.%d%s",
|
|
|
08f5f9 |
dsobasename,
|
|
|
08f5f9 |
dctx->cctx->settings.osdsuffix,
|
|
|
867d1e |
dctx->cctx->verinfo.major,
|
|
|
867d1e |
dctx->cctx->verinfo.minor,
|
|
|
08f5f9 |
dctx->cctx->verinfo.revision,
|
|
|
08f5f9 |
dctx->cctx->settings.osdfussix)
|
|
|
867d1e |
>= sizeof(output))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
867d1e |
}
|
|
|
b3940a |
|
|
|
b3940a |
*ectx->lout[0] = "-o";
|
|
|
b3940a |
*ectx->lout[1] = output;
|
|
|
b3940a |
|
|
|
0f5ca7 |
/* ldrpath */
|
|
|
0f5ca7 |
if (dctx->cctx->host.ldrpath) {
|
|
|
0f5ca7 |
if (slbt_exec_link_remove_file(dctx,ectx,ectx->rpathfilename))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
0f5ca7 |
|
|
|
b8d3bb |
if (slbt_create_symlink(
|
|
|
b8d3bb |
dctx,ectx,
|
|
|
b8d3bb |
dctx->cctx->host.ldrpath,
|
|
|
b8d3bb |
ectx->rpathfilename,
|
|
|
cc0827 |
SLBT_SYMLINK_LITERAL))
|
|
|
b8d3bb |
return SLBT_NESTED_ERROR(dctx);
|
|
|
0f5ca7 |
}
|
|
|
0f5ca7 |
|
|
|
79c501 |
/* cwd */
|
|
|
688ec9 |
if (slbt_realpath(fdcwd,".",O_DIRECTORY,cwd,sizeof(cwd)))
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
79c501 |
|
|
|
2ef5be |
/* .libs/libfoo.so --> -L.libs -lfoo */
|
|
|
2ef5be |
if (slbt_exec_link_adjust_argument_vector(
|
|
|
3be47d |
dctx,ectx,&depsmeta,cwd,true))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
2ef5be |
|
|
|
2ef5be |
/* using alternate argument vector */
|
|
|
34988f |
ccwrap = (char *)dctx->cctx->ccwrap;
|
|
|
3be47d |
ectx->argv = depsmeta.altv;
|
|
|
34988f |
ectx->program = ccwrap ? ccwrap : depsmeta.altv[0];
|
|
|
2ef5be |
|
|
|
671454 |
/* sigh */
|
|
|
671454 |
if (slbt_exec_link_finalize_argument_vector(dctx,ectx))
|
|
|
671454 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
671454 |
|
|
|
b3940a |
/* step output */
|
|
|
b3940a |
if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
|
|
|
b3940a |
if (slbt_output_link(dctx,ectx))
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
9c9f28 |
SLBT_NESTED_ERROR(dctx));
|
|
|
b3940a |
|
|
|
b3940a |
/* spawn */
|
|
|
b3940a |
if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
9c9f28 |
SLBT_SPAWN_ERROR(dctx));
|
|
|
b3940a |
|
|
|
3be47d |
return slbt_exec_link_exit(&depsmeta,0);
|
|
|
b3940a |
}
|
|
|
b3940a |
|
|
|
f6ccbe |
static int slbt_exec_link_create_executable(
|
|
|
f6ccbe |
const struct slbt_driver_ctx * dctx,
|
|
|
f6ccbe |
struct slbt_exec_ctx * ectx,
|
|
|
f6ccbe |
const char * exefilename)
|
|
|
f6ccbe |
{
|
|
|
5fac6c |
int fdcwd;
|
|
|
9706fa |
int fdwrap;
|
|
|
f6ccbe |
char ** parg;
|
|
|
46aa6f |
char ** xarg;
|
|
|
e9dbdf |
char * base;
|
|
|
34988f |
char * ccwrap;
|
|
|
5ee0d1 |
char cwd [PATH_MAX];
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
char dpfixup[PATH_MAX];
|
|
|
f6ccbe |
char output [PATH_MAX];
|
|
|
5ee0d1 |
char wrapper[PATH_MAX];
|
|
|
5e5804 |
char wraplnk[PATH_MAX];
|
|
|
238670 |
bool fabspath;
|
|
|
372423 |
bool fpic;
|
|
|
dac9cd |
const struct slbt_source_version * verinfo;
|
|
|
bd9cc9 |
struct slbt_deps_meta depsmeta = {0,0,0,0};
|
|
|
6beda1 |
struct stat st;
|
|
|
f6ccbe |
|
|
|
f6ccbe |
/* initial state */
|
|
|
f6ccbe |
slbt_reset_arguments(ectx);
|
|
|
f6ccbe |
|
|
|
f6ccbe |
/* placeholders */
|
|
|
f6ccbe |
slbt_reset_placeholders(ectx);
|
|
|
f6ccbe |
|
|
|
5fac6c |
/* fdcwd */
|
|
|
5fac6c |
fdcwd = slbt_driver_fdcwd(dctx);
|
|
|
5fac6c |
|
|
|
372423 |
/* fpic */
|
|
|
372423 |
fpic = !(dctx->cctx->drvflags & SLBT_DRIVER_ALL_STATIC);
|
|
|
372423 |
|
|
|
f6ccbe |
/* input argument adjustment */
|
|
|
f6ccbe |
for (parg=ectx->cargv; *parg; parg++)
|
|
|
2fd6a3 |
slbt_adjust_object_argument(*parg,fpic,true,fdcwd);
|
|
|
f6ccbe |
|
|
|
f6ccbe |
/* linker argument adjustment */
|
|
|
46aa6f |
for (parg=ectx->cargv, xarg=ectx->xargv; *parg; parg++, xarg++)
|
|
|
afaba2 |
if (slbt_adjust_linker_argument(
|
|
|
9c9f28 |
dctx,
|
|
|
46aa6f |
*parg,xarg,true,
|
|
|
afaba2 |
dctx->cctx->settings.dsosuffix,
|
|
|
8b7d50 |
dctx->cctx->settings.arsuffix,
|
|
|
8b7d50 |
&depsmeta) < 0)
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
f6ccbe |
|
|
|
f6ccbe |
/* --no-undefined */
|
|
|
f6ccbe |
if (dctx->cctx->drvflags & SLBT_DRIVER_NO_UNDEFINED)
|
|
|
f6ccbe |
*ectx->noundef = "-Wl,--no-undefined";
|
|
|
f6ccbe |
|
|
|
9706fa |
/* executable wrapper: create */
|
|
|
9706fa |
if ((size_t)snprintf(wrapper,sizeof(wrapper),
|
|
|
9706fa |
"%s.wrapper.tmp",
|
|
|
5ee0d1 |
dctx->cctx->output)
|
|
|
5ee0d1 |
>= sizeof(wrapper))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
5ee0d1 |
|
|
|
5fac6c |
if ((fdwrap = openat(fdcwd,wrapper,O_RDWR|O_CREAT|O_TRUNC,0644)) < 0)
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,wrapper);
|
|
|
5ee0d1 |
|
|
|
9706fa |
slbt_exec_set_fdwrapper(ectx,fdwrap);
|
|
|
9706fa |
|
|
|
9706fa |
/* executable wrapper: header */
|
|
|
dac9cd |
verinfo = slbt_source_version();
|
|
|
dac9cd |
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
/* cwd, DL_PATH fixup */
|
|
|
bd56f8 |
if (slbt_realpath(fdcwd,".",O_DIRECTORY,cwd,sizeof(cwd)))
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
bd56f8 |
|
|
|
bd56f8 |
slbt_emit_fdwrap_dl_path_fixup(
|
|
|
bd56f8 |
cwd,dpfixup,sizeof(dpfixup),
|
|
|
bd56f8 |
wrapper);
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
|
|
|
9706fa |
if (slbt_dprintf(fdwrap,
|
|
|
5ee0d1 |
"#!/bin/sh\n"
|
|
|
821d55 |
"# libtool compatible executable wrapper\n"
|
|
|
dac9cd |
"# Generated by %s (slibtool %d.%d.%d)\n"
|
|
|
dac9cd |
"# [commit reference: %s]\n\n"
|
|
|
1f87fd |
|
|
|
5ee0d1 |
"if [ -z \"$%s\" ]; then\n"
|
|
|
5ee0d1 |
"\tDL_PATH=\n"
|
|
|
5ee0d1 |
"\tCOLON=\n"
|
|
|
5ee0d1 |
"\tLCOLON=\n"
|
|
|
5ee0d1 |
"else\n"
|
|
|
5ee0d1 |
"\tDL_PATH=\n"
|
|
|
5ee0d1 |
"\tCOLON=\n"
|
|
|
5ee0d1 |
"\tLCOLON=':'\n"
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
"fi\n\n"
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
"DL_PATH_FIXUP=\"%s\";\n\n",
|
|
|
1f87fd |
|
|
|
1f87fd |
dctx->program,
|
|
|
dac9cd |
verinfo->major,verinfo->minor,verinfo->revision,
|
|
|
dac9cd |
verinfo->commit,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
dctx->cctx->settings.ldpathenv,
|
|
Lucio Andrés Illanes Albornoz |
e945f1 |
dpfixup) < 0)
|
|
|
6beda1 |
return SLBT_SYSTEM_ERROR(dctx,0);
|
|
|
5ee0d1 |
|
|
|
f6ccbe |
/* output */
|
|
|
f6ccbe |
if ((size_t)snprintf(output,sizeof(output),"%s",
|
|
|
f6ccbe |
exefilename)
|
|
|
f6ccbe |
>= sizeof(output))
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
f6ccbe |
|
|
|
f6ccbe |
*ectx->lout[0] = "-o";
|
|
|
f6ccbe |
*ectx->lout[1] = output;
|
|
|
f6ccbe |
|
|
|
e5d83d |
/* static? */
|
|
|
e5d83d |
if (dctx->cctx->drvflags & SLBT_DRIVER_ALL_STATIC)
|
|
|
e5d83d |
*ectx->dpic = "-static";
|
|
|
e5d83d |
|
|
|
2ef5be |
/* .libs/libfoo.so --> -L.libs -lfoo */
|
|
|
2ef5be |
if (slbt_exec_link_adjust_argument_vector(
|
|
|
3be47d |
dctx,ectx,&depsmeta,cwd,false))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
2ef5be |
|
|
|
2ef5be |
/* using alternate argument vector */
|
|
|
34988f |
ccwrap = (char *)dctx->cctx->ccwrap;
|
|
|
3be47d |
ectx->argv = depsmeta.altv;
|
|
|
34988f |
ectx->program = ccwrap ? ccwrap : depsmeta.altv[0];
|
|
|
2ef5be |
|
|
|
4a0a6c |
/* executable wrapper symlink */
|
|
|
4a0a6c |
if ((size_t)snprintf(wraplnk,sizeof(wraplnk),"%s.exe.wrapper",
|
|
|
4a0a6c |
dctx->cctx->output) >= sizeof(wraplnk))
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
9c9f28 |
SLBT_BUFFER_ERROR(dctx));
|
|
|
4a0a6c |
|
|
|
e9dbdf |
/* executable wrapper: base name */
|
|
|
4a0a6c |
if ((base = strrchr(wraplnk,'/')))
|
|
|
e9dbdf |
base++;
|
|
|
e9dbdf |
else
|
|
|
4a0a6c |
base = wraplnk;
|
|
|
e9dbdf |
|
|
|
5ee0d1 |
/* executable wrapper: footer */
|
|
|
238670 |
fabspath = (exefilename[0] == '/');
|
|
|
238670 |
|
|
|
9706fa |
if (slbt_dprintf(fdwrap,
|
|
Lucio Andrés Illanes Albornoz |
acc4e7 |
"DL_PATH=\"${DL_PATH}${LCOLON}${%s}\"\n\n"
|
|
|
92ddbc |
"export %s=\"$DL_PATH\"\n\n"
|
|
|
1ce3d5 |
"if [ $(basename \"$0\") = \"%s\" ]; then\n"
|
|
|
e9dbdf |
"\tprogram=\"$1\"; shift\n"
|
|
|
e9dbdf |
"\texec \"$program\" \"$@\"\n"
|
|
|
e9dbdf |
"fi\n\n"
|
|
|
5ee0d1 |
"exec %s/%s \"$@\"\n",
|
|
|
5ee0d1 |
dctx->cctx->settings.ldpathenv,
|
|
|
5ee0d1 |
dctx->cctx->settings.ldpathenv,
|
|
|
e9dbdf |
base,
|
|
|
238670 |
fabspath ? "" : cwd,
|
|
|
238670 |
fabspath ? &exefilename[1] : exefilename) < 0)
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
6beda1 |
SLBT_SYSTEM_ERROR(dctx,0));
|
|
|
5ee0d1 |
|
|
|
671454 |
/* sigh */
|
|
|
671454 |
if (slbt_exec_link_finalize_argument_vector(dctx,ectx))
|
|
|
671454 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
671454 |
|
|
|
f6ccbe |
/* step output */
|
|
|
f6ccbe |
if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
|
|
|
f6ccbe |
if (slbt_output_link(dctx,ectx))
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
9c9f28 |
SLBT_NESTED_ERROR(dctx));
|
|
|
f6ccbe |
|
|
|
f6ccbe |
/* spawn */
|
|
|
f6ccbe |
if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
9c9f28 |
SLBT_SPAWN_ERROR(dctx));
|
|
|
f6ccbe |
|
|
|
5ee0d1 |
/* executable wrapper: finalize */
|
|
|
9706fa |
slbt_exec_close_fdwrapper(ectx);
|
|
|
5ee0d1 |
|
|
|
5e5804 |
if (slbt_create_symlink(
|
|
|
5e5804 |
dctx,ectx,
|
|
|
5e5804 |
dctx->cctx->output,wraplnk,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
9c9f28 |
SLBT_NESTED_ERROR(dctx));
|
|
|
5e5804 |
|
|
|
7ae5c1 |
if (fstatat(fdcwd,wrapper,&st,0))
|
|
|
6beda1 |
return slbt_exec_link_exit(
|
|
|
6beda1 |
&depsmeta,
|
|
|
6beda1 |
SLBT_SYSTEM_ERROR(dctx,wrapper));
|
|
|
6beda1 |
|
|
|
d586fc |
if (renameat(fdcwd,wrapper,fdcwd,dctx->cctx->output))
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
6beda1 |
SLBT_SYSTEM_ERROR(dctx,dctx->cctx->output));
|
|
|
5ee0d1 |
|
|
|
289362 |
if (fchmodat(fdcwd,dctx->cctx->output,0755,0))
|
|
|
9c9f28 |
return slbt_exec_link_exit(
|
|
|
9c9f28 |
&depsmeta,
|
|
|
6beda1 |
SLBT_SYSTEM_ERROR(dctx,dctx->cctx->output));
|
|
|
5ee0d1 |
|
|
|
3be47d |
return slbt_exec_link_exit(&depsmeta,0);
|
|
|
f6ccbe |
}
|
|
|
f6ccbe |
|
|
|
b3940a |
static int slbt_exec_link_create_library_symlink(
|
|
|
b3940a |
const struct slbt_driver_ctx * dctx,
|
|
|
b3940a |
struct slbt_exec_ctx * ectx,
|
|
|
b3940a |
bool fmajor)
|
|
|
b3940a |
{
|
|
|
b3940a |
char target[PATH_MAX];
|
|
|
b3940a |
char lnkname[PATH_MAX];
|
|
|
b3940a |
|
|
|
112a2b |
if (ectx->relfilename) {
|
|
|
112a2b |
strcpy(target,ectx->relfilename);
|
|
|
112a2b |
sprintf(lnkname,"%s.release",ectx->dsofilename);
|
|
|
112a2b |
|
|
|
f23d99 |
if (!dctx->cctx->verinfo.verinfo)
|
|
|
f23d99 |
if (slbt_create_symlink(
|
|
|
f23d99 |
dctx,ectx,
|
|
|
f23d99 |
target,lnkname,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
f23d99 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
600957 |
} else {
|
|
|
08f5f9 |
sprintf(target,"%s%s.%d.%d.%d%s",
|
|
|
08f5f9 |
ectx->dsobasename,
|
|
|
08f5f9 |
dctx->cctx->settings.osdsuffix,
|
|
|
112a2b |
dctx->cctx->verinfo.major,
|
|
|
112a2b |
dctx->cctx->verinfo.minor,
|
|
|
08f5f9 |
dctx->cctx->verinfo.revision,
|
|
|
08f5f9 |
dctx->cctx->settings.osdfussix);
|
|
|
600957 |
}
|
|
|
600957 |
|
|
|
b3940a |
|
|
|
600957 |
if (fmajor && ectx->dsorellnkname) {
|
|
|
600957 |
sprintf(lnkname,"%s.%d",
|
|
|
600957 |
ectx->dsorellnkname,
|
|
|
600957 |
dctx->cctx->verinfo.major);
|
|
|
600957 |
|
|
|
600957 |
} else if (fmajor) {
|
|
|
08f5f9 |
sprintf(lnkname,"%s%s.%d%s",
|
|
|
08f5f9 |
ectx->dsobasename,
|
|
|
08f5f9 |
dctx->cctx->settings.osdsuffix,
|
|
|
08f5f9 |
dctx->cctx->verinfo.major,
|
|
|
08f5f9 |
dctx->cctx->settings.osdfussix);
|
|
|
b3940a |
|
|
|
600957 |
} else {
|
|
|
b3940a |
strcpy(lnkname,ectx->dsofilename);
|
|
|
600957 |
}
|
|
|
600957 |
|
|
|
b3940a |
|
|
|
dbd229 |
if (fmajor && (dctx->cctx->drvflags & SLBT_DRIVER_IMAGE_PE))
|
|
|
dbd229 |
return slbt_copy_file(
|
|
|
dbd229 |
dctx,ectx,
|
|
|
dbd229 |
target,lnkname);
|
|
|
dbd229 |
else
|
|
|
dbd229 |
return slbt_create_symlink(
|
|
|
dbd229 |
dctx,ectx,
|
|
|
dbd229 |
target,lnkname,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT);
|
|
|
b3940a |
}
|
|
|
b3940a |
|
|
|
2bd749 |
int slbt_exec_link(
|
|
|
2bd749 |
const struct slbt_driver_ctx * dctx,
|
|
|
2bd749 |
struct slbt_exec_ctx * ectx)
|
|
|
2bd749 |
{
|
|
|
2bd749 |
int ret;
|
|
|
a51ace |
const char * output;
|
|
|
2bd749 |
char * dot;
|
|
|
2bd749 |
struct slbt_exec_ctx * actx;
|
|
|
372423 |
bool fpic;
|
|
|
372423 |
bool fstaticonly;
|
|
|
9112ac |
char soname[PATH_MAX];
|
|
|
4469ed |
char soxyz [PATH_MAX];
|
|
|
4469ed |
char solnk [PATH_MAX];
|
|
|
4469ed |
char arname[PATH_MAX];
|
|
|
d75902 |
char target[PATH_MAX];
|
|
|
d75902 |
char lnkname[PATH_MAX];
|
|
|
4469ed |
|
|
|
c4a389 |
/* dry run */
|
|
|
c4a389 |
if (dctx->cctx->drvflags & SLBT_DRIVER_DRY_RUN)
|
|
|
c4a389 |
return 0;
|
|
|
c4a389 |
|
|
|
2f9f52 |
/* context */
|
|
|
2f9f52 |
if (ectx)
|
|
|
2f9f52 |
actx = 0;
|
|
|
2f9f52 |
else if ((ret = slbt_get_exec_ctx(dctx,&ectx)))
|
|
|
2f9f52 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
2f9f52 |
else
|
|
|
2f9f52 |
actx = ectx;
|
|
|
2f9f52 |
|
|
|
4469ed |
/* libfoo.so.x.y.z */
|
|
|
08f5f9 |
if ((size_t)snprintf(soxyz,sizeof(soxyz),"%s%s%s.%d.%d.%d%s",
|
|
|
2f9f52 |
ectx->sonameprefix,
|
|
|
4469ed |
dctx->cctx->libname,
|
|
|
08f5f9 |
dctx->cctx->settings.osdsuffix,
|
|
|
4469ed |
dctx->cctx->verinfo.major,
|
|
|
4469ed |
dctx->cctx->verinfo.minor,
|
|
|
08f5f9 |
dctx->cctx->verinfo.revision,
|
|
|
08f5f9 |
dctx->cctx->settings.osdfussix)
|
|
|
2f9f52 |
>= sizeof(soxyz)) {
|
|
|
2f9f52 |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_BUFFER_ERROR(dctx);
|
|
|
2f9f52 |
}
|
|
|
4469ed |
|
|
|
4469ed |
/* libfoo.so.x */
|
|
|
08f5f9 |
sprintf(soname,"%s%s%s.%d%s",
|
|
|
2f9f52 |
ectx->sonameprefix,
|
|
|
4469ed |
dctx->cctx->libname,
|
|
|
08f5f9 |
dctx->cctx->settings.osdsuffix,
|
|
|
08f5f9 |
dctx->cctx->verinfo.major,
|
|
|
08f5f9 |
dctx->cctx->settings.osdfussix);
|
|
|
4469ed |
|
|
|
4469ed |
/* libfoo.so */
|
|
|
4469ed |
sprintf(solnk,"%s%s%s",
|
|
|
2f9f52 |
ectx->sonameprefix,
|
|
|
4469ed |
dctx->cctx->libname,
|
|
|
4469ed |
dctx->cctx->settings.dsosuffix);
|
|
|
4469ed |
|
|
|
4469ed |
/* libfoo.a */
|
|
|
4469ed |
sprintf(arname,"%s%s%s",
|
|
|
4469ed |
dctx->cctx->settings.arprefix,
|
|
|
4469ed |
dctx->cctx->libname,
|
|
|
4469ed |
dctx->cctx->settings.arsuffix);
|
|
|
2bd749 |
|
|
|
5cc3b3 |
/* output suffix */
|
|
|
a51ace |
output = dctx->cctx->output;
|
|
|
a51ace |
dot = strrchr(output,'.');
|
|
|
5cc3b3 |
|
|
|
2bd749 |
/* .libs directory */
|
|
|
267766 |
if (slbt_mkdir(dctx,ectx->ldirname)) {
|
|
|
c141a0 |
ret = SLBT_SYSTEM_ERROR(dctx,ectx->ldirname);
|
|
|
723ef0 |
slbt_free_exec_ctx(actx);
|
|
|
c141a0 |
return ret;
|
|
|
723ef0 |
}
|
|
|
2bd749 |
|
|
|
5cc3b3 |
/* non-pic libfoo.a */
|
|
|
5cc3b3 |
if (dot && !strcmp(dot,".a"))
|
|
|
02ae4d |
if (slbt_exec_link_create_archive(dctx,ectx,output,false,false)) {
|
|
|
5cc3b3 |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
5cc3b3 |
}
|
|
|
5cc3b3 |
|
|
|
372423 |
/* fpic, fstaticonly */
|
|
|
372423 |
if (dctx->cctx->drvflags & SLBT_DRIVER_ALL_STATIC) {
|
|
|
372423 |
fstaticonly = true;
|
|
|
372423 |
fpic = false;
|
|
|
f782a1 |
} else if (dctx->cctx->drvflags & SLBT_DRIVER_DISABLE_SHARED) {
|
|
|
f782a1 |
fstaticonly = true;
|
|
|
f782a1 |
fpic = false;
|
|
|
2c2879 |
} else if (dctx->cctx->drvflags & SLBT_DRIVER_DISABLE_STATIC) {
|
|
|
2c2879 |
fstaticonly = false;
|
|
|
2c2879 |
fpic = true;
|
|
|
372423 |
} else if (dctx->cctx->drvflags & SLBT_DRIVER_SHARED) {
|
|
|
372423 |
fstaticonly = false;
|
|
|
372423 |
fpic = true;
|
|
|
372423 |
} else {
|
|
|
372423 |
fstaticonly = false;
|
|
|
372423 |
fpic = false;
|
|
|
372423 |
}
|
|
|
372423 |
|
|
|
a0c318 |
/* pic libfoo.a */
|
|
|
a0c318 |
if (dot && !strcmp(dot,".la"))
|
|
|
a0c318 |
if (slbt_exec_link_create_archive(
|
|
|
a0c318 |
dctx,ectx,
|
|
|
a0c318 |
ectx->arfilename,
|
|
|
02ae4d |
fpic,true)) {
|
|
|
a0c318 |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
a0c318 |
}
|
|
|
a0c318 |
|
|
|
372423 |
/* -all-static library */
|
|
|
372423 |
if (fstaticonly && dctx->cctx->libname)
|
|
|
372423 |
if (slbt_create_symlink(
|
|
|
372423 |
dctx,ectx,
|
|
|
372423 |
"/dev/null",
|
|
|
372423 |
ectx->dsofilename,
|
|
|
cc0827 |
SLBT_SYMLINK_LITERAL))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
372423 |
|
|
|
d83e2a |
/* dynamic library via -module */
|
|
|
89f5e3 |
if (dctx->cctx->rpath && !fstaticonly) {
|
|
|
89f5e3 |
if (dctx->cctx->drvflags & SLBT_DRIVER_MODULE) {
|
|
|
89f5e3 |
if (!dot || strcmp(dot,".la")) {
|
|
|
89f5e3 |
if (slbt_exec_link_create_library(
|
|
|
89f5e3 |
dctx,ectx,
|
|
|
89f5e3 |
ectx->dsobasename,
|
|
|
89f5e3 |
ectx->dsofilename,
|
|
|
89f5e3 |
ectx->relfilename)) {
|
|
|
89f5e3 |
slbt_free_exec_ctx(actx);
|
|
|
89f5e3 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
89f5e3 |
}
|
|
|
89f5e3 |
|
|
|
ff7fb8 |
slbt_free_exec_ctx(actx);
|
|
|
89f5e3 |
return 0;
|
|
|
ff7fb8 |
}
|
|
|
712060 |
}
|
|
|
712060 |
}
|
|
|
712060 |
|
|
|
b3940a |
/* dynamic library */
|
|
|
372423 |
if (dot && !strcmp(dot,".la") && dctx->cctx->rpath && !fstaticonly) {
|
|
|
d75902 |
/* -shrext support */
|
|
|
d75902 |
if (dctx->cctx->shrext) {
|
|
|
d75902 |
strcpy(target,ectx->lafilename);
|
|
|
d75902 |
sprintf(lnkname,"%s.shrext%s",ectx->lafilename,dctx->cctx->shrext);
|
|
|
d75902 |
|
|
|
d75902 |
if (slbt_create_symlink(
|
|
|
d75902 |
dctx,ectx,
|
|
|
d75902 |
target,lnkname,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
d75902 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
d75902 |
|
|
|
d75902 |
strcpy(target,lnkname);
|
|
|
d75902 |
sprintf(lnkname,"%s.shrext",ectx->lafilename);
|
|
|
d75902 |
|
|
|
d75902 |
if (slbt_create_symlink(
|
|
|
d75902 |
dctx,ectx,
|
|
|
d75902 |
target,lnkname,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
d75902 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
d75902 |
}
|
|
|
d75902 |
|
|
|
d75902 |
|
|
|
b3940a |
/* linking: libfoo.so.x.y.z */
|
|
|
b3940a |
if (slbt_exec_link_create_library(
|
|
|
b3940a |
dctx,ectx,
|
|
|
08f5f9 |
ectx->dsobasename,
|
|
|
112a2b |
ectx->dsofilename,
|
|
|
112a2b |
ectx->relfilename)) {
|
|
|
b3940a |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
b3940a |
}
|
|
|
b3940a |
|
|
|
867d1e |
if (!(dctx->cctx->drvflags & SLBT_DRIVER_AVOID_VERSION)) {
|
|
|
867d1e |
/* symlink: libfoo.so.x --> libfoo.so.x.y.z */
|
|
|
867d1e |
if (slbt_exec_link_create_library_symlink(
|
|
|
867d1e |
dctx,ectx,
|
|
|
867d1e |
true)) {
|
|
|
867d1e |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
867d1e |
}
|
|
|
b3940a |
|
|
|
867d1e |
/* symlink: libfoo.so --> libfoo.so.x.y.z */
|
|
|
867d1e |
if (slbt_exec_link_create_library_symlink(
|
|
|
867d1e |
dctx,ectx,
|
|
|
867d1e |
false)) {
|
|
|
867d1e |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
867d1e |
}
|
|
|
112a2b |
} else if (ectx->relfilename) {
|
|
|
112a2b |
/* symlink: libfoo.so --> libfoo-x.y.z.so */
|
|
|
112a2b |
if (slbt_exec_link_create_library_symlink(
|
|
|
112a2b |
dctx,ectx,
|
|
|
112a2b |
false)) {
|
|
|
112a2b |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
112a2b |
}
|
|
|
b3940a |
}
|
|
|
9112ac |
|
|
|
9112ac |
/* PE import libraries */
|
|
|
9112ac |
if (dctx->cctx->drvflags & SLBT_DRIVER_IMAGE_PE) {
|
|
|
ff4b97 |
/* libfoo.x.lib.a */
|
|
|
9112ac |
if (slbt_exec_link_create_import_library(
|
|
|
9112ac |
dctx,ectx,
|
|
|
ff4b97 |
ectx->pimpfilename,
|
|
|
9112ac |
ectx->deffilename,
|
|
|
4fdf35 |
soname,
|
|
|
4fdf35 |
true))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
9112ac |
|
|
|
ff4b97 |
/* symlink: libfoo.lib.a --> libfoo.x.lib.a */
|
|
|
ff4b97 |
if (slbt_create_symlink(
|
|
|
9112ac |
dctx,ectx,
|
|
|
9112ac |
ectx->pimpfilename,
|
|
|
ff4b97 |
ectx->dimpfilename,
|
|
|
cc0827 |
SLBT_SYMLINK_DEFAULT))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
9112ac |
|
|
|
9112ac |
/* libfoo.x.y.z.lib.a */
|
|
|
9112ac |
if (slbt_exec_link_create_import_library(
|
|
|
9112ac |
dctx,ectx,
|
|
|
9112ac |
ectx->vimpfilename,
|
|
|
9112ac |
ectx->deffilename,
|
|
|
4469ed |
soxyz,
|
|
|
4fdf35 |
false))
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
9112ac |
}
|
|
|
b3940a |
}
|
|
|
b3940a |
|
|
|
f6ccbe |
/* executable */
|
|
|
a02c0e |
if (!dctx->cctx->libname) {
|
|
|
f6ccbe |
/* linking: .libs/exefilename */
|
|
|
f6ccbe |
if (slbt_exec_link_create_executable(
|
|
|
f6ccbe |
dctx,ectx,
|
|
|
f6ccbe |
ectx->exefilename)) {
|
|
|
f6ccbe |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
f6ccbe |
}
|
|
|
f6ccbe |
}
|
|
|
f6ccbe |
|
|
|
2bd749 |
/* no wrapper? */
|
|
|
5cc3b3 |
if (!dot || strcmp(dot,".la")) {
|
|
|
2bd749 |
slbt_free_exec_ctx(actx);
|
|
|
2bd749 |
return 0;
|
|
|
2bd749 |
}
|
|
|
2bd749 |
|
|
|
a9cfe4 |
/* library wrapper */
|
|
|
a9cfe4 |
if (slbt_create_library_wrapper(
|
|
|
a9cfe4 |
dctx,ectx,
|
|
|
a9cfe4 |
arname,soname,soxyz,solnk)) {
|
|
|
2bd749 |
slbt_free_exec_ctx(actx);
|
|
|
9c9f28 |
return SLBT_NESTED_ERROR(dctx);
|
|
|
2bd749 |
}
|
|
|
2bd749 |
|
|
|
4c76f7 |
/* wrapper symlink */
|
|
|
9c9f28 |
if ((ret = slbt_create_symlink(
|
|
|
a9cfe4 |
dctx,ectx,
|
|
|
a9cfe4 |
output,
|
|
|
a9cfe4 |
ectx->lafilename,
|
|
|
cc0827 |
SLBT_SYMLINK_WRAPPER)))
|
|
|
9c9f28 |
SLBT_NESTED_ERROR(dctx);
|
|
|
4c76f7 |
|
|
|
26ea30 |
/* .lai wrapper symlink */
|
|
|
26ea30 |
if (ret == 0)
|
|
|
9c9f28 |
if ((ret = slbt_create_symlink(
|
|
|
26ea30 |
dctx,ectx,
|
|
|
26ea30 |
output,
|
|
|
26ea30 |
ectx->laifilename,
|
|
|
cc0827 |
SLBT_SYMLINK_WRAPPER)))
|
|
|
9c9f28 |
SLBT_NESTED_ERROR(dctx);
|
|
|
26ea30 |
|
|
|
2bd749 |
/* all done */
|
|
|
2bd749 |
slbt_free_exec_ctx(actx);
|
|
|
2bd749 |
|
|
|
4469ed |
return ret;
|
|
|
2bd749 |
}
|