/*******************************************************************/
/* slibtool: a strong libtool implementation, written in C */
/* Copyright (C) 2016--2024 SysDeer Technologies, LLC */
/* Released under the Standard MIT License; see COPYING.SLIBTOOL. */
/*******************************************************************/
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <slibtool/slibtool.h>
#include "slibtool_driver_impl.h"
#include "slibtool_mkdir_impl.h"
#include "slibtool_linkcmd_impl.h"
#include "slibtool_errinfo_impl.h"
#include "slibtool_ar_impl.h"
#define SLBT_ECTX_LIB_EXTRAS 26
#define SLBT_ECTX_SPARE_PTRS 16
static int slbt_ectx_free_exec_ctx_impl(
struct slbt_exec_ctx_impl * ictx,
int status);
static size_t slbt_parse_comma_separated_flags(
const char * str,
int * argc)
{
const char * ch;
for (ch=str; *ch; ch++)
if (*ch == ',')
(*argc)++;
return ch - str;
}
static char * slbt_source_file(char ** argv)
{
char ** parg;
char * ch;
for (parg=argv; *parg; parg++)
if ((ch = strrchr(*parg,'.')))
if ((!(strcmp(++ch,"s")))
|| (!(strcmp(ch,"S")))
|| (!(strcmp(ch,"asm")))
|| (!(strcmp(ch,"c")))
|| (!(strcmp(ch,"cc")))
|| (!(strcmp(ch,"cpp")))
|| (!(strcmp(ch,"cxx"))))
return *parg;
return 0;
}
static int slbt_exec_ctx_tool_argc(char ** argv)
{
char ** parg;
if (!(parg = argv))
return 0;
for (; *parg; )
parg++;
return parg - argv + 1;
}
static struct slbt_exec_ctx_impl * slbt_exec_ctx_alloc(
const struct slbt_driver_ctx * dctx)
{
struct slbt_driver_ctx_impl * ctx;
struct slbt_exec_ctx_impl * ictx;
size_t size;
size_t slen;
size_t exts;
int argc;
char * args;
char * shadow;
char * csrc;
char ** parg;
struct slbt_archive_ctx ** dlactxv;
size_t ndlopen;
/* internal driver context for host-specific tool arguments */
ctx = slbt_get_driver_ictx(dctx);
/* initial buffer size (cargv, -Wc), .libs/.exe.wrapper */
argc = 0;
csrc = 0;
size = 0;
exts = 20;
for (parg=dctx->cctx->cargv; *parg; parg++, argc++) {
if (!(strncmp("-Wc,",*parg,4))) {
size += slbt_parse_comma_separated_flags(
&(*parg)[4],&argc) + 1;
} else {
size += strlen(*parg) + 1;
}
}
/* argument transformation: assume for each argv member */
if (dctx->cctx->shrext) {
exts += argc * (strlen(dctx->cctx->shrext));
}
if (dctx->cctx->settings.dsosuffix) {
exts += argc * (strlen(dctx->cctx->settings.dsosuffix));
}
size += argc * exts;
/* buffer size (csrc, ldirname, lbasename, lobjname, aobjname, etc.) */
if (dctx->cctx->libname) {
slen = strlen(dctx->cctx->libname);
size += (strlen(".slibtool.expsyms.extension") + slen + exts + 1) * SLBT_ECTX_LIB_EXTRAS;
} else if (dctx->cctx->output) {
slen = strlen(dctx->cctx->output);
size += (strlen(".slibtool.expsyms.extension") + slen + exts + 1) * SLBT_ECTX_LIB_EXTRAS;
} else if ((csrc = slbt_source_file(dctx->cctx->cargv))) {
slen = strlen(csrc);
size += (strlen(".slibtool.expsyms.extension") + slen + exts + 1) * SLBT_ECTX_LIB_EXTRAS;
} else {
size += exts * SLBT_ECTX_LIB_EXTRAS;
}
/* string buffers: args, shadow */
if (!(args = malloc(size)))
return 0;
if (!(shadow = malloc(size))) {
free(args);
return 0;
}
/* tool-specific argv: to simplify matters, be additive */
argc += slbt_exec_ctx_tool_argc(ctx->host.ar_argv);
argc += slbt_exec_ctx_tool_argc(ctx->host.as_argv);
argc += slbt_exec_ctx_tool_argc(ctx->host.nm_argv);
argc += slbt_exec_ctx_tool_argc(ctx->host.ranlib_argv);
argc += slbt_exec_ctx_tool_argc(ctx->host.windres_argv);
argc += slbt_exec_ctx_tool_argc(ctx->host.dlltool_argv);
argc += slbt_exec_ctx_tool_argc(ctx->host.mdso_argv);
/* argv transformation: .libs/libfoo.so --> -L.libs -lfoo */
argc *= 2;
/* argv ad-hoc extensions */
argc += SLBT_ECTX_SPARE_PTRS;
/* ctx alloc and vector alloc: argv, xargv, and altv, where we */
/* assume -Wl,--whole-archive arg -Wl,--no-whole-archive; */
/* and also dlargv for compiling dlunit.dlopen.c */
if (!(ictx = calloc(1,sizeof(*ictx)))) {
free(args);
free(shadow);
return 0;
}
if (!(ictx->vbuffer = calloc(6*(argc+1),sizeof(char *)))) {
free(args);
free(shadow);
free(ictx);
}
if ((ndlopen = (slbt_get_driver_ictx(dctx))->ndlopen)) {
if (!(dlactxv = calloc(ndlopen+1,sizeof(*dlactxv)))) {
free(ictx->vbuffer);
free(ictx);
free(args);
free(shadow);
}
ictx->dlactxv = dlactxv;
}
/* all ready */
ictx->dctx = dctx;
ictx->args = args;
ictx->argc = argc;
ictx->size = size;
ictx->exts = exts;
ictx->shadow = shadow;
ictx->ctx.csrc = csrc;
ictx->fdwrapper = (-1);
ictx->ctx.envp = slbt_driver_envp(dctx);
return ictx;
}
int slbt_ectx_get_exec_ctx(
const struct slbt_driver_ctx * dctx,
struct slbt_exec_ctx ** ectx)
{
struct slbt_exec_ctx_impl * ictx;
struct slbt_driver_ctx_impl * idctx;
struct slbt_error_info** errinfp;
char ** parg;
char ** src;
char ** dst;
char * ch;
char * mark;
const char * dmark;
const char * dsoext;
char * slash;
char * arname;
struct slbt_archive_ctx ** dlactxv;
struct argv_entry * dlentry;
struct argv_entry ** dlopenv;
bool fpreopen;
const char * arprefix;
const char * dsoprefix;
const char * impprefix;
const char * ref;
int i;
/* internal driver context */
idctx = slbt_get_driver_ictx(dctx);
/* alloc */
if (!(ictx = slbt_exec_ctx_alloc(dctx)))
return SLBT_NESTED_ERROR(dctx);
/* init with guard for later .lo check */
ch = ictx->args + strlen(".lo");
ictx->ctx.argv = ictx->vbuffer;
ictx->ctx.xargv = &ictx->ctx.argv [ictx->argc + 1];
ictx->ctx.altv = &ictx->ctx.xargv[ictx->argc + 1];
ictx->dlargv = &ictx->ctx.altv [ictx->argc + 1];
/* <compiler> */
ictx->ctx.compiler = dctx->cctx->cargv[0];
ictx->ctx.cargv = ictx->ctx.argv;
/* ldirname, lbasename */
ref = (dctx->cctx->output)
? dctx->cctx->output
: ictx->ctx.csrc;
if (ref && !ictx->ctx.csrc && (mark = strrchr(ref,'/'))) {
if (!(strncmp(ref,"../",3)))
dmark = 0;
else if (!(strncmp(ref,"./",2)))
dmark = &ref[1];
else
dmark = strchr(ref,'/');
for (; dmark; ) {
if (!(strncmp(dmark,"/./",3))) {
dmark = strchr(&dmark[2],'/');
} else if (!(strncmp(dmark,"/../",4))) {
ictx->ctx.ldirdepth = -1;
dmark = 0;
} else {
for (; *dmark=='/'; )
dmark++;
ictx->ctx.ldirdepth++;
dmark = strchr(dmark,'/');
}
}
ictx->ctx.ldirname = ch;
strcpy(ch,ref);
ch += mark - ref;
ch += sprintf(ch,"%s","/.libs/");
ch++;
ictx->ctx.lbasename = ch;
ch += sprintf(ch,"%s",++mark);
ch++;
} else if (ref) {
ictx->ctx.ldirname = ch;
ch += sprintf(ch,"%s",".libs/");
ch++;
ictx->ctx.lbasename = ch;
mark = strrchr(ref,'/');
ch += sprintf(ch,"%s",mark ? ++mark : ref);
ch++;
}
/* lbasename suffix */
if (ref && (dctx->cctx->mode == SLBT_MODE_COMPILE)) {
if ((ch[-4] == '.') && (ch[-3] == 'l') && (ch[-2] == 'o')) {
ch[-3] = 'o';
ch[-2] = 0;
ch--;
} else if (ictx->ctx.csrc) {
if ((mark = strrchr(ictx->ctx.lbasename,'.'))) {
ch = mark;
*++ch = 'o';
*++ch = 0;
ch++;
}
}
}
/* cargv, -Wc */
for (i=0, parg=dctx->cctx->cargv; *parg; parg++, ch++) {
if (!(strncmp("-Wc,",*parg,4))) {
strcpy(ch,&(*parg)[4]);
ictx->ctx.argv[i++] = ch;
for (; *ch; ch++)
if (*ch == ',') {
*ch++ = 0;
ictx->ctx.argv[i++] = ch;
}
} else {
ictx->ctx.argv[i++] = ch;
ch += sprintf(ch,"%s",*parg);
ch += ictx->exts;
}
}
/* placeholders for -DPIC, -fPIC, -c, -o, <output> */
ictx->ctx.dpic = &ictx->ctx.argv[i++];
ictx->ctx.fpic = &ictx->ctx.argv[i++];
ictx->ctx.cass = &ictx->ctx.argv[i++];
ictx->ctx.noundef = &ictx->ctx.argv[i++];
ictx->ctx.soname = &ictx->ctx.argv[i++];
ictx->ctx.lsoname = &ictx->ctx.argv[i++];
ictx->ctx.symdefs = &ictx->ctx.argv[i++];
ictx->ctx.symfile = &ictx->ctx.argv[i++];
ictx->ctx.explarg = &ictx->ctx.argv[i++];
ictx->ctx.expsyms = &ictx->ctx.argv[i++];
ictx->ctx.lout[0] = &ictx->ctx.argv[i++];
ictx->ctx.lout[1] = &ictx->ctx.argv[i++];
ictx->ctx.rpath[0] = &ictx->ctx.argv[i++];
ictx->ctx.rpath[1] = &ictx->ctx.argv[i++];
ictx->ctx.sentinel= &ictx->ctx.argv[i++];
slbt_reset_placeholders(&ictx->ctx);
/* dsoprefix */
if (dctx->cctx->settings.dsoprefix) {
ictx->dsoprefix = ch;
strcpy(ch,dctx->cctx->settings.dsoprefix);
ch += strlen(ch) + 1;
}
/* output file name */
if (ref && ((dctx->cctx->mode == SLBT_MODE_COMPILE))) {
*ictx->ctx.lout[0] = "-o";
*ictx->ctx.lout[1] = ch;
ictx->ctx.lobjname = ch;
ch += sprintf(ch,"%s%s",
ictx->ctx.ldirname,
ictx->ctx.lbasename)
+ 1;
ictx->ctx.aobjname = ch;
ch += sprintf(ch,"%s",ictx->ctx.ldirname);
ch -= strlen(".libs/");
ch += sprintf(ch,"%s",
ictx->ctx.lbasename)
+ 1;
ictx->ctx.ltobjname = ch;
strcpy(ch,ictx->ctx.aobjname);
if ((mark = strrchr(ch,'.')))
ch = mark + sprintf(mark,"%s",".lo")
+ 1;
}
/* linking: arfilename, lafilename, laifilename, dsobasename, dsofilename, mapfilename */
if (dctx->cctx->mode == SLBT_MODE_LINK && dctx->cctx->libname) {
if (!(dsoext = dctx->cctx->shrext))
dsoext = dctx->cctx->settings.dsosuffix;
/* arprefix, dsoprefix */
if (dctx->cctx->drvflags & SLBT_DRIVER_MODULE) {
ictx->ctx.sonameprefix = "";
arprefix = "";
dsoprefix = "";
impprefix = "";
} else {
ictx->ctx.sonameprefix = ictx->dsoprefix;
arprefix = dctx->cctx->settings.arprefix;
dsoprefix = dctx->cctx->settings.dsoprefix;
impprefix = dctx->cctx->settings.impprefix;
}
/* arfilename */
ictx->ctx.arfilename = ch;
ch += sprintf(ch,"%s%s%s%s",
ictx->ctx.ldirname,
arprefix,
dctx->cctx->libname,
dctx->cctx->settings.arsuffix);
ch++;
/* lafilename */
ictx->ctx.lafilename = ch;
ch += sprintf(ch,"%s%s%s.la",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname);
ch++;
/* laifilename */
ictx->ctx.laifilename = ch;
ch += sprintf(ch,"%s%s%s.lai",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname);
ch++;
/* dsobasename */
ictx->ctx.dsobasename = ch;
ch += sprintf(ch,"%s%s%s",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname);
ch++;
/* dsofilename */
ictx->ctx.dsofilename = ch;
ch += sprintf(ch,"%s%s%s%s",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname,
dsoext);
ch++;
/* mapfilename */
ictx->ctx.mapfilename = ch;
ch += sprintf(ch,"%s%s%s%s%s%s",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname,
dctx->cctx->release ? "-" : "",
dctx->cctx->release ? dctx->cctx->release : "",
dctx->cctx->settings.mapsuffix);
ch++;
/* deffilename */
ictx->ctx.deffilename = ch;
ch += sprintf(ch,"%s%s%s%s%s%s.def",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname,
dctx->cctx->release ? "-" : "",
dctx->cctx->release ? dctx->cctx->release : "",
dsoext);
ch++;
/* rpathfilename */
ictx->ctx.rpathfilename = ch;
ch += sprintf(ch,"%s%s%s%s.slibtool.rpath",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname,
dsoext);
ch++;
/* default implib file name */
ictx->ctx.dimpfilename = ch;
ch += sprintf(ch,"%s%s%s%s",
ictx->ctx.ldirname,
impprefix,
dctx->cctx->libname,
dctx->cctx->settings.impsuffix);
ch++;
/* primary implib file name */
ictx->ctx.pimpfilename = ch;
ch += sprintf(ch,"%s%s%s%s%s.%d%s",
ictx->ctx.ldirname,
impprefix,
dctx->cctx->libname,
dctx->cctx->release ? "-" : "",
dctx->cctx->release ? dctx->cctx->release : "",
dctx->cctx->verinfo.major,
dctx->cctx->settings.impsuffix);
ch++;
/* versioned implib file name */
ictx->ctx.vimpfilename = ch;
ch += sprintf(ch,"%s%s%s%s%s.%d.%d.%d%s",
ictx->ctx.ldirname,
impprefix,
dctx->cctx->libname,
dctx->cctx->release ? "-" : "",
dctx->cctx->release ? dctx->cctx->release : "",
dctx->cctx->verinfo.major,
dctx->cctx->verinfo.minor,
dctx->cctx->verinfo.revision,
dctx->cctx->settings.impsuffix);
ch++;
/* relfilename */
if (dctx->cctx->release) {
ictx->ctx.relfilename = ch;
ch += dctx->cctx->verinfo.verinfo
? sprintf(ch,"%s%s%s-%s%s.%d.%d.%d%s",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname,
dctx->cctx->release,
dctx->cctx->settings.osdsuffix,
dctx->cctx->verinfo.major,
dctx->cctx->verinfo.minor,
dctx->cctx->verinfo.revision,
dctx->cctx->settings.osdfussix)
: sprintf(ch,"%s%s%s-%s%s",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname,
dctx->cctx->release,
dsoext);
ch++;
}
/* dsorellnkname */
if (dctx->cctx->release) {
ictx->ctx.dsorellnkname = ch;
ch += sprintf(ch,"%s%s%s-%s%s",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname,
dctx->cctx->release,
dsoext);
ch++;
}
/* dlopensrc, dlopenobj */
if (idctx->dlopenv) {
ictx->ctx.dlopensrc = ch;
ch += sprintf(ch,"%s%s%s.dlopen.c",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname);
ch++;
ictx->ctx.dlopenobj = ch;
ch += sprintf(ch,"%s%s%s.dlopen.o",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname);
ch++;
ictx->ctx.dlpreopen = ch;
ch += sprintf(ch,"%s%s%s.dlpreopen.a",
ictx->ctx.ldirname,
dsoprefix,
dctx->cctx->libname);
ch++;
ictx->ctx.dlunit = ch;
ch += sprintf(ch,"%s%s",
dsoprefix,
dctx->cctx->libname);
ch++;
}
/* linking: exefilename */
} else if (dctx->cctx->mode == SLBT_MODE_LINK) {
ictx->ctx.exefilename = ch;
if ((slash = strrchr(dctx->cctx->output,'/'))) {
strcpy(ch,dctx->cctx->output);
mark = ch + (slash - dctx->cctx->output);
sprintf(++mark,".libs/%s",++slash);
ch += strlen(ch) + 1;
} else
ch += sprintf(ch,".libs/%s",dctx->cctx->output) + 1;
}
/* dlopensrc, dlopenobj: executable program */
if (idctx->dlopenv && !dctx->cctx->libname) {
ictx->ctx.dlopensrc = ch;
ch += sprintf(ch,"%s.dlopen.c",
ictx->ctx.exefilename);
ch++;
ictx->ctx.dlopenobj = ch;
ch += sprintf(ch,"%s.dlopen.o",
ictx->ctx.exefilename);
ch++;
ictx->ctx.dlpreopen = ch;
ch += sprintf(ch,"%s.dlpreopen.a",
ictx->ctx.exefilename);
ch++;
ictx->ctx.dlunit = ch;
ch += sprintf(ch,"%s",
"@PROGRAM@");
ch++;
ictx->ctx.mapfilename = ch;
ch += sprintf(ch,"%s%s",
ictx->ctx.exefilename,
dctx->cctx->settings.mapsuffix);
ch++;
}
/* dlopen, dlpreopen */
if ((dlopenv = idctx->dlopenv), (dlactxv = ictx->dlactxv)) {
if (slbt_ar_get_varchive_ctx(dctx,dlactxv) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
if (slbt_ar_update_syminfo(*dlactxv) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
dlactxv++;
for (; *dlopenv; ) {
dlentry = *dlopenv;
fpreopen = (dlentry->tag == TAG_DLPREOPEN);
arname = ictx->sbuf;
strcpy(arname,dlentry->arg);
slbt_adjust_wrapper_argument(
arname,true,
".expsyms.a");
errinfp = idctx->errinfp;
if (slbt_ar_get_archive_ctx(dctx,arname,dlactxv) < 0) {
if ((*errinfp)->esyscode != ENOENT)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
strcpy(arname,dlentry->arg);
slbt_adjust_wrapper_argument(
arname,true,
dctx->cctx->settings.arsuffix);
if (slbt_ar_get_archive_ctx(dctx,arname,dlactxv) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
idctx->errinfp = errinfp;
for (; *errinfp; )
*errinfp++ = 0;
fpreopen = true;
}
if (fpreopen) {
if (slbt_ar_update_syminfo(*dlactxv) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
dlactxv++;
} else {
slbt_ar_free_archive_ctx(*dlactxv);
*dlactxv = 0;
}
dlopenv++;
}
if (slbt_mkdir(dctx,ictx->ctx.ldirname) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_SYSTEM_ERROR(
dctx,
ictx->ctx.ldirname));
if (slbt_ar_create_dlsyms(
ictx->dlactxv,
ictx->ctx.dlunit,
ictx->ctx.dlopensrc,
0644) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
if (slbt_ar_merge_archives(ictx->dlactxv,&ictx->dlpreopen) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
if (slbt_ar_store_archive(ictx->dlpreopen,ictx->ctx.dlpreopen,0644) < 0)
return slbt_ectx_free_exec_ctx_impl(
ictx,
SLBT_NESTED_ERROR(dctx));
}
/* vector of exported symbols (raw input via -export-symbols) */
if (dctx->cctx->expsyms)
if (slbt_lib_get_symlist_ctx(
dctx,dctx->cctx->expsyms,
&ictx->sctx) < 0)
return SLBT_NESTED_ERROR(dctx);
/* argument strings shadow copy */
memcpy(ictx->shadow,ictx->args,ictx->size);
/* compile mode: argument vector shadow copy */
if (dctx->cctx->mode == SLBT_MODE_COMPILE)
for (src=ictx->ctx.argv, dst=ictx->ctx.xargv; *src; src++, dst++)
*dst = *src;
/* save the full vector's lout, mout */
ictx->lout[0] = ictx->ctx.lout[0];
ictx->lout[1] = ictx->ctx.lout[1];
ictx->mout[0] = ictx->ctx.mout[0];
ictx->mout[1] = ictx->ctx.mout[1];
/* all done */
*ectx = &ictx->ctx;
return 0;
}
static int slbt_ectx_free_exec_ctx_impl(
struct slbt_exec_ctx_impl * ictx,
int status)
{
struct slbt_archive_ctx ** dlactxv;
if (ictx->sctx)
slbt_lib_free_symlist_ctx(ictx->sctx);
if (ictx->fdwrapper >= 0)
close(ictx->fdwrapper);
if (ictx->dlactxv) {
for (dlactxv=ictx->dlactxv; *dlactxv; dlactxv++)
slbt_ar_free_archive_ctx(*dlactxv);
free(ictx->dlactxv);
}
free(ictx->args);
free(ictx->shadow);
free(ictx->vbuffer);
free (ictx);
return status;
}
void slbt_ectx_free_exec_ctx(struct slbt_exec_ctx * ctx)
{
struct slbt_exec_ctx_impl * ictx;
uintptr_t addr;
if (ctx) {
addr = (uintptr_t)ctx - offsetof(struct slbt_exec_ctx_impl,ctx);
ictx = (struct slbt_exec_ctx_impl *)addr;
slbt_ectx_free_exec_ctx_impl(ictx,0);
}
}
void slbt_ectx_reset_arguments(struct slbt_exec_ctx * ectx)
{
struct slbt_exec_ctx_impl * ictx;
uintptr_t addr;
addr = (uintptr_t)ectx - offsetof(struct slbt_exec_ctx_impl,ctx);
ictx = (struct slbt_exec_ctx_impl *)addr;
memcpy(ictx->args,ictx->shadow,ictx->size);
}
void slbt_ectx_reset_argvector(struct slbt_exec_ctx * ectx)
{
struct slbt_exec_ctx_impl * ictx;
uintptr_t addr;
char ** src;
char ** dst;
addr = (uintptr_t)ectx - offsetof(struct slbt_exec_ctx_impl,ctx);
ictx = (struct slbt_exec_ctx_impl *)addr;
for (src=ectx->xargv, dst=ectx->argv; *src; src++, dst++)
*dst = *src;
*dst = 0;
ectx->lout[0] = ictx->lout[0];
ectx->lout[1] = ictx->lout[1];
ectx->mout[0] = ictx->mout[0];
ectx->mout[1] = ictx->mout[1];
}
slbt_hidden void slbt_reset_placeholders(struct slbt_exec_ctx * ectx)
{
struct slbt_exec_ctx_impl * ictx;
ictx = slbt_get_exec_ictx(ectx);
if (ictx->lout[0]) {
ectx->lout[0] = ictx->lout[0];
ectx->lout[1] = ictx->lout[1];
}
*ectx->dpic = "-USLIBTOOL_PLACEHOLDER_DPIC";
*ectx->fpic = "-USLIBTOOL_PLACEHOLDER_FPIC";
*ectx->cass = "-USLIBTOOL_PLACEHOLDER_COMPILE_ASSEMBLE";
*ectx->noundef = "-USLIBTOOL_PLACEHOLDER_NO_UNDEFINED";
*ectx->soname = "-USLIBTOOL_PLACEHOLDER_SONAME";
*ectx->lsoname = "-USLIBTOOL_PLACEHOLDER_LSONAME";
*ectx->symdefs = "-USLIBTOOL_PLACEHOLDER_SYMDEF_SWITCH";
*ectx->symfile = "-USLIBTOOL_PLACEHOLDER_SYMDEF_FILE";
*ectx->explarg = "-USLIBTOOL_PLACEHOLDER_EXPSYMS_SWITCH";
*ectx->expsyms = "-USLIBTOOL_PLACEHOLDER_EXPSYMS_FILE";
*ectx->lout[0] = "-USLIBTOOL_PLACEHOLDER_OUTPUT_SWITCH";
*ectx->lout[1] = "-USLIBTOOL_PLACEHOLDER_OUTPUT_FILE";
*ectx->rpath[0] = "-USLIBTOOL_PLACEHOLDER_RPATH_SWITCH";
*ectx->rpath[1] = "-USLIBTOOL_PLACEHOLDER_RPATH_DIR";
ectx->mout[0] = 0;
ectx->mout[1] = 0;
*ectx->sentinel= 0;
}
slbt_hidden void slbt_disable_placeholders(struct slbt_exec_ctx * ectx)
{
*ectx->dpic = 0;
*ectx->fpic = 0;
*ectx->cass = 0;
*ectx->noundef = 0;
*ectx->soname = 0;
*ectx->lsoname = 0;
*ectx->symdefs = 0;
*ectx->symfile = 0;
*ectx->explarg = 0;
*ectx->expsyms = 0;
*ectx->lout[0] = 0;
*ectx->lout[1] = 0;
*ectx->rpath[0] = 0;
*ectx->rpath[1] = 0;
*ectx->sentinel= 0;
}