orbea / cross / slibtool

Forked from cross/slibtool 3 years ago
Clone

Blame src/logic/slbt_exec_link.c

2bd749
/*******************************************************************/
2bd749
/*  slibtool: a skinny libtool implementation, written in C        */
2bd749
/*  Copyright (C) 2016  Z. Gilboa                                  */
2bd749
/*  Released under the Standard MIT License; see COPYING.SLIBTOOL. */
2bd749
/*******************************************************************/
2bd749
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"
6529aa
#include "slibtool_symlink_impl.h"
2bd749
5cc3b3
/*******************************************************************/
5cc3b3
/*                                                                 */
5cc3b3
/* -o <ltlib>  switches              input   result                */
5cc3b3
/* ----------  --------------------- -----   ------                */
b07789
/* libfoo.a    [-shared|-static]     bar.lo  libfoo.a              */
5cc3b3
/*                                                                 */
6d048d
/* ar cru libfoo.a bar.o                                           */
5cc3b3
/* ranlib libfoo.a                                                 */
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
/*                                                                 */
a0c318
/* ar cru .libs/libfoo.a .libs/bar.o                               */
a0c318
/* ranlib .libs/libfoo.a                                           */
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
/*                                                                 */
f730ac
/* ar cru .libs/libfoo.a bar.o                                     */
f730ac
/* ranlib .libs/libfoo.a                                           */
f730ac
/* (generate libfoo.la)                                            */
f730ac
/* ln -s ../libfoo.la .libs/libfoo.la                              */
a0c318
/*                                                                 */
a0c318
/*******************************************************************/
a0c318
5cc3b3
static bool slbt_adjust_input_argument(char * arg, bool fpic)
5cc3b3
{
53aa85
	char *	slash;
5cc3b3
	char *	dot;
53aa85
	char	base[PATH_MAX];
5cc3b3
5cc3b3
	if (*arg == '-')
5cc3b3
		return false;
5cc3b3
5cc3b3
	if (!(dot = strrchr(arg,'.')))
5cc3b3
		return false;
5cc3b3
5cc3b3
	if (strcmp(dot,".lo"))
5cc3b3
		return false;
5cc3b3
5cc3b3
	if (fpic) {
53aa85
		if ((slash = strrchr(arg,'/')))
53aa85
			slash++;
53aa85
		else
53aa85
			slash = arg;
53aa85
53aa85
		if ((size_t)snprintf(base,sizeof(base),"%s",
53aa85
				slash) >= sizeof(base))
53aa85
			return false;
53aa85
53aa85
		sprintf(slash,".libs/%s",base);
53aa85
		dot = strrchr(arg,'.');
5cc3b3
	}
53aa85
53aa85
	dot[1] = 'o';
53aa85
	dot[2] = '\0';
53aa85
	return true;
5cc3b3
}
5cc3b3
b3940a
static bool slbt_adjust_linker_argument(
b3940a
	char *		arg,
b3940a
	bool		fpic,
b3940a
	const char *	dsosuffix,
b3940a
	const char *	arsuffix)
b3940a
{
b3940a
	int	fdlib;
b3940a
	char *	slash;
b3940a
	char *	dot;
b3940a
	char	base[PATH_MAX];
b3940a
b3940a
	if (*arg == '-')
b3940a
		return false;
b3940a
b3940a
	if (!(dot = strrchr(arg,'.')))
b3940a
		return false;
b3940a
b3940a
	if (strcmp(dot,".la"))
b3940a
		return false;
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))
b3940a
			return false;
b3940a
b3940a
		sprintf(slash,".libs/%s",base);
b3940a
		dot = strrchr(arg,'.');
b3940a
	}
b3940a
b3940a
	/* shared library dependency? */
b3940a
	if (fpic) {
b3940a
		sprintf(dot,"%s",dsosuffix);
b3940a
b3940a
		if ((fdlib = open(arg,O_RDONLY)) >= 0)
b3940a
			close(fdlib);
b3940a
		else
b3940a
			sprintf(dot,"%s",arsuffix);
b3940a
b3940a
		return true;
b3940a
	}
b3940a
b3940a
	/* input archive */
b3940a
	sprintf(dot,"%s",arsuffix);
b3940a
	return true;
b3940a
}
b3940a
2ef5be
static int slbt_exec_link_adjust_argument_vector(
2ef5be
	const struct slbt_driver_ctx *	dctx,
2ef5be
	struct slbt_exec_ctx *		ectx,
79c501
	const char *			cwd,
2ef5be
	bool				flibrary)
2ef5be
{
2ef5be
	char ** carg;
2ef5be
	char ** aarg;
2ef5be
	char *	slash;
2ef5be
	char *	mark;
2ef5be
	char *	dot;
2ef5be
	char	arg[PATH_MAX];
2ef5be
	bool	fwholearchive = false;
2ef5be
2ef5be
	carg = ectx->cargv;
2ef5be
	aarg = ectx->altv;
2ef5be
2ef5be
	for (; *carg; ) {
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
2ef5be
		if (**carg == '-') {
2ef5be
			*aarg++ = *carg++;
2ef5be
2ef5be
		} else if (!(dot = strrchr(*carg,'.'))) {
2ef5be
			*aarg++ = *carg++;
2ef5be
2ef5be
		} else if (!(strcmp(dot,".a"))) {
2ef5be
			if (flibrary && !fwholearchive)
2ef5be
				*aarg++ = "-Wl,--whole-archive";
2ef5be
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
2ef5be
		} else {
2ef5be
			/* account for {'-','L','-','l'} */
2ef5be
			if ((size_t)snprintf(arg,sizeof(arg),"%s",
2ef5be
					*carg) >= (sizeof(arg) - 4))
2ef5be
				return -1;
2ef5be
2ef5be
			if ((slash = strrchr(arg,'/'))) {
2ef5be
				sprintf(*carg,"-L%s",arg);
2ef5be
2ef5be
				mark   = strrchr(*carg,'/');
2ef5be
				*mark  = '\0';
2ef5be
5ee0d1
				if (ectx->fwrapper) {
5ee0d1
					*slash = '\0';
5ee0d1
5ee0d1
					if (fprintf(ectx->fwrapper,
79c501
							"DL_PATH=\"$DL_PATH$COLON%s/%s\"\n"
5ee0d1
							"COLON=':'\n\n",
79c501
							cwd,arg) < 0)
5ee0d1
						return -1;
5ee0d1
				}
5ee0d1
2ef5be
				*aarg++ = *carg++;
2ef5be
				*aarg++ = ++mark;
2ef5be
2ef5be
				++slash;
2ef5be
				slash += strlen(dctx->cctx->settings.dsoprefix);
2ef5be
2ef5be
				sprintf(mark,"-l%s",slash);
2ef5be
				dot  = strrchr(mark,'.');
2ef5be
				*dot = '\0';
2ef5be
			} else {
2ef5be
				*aarg++ = *carg++;
2ef5be
			}
2ef5be
		}
2ef5be
	}
2ef5be
2ef5be
	return 0;
2ef5be
}
2ef5be
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
{
628cde
	/* remove target (if any) */
628cde
	if (!(unlink(target)) || (errno == ENOENT))
628cde
		return 0;
628cde
628cde
	if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
628cde
		strerror(errno);
628cde
628cde
	return -1;
628cde
}
628cde
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,
3b5e3d
	bool				fpic)
5cc3b3
{
5cc3b3
	char ** 	aarg;
5cc3b3
	char ** 	parg;
5cc3b3
	char *		ranlib[3];
3c594d
	char		program[PATH_MAX];
3c594d
	char		output [PATH_MAX];
5cc3b3
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))
a51ace
		return -1;
a51ace
5cc3b3
	/* ar alternate argument vector */
5cc3b3
	if ((size_t)snprintf(program,sizeof(program),"%s",
5cc3b3
			dctx->cctx->host.ar) >= sizeof(program))
5cc3b3
		return -1;
5cc3b3
5cc3b3
	aarg    = ectx->altv;
5cc3b3
	*aarg++ = program;
5cc3b3
	*aarg++ = "cru";
a51ace
	*aarg++ = output;
5cc3b3
5cc3b3
	/* input argument adjustment */
5cc3b3
	for (parg=ectx->cargv; *parg; parg++)
3b5e3d
		if (slbt_adjust_input_argument(*parg,fpic))
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))
5cc3b3
			return -1;
5cc3b3
628cde
	/* remove old archive as needed */
628cde
	if (slbt_exec_link_remove_file(dctx,ectx,output))
628cde
		return -1;
628cde
5cc3b3
	/* ar spawn */
5cc3b3
	if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
5cc3b3
		return -1;
5cc3b3
5cc3b3
	/* ranlib argv */
5cc3b3
	if ((size_t)snprintf(program,sizeof(program),"%s",
5cc3b3
			dctx->cctx->host.ranlib) >= sizeof(program))
5cc3b3
		return -1;
5cc3b3
5cc3b3
	ranlib[0] = program;
a51ace
	ranlib[1] = output;
5cc3b3
	ranlib[2] = 0;
5cc3b3
	ectx->argv = ranlib;
5cc3b3
5cc3b3
	/* step output */
5cc3b3
	if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
5cc3b3
		if (slbt_output_link(dctx,ectx))
5cc3b3
			return -1;
5cc3b3
5cc3b3
	/* ranlib spawn */
5cc3b3
	if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
5cc3b3
		return -1;
5cc3b3
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,
b3940a
	const char *			dsofilename)
b3940a
{
b3940a
	char ** parg;
79c501
	char	cwd    [PATH_MAX];
b3940a
	char	output [PATH_MAX];
0f8591
	char	soname [PATH_MAX];
b3940a
b3940a
	/* initial state */
b3940a
	slbt_reset_arguments(ectx);
b3940a
b3940a
	/* placeholders */
b3940a
	slbt_reset_placeholders(ectx);
b3940a
b3940a
	/* input argument adjustment */
b3940a
	for (parg=ectx->cargv; *parg; parg++)
b3940a
		slbt_adjust_input_argument(*parg,true);
b3940a
b3940a
	/* linker argument adjustment */
b3940a
	for (parg=ectx->cargv; *parg; parg++)
b3940a
		slbt_adjust_linker_argument(
b3940a
			*parg,true,
b3940a
			dctx->cctx->settings.dsosuffix,
b3940a
			dctx->cctx->settings.arsuffix);
b3940a
b3940a
	/* --no-undefined */
b3940a
	if (dctx->cctx->drvflags & SLBT_DRIVER_NO_UNDEFINED)
b3940a
		*ectx->noundef = "-Wl,--no-undefined";
b3940a
0f8591
	/* -soname */
0f8591
	if ((size_t)snprintf(soname,sizeof(soname),"-Wl,%s%s%s.%d",
0f8591
				dctx->cctx->settings.dsoprefix,
0f8591
				dctx->cctx->libname,
0f8591
				dctx->cctx->settings.dsosuffix,
0f8591
				dctx->cctx->verinfo.major)
0f8591
			>= sizeof(soname))
0f8591
		return -1;
0f8591
0f8591
	*ectx->soname  = "-Wl,-soname";
0f8591
	*ectx->lsoname = soname;
0f8591
b3940a
	/* shared object */
b3940a
	*ectx->dpic = "-shared";
b3940a
	*ectx->fpic = "-fPIC";
b3940a
b3940a
	/* output */
b3940a
	if ((size_t)snprintf(output,sizeof(output),"%s.%d.%d.%d",
b3940a
				dsofilename,
b3940a
				dctx->cctx->verinfo.major,
b3940a
				dctx->cctx->verinfo.minor,
b3940a
				dctx->cctx->verinfo.revision)
b3940a
			>= sizeof(output))
b3940a
		return -1;
b3940a
b3940a
	*ectx->lout[0] = "-o";
b3940a
	*ectx->lout[1] = output;
b3940a
79c501
	/* cwd */
79c501
	if (!getcwd(cwd,sizeof(cwd)))
79c501
		return -1;
79c501
2ef5be
	/* .libs/libfoo.so --> -L.libs -lfoo */
2ef5be
	if (slbt_exec_link_adjust_argument_vector(
79c501
			dctx,ectx,cwd,true))
2ef5be
		return -1;
2ef5be
2ef5be
	/* using alternate argument vector */
2ef5be
	ectx->argv    = ectx->altv;
2ef5be
	ectx->program = ectx->altv[0];
2ef5be
b3940a
	/* step output */
b3940a
	if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
b3940a
		if (slbt_output_link(dctx,ectx))
b3940a
			return -1;
b3940a
b3940a
	/* spawn */
b3940a
	if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
b3940a
		return -1;
b3940a
b3940a
	return 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
{
f6ccbe
	char ** parg;
5ee0d1
	char	cwd    [PATH_MAX];
f6ccbe
	char	output [PATH_MAX];
5ee0d1
	char	wrapper[PATH_MAX];
5e5804
	char	wraplnk[PATH_MAX];
f6ccbe
f6ccbe
	/* initial state */
f6ccbe
	slbt_reset_arguments(ectx);
f6ccbe
f6ccbe
	/* placeholders */
f6ccbe
	slbt_reset_placeholders(ectx);
f6ccbe
f6ccbe
	/* input argument adjustment */
f6ccbe
	for (parg=ectx->cargv; *parg; parg++)
f6ccbe
		slbt_adjust_input_argument(*parg,true);
f6ccbe
f6ccbe
	/* linker argument adjustment */
f6ccbe
	for (parg=ectx->cargv; *parg; parg++)
f6ccbe
		slbt_adjust_linker_argument(
f6ccbe
			*parg,true,
f6ccbe
			dctx->cctx->settings.dsosuffix,
f6ccbe
			dctx->cctx->settings.arsuffix);
f6ccbe
f6ccbe
	/* --no-undefined */
f6ccbe
	if (dctx->cctx->drvflags & SLBT_DRIVER_NO_UNDEFINED)
f6ccbe
		*ectx->noundef = "-Wl,--no-undefined";
f6ccbe
5ee0d1
	/* executable wrapper: header */
5ee0d1
	if ((size_t)snprintf(wrapper,sizeof(wrapper),"%s.wrapper.tmp",
5ee0d1
				dctx->cctx->output)
5ee0d1
			>= sizeof(wrapper))
5ee0d1
		return -1;
5ee0d1
5ee0d1
	if (!(ectx->fwrapper = fopen(wrapper,"w")))
5ee0d1
		return -1;
5ee0d1
5ee0d1
	if (fprintf(ectx->fwrapper,
5ee0d1
			"#!/bin/sh\n"
5ee0d1
			"# slibtool (pre-alpha): generated executable wrapper\n\n"
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"
5ee0d1
			"fi\n\n",
5ee0d1
			dctx->cctx->settings.ldpathenv) < 0)
5ee0d1
		return -1;
5ee0d1
f6ccbe
	/* output */
f6ccbe
	if ((size_t)snprintf(output,sizeof(output),"%s",
f6ccbe
				exefilename)
f6ccbe
			>= sizeof(output))
f6ccbe
		return -1;
f6ccbe
f6ccbe
	*ectx->lout[0] = "-o";
f6ccbe
	*ectx->lout[1] = output;
f6ccbe
79c501
	/* cwd */
79c501
	if (!getcwd(cwd,sizeof(cwd)))
79c501
		return -1;
79c501
2ef5be
	/* .libs/libfoo.so --> -L.libs -lfoo */
2ef5be
	if (slbt_exec_link_adjust_argument_vector(
79c501
			dctx,ectx,cwd,false))
2ef5be
		return -1;
2ef5be
2ef5be
	/* using alternate argument vector */
2ef5be
	ectx->argv    = ectx->altv;
2ef5be
	ectx->program = ectx->altv[0];
2ef5be
5ee0d1
	/* executable wrapper: footer */
5ee0d1
	if (fprintf(ectx->fwrapper,
5ee0d1
			"DL_PATH=\"$DL_PATH$LCOLON$%s\"\n\n"
5ee0d1
			"export %s=$DL_PATH\n\n"
5ee0d1
			"exec %s/%s \"$@\"\n",
5ee0d1
			dctx->cctx->settings.ldpathenv,
5ee0d1
			dctx->cctx->settings.ldpathenv,
5ee0d1
			cwd,exefilename) < 0)
5ee0d1
		return -1;
5ee0d1
f6ccbe
	/* step output */
f6ccbe
	if (!(dctx->cctx->drvflags & SLBT_DRIVER_SILENT))
f6ccbe
		if (slbt_output_link(dctx,ectx))
f6ccbe
			return -1;
f6ccbe
f6ccbe
	/* spawn */
f6ccbe
	if ((slbt_spawn(ectx,true) < 0) || ectx->exitcode)
f6ccbe
		return -1;
f6ccbe
5ee0d1
	/* executable wrapper: finalize */
5ee0d1
	fclose(ectx->fwrapper);
5ee0d1
	ectx->fwrapper = 0;
5ee0d1
5e5804
	if ((size_t)snprintf(wraplnk,sizeof(wraplnk),"%s.exe.wrapper",
5e5804
			dctx->cctx->output) >= sizeof(wraplnk))
5e5804
		return -1;
5e5804
5e5804
	if (slbt_create_symlink(
5e5804
			dctx,ectx,
5e5804
			dctx->cctx->output,wraplnk,
5e5804
			false))
5e5804
		return -1;
5e5804
5ee0d1
	if (rename(wrapper,dctx->cctx->output))
5ee0d1
		return -1;
5ee0d1
5ee0d1
	if (chmod(dctx->cctx->output,0755))
5ee0d1
		return -1;
5ee0d1
f6ccbe
	return 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
b3940a
	sprintf(target,"%s.%d.%d.%d",
b3940a
		ectx->dsofilename,
b3940a
		dctx->cctx->verinfo.major,
b3940a
		dctx->cctx->verinfo.minor,
b3940a
		dctx->cctx->verinfo.revision);
b3940a
b3940a
	if (fmajor)
b3940a
		sprintf(lnkname,"%s.%d",
b3940a
			ectx->dsofilename,
b3940a
			dctx->cctx->verinfo.major);
b3940a
b3940a
	else
b3940a
		strcpy(lnkname,ectx->dsofilename);
b3940a
6529aa
	return slbt_create_symlink(
b3940a
		dctx,ectx,
b3940a
		target,lnkname,
b3940a
		false);
b3940a
}
b3940a
2bd749
int slbt_exec_link(
2bd749
	const struct slbt_driver_ctx *	dctx,
2bd749
	struct slbt_exec_ctx *		ectx)
2bd749
{
2bd749
	int			ret;
2bd749
	int			fdlibs;
a51ace
	const char *		output;
2bd749
	char *			dot;
2bd749
	FILE *			fout;
2bd749
	struct slbt_exec_ctx *	actx;
2bd749
2bd749
	/* context */
2bd749
	if (ectx)
2bd749
		actx = 0;
2bd749
	else if ((ret = slbt_get_exec_ctx(dctx,&ectx)))
2bd749
		return ret;
2bd749
	else
2bd749
		actx = ectx;
2bd749
5cc3b3
	/* output suffix */
a51ace
	output = dctx->cctx->output;
a51ace
	dot    = strrchr(output,'.');
5cc3b3
2bd749
	/* .libs directory */
2bd749
	if (dctx->cctx->drvflags & SLBT_DRIVER_SHARED) {
2bd749
		if ((fdlibs = open(ectx->ldirname,O_DIRECTORY)) >= 0)
2bd749
			close(fdlibs);
2bd749
		else if ((errno != ENOENT) || mkdir(ectx->ldirname,0777)) {
2bd749
			slbt_free_exec_ctx(actx);
2bd749
			return -1;
2bd749
		}
2bd749
	}
2bd749
5cc3b3
	/* non-pic libfoo.a */
5cc3b3
	if (dot && !strcmp(dot,".a"))
3b5e3d
		if (slbt_exec_link_create_archive(dctx,ectx,output,false)) {
5cc3b3
			slbt_free_exec_ctx(actx);
5cc3b3
			return -1;
5cc3b3
		}
5cc3b3
a0c318
	/* pic libfoo.a */
a0c318
	if (dot && !strcmp(dot,".la"))
a0c318
		if (slbt_exec_link_create_archive(
a0c318
				dctx,ectx,
a0c318
				ectx->arfilename,
5fff27
				dctx->cctx->drvflags & SLBT_DRIVER_SHARED)) {
a0c318
			slbt_free_exec_ctx(actx);
a0c318
			return -1;
a0c318
		}
a0c318
b3940a
	/* dynamic library */
b3940a
	if (dot && !strcmp(dot,".la") && dctx->cctx->rpath) {
b3940a
		/* linking: libfoo.so.x.y.z */
b3940a
		if (slbt_exec_link_create_library(
b3940a
				dctx,ectx,
b3940a
				ectx->dsofilename)) {
b3940a
			slbt_free_exec_ctx(actx);
b3940a
			return -1;
b3940a
		}
b3940a
b3940a
		/* symlink: libfoo.so.x --> libfoo.so.x.y.z */
b3940a
		if (slbt_exec_link_create_library_symlink(
b3940a
				dctx,ectx,
b3940a
				true)) {
b3940a
			slbt_free_exec_ctx(actx);
b3940a
			return -1;
b3940a
		}
b3940a
b3940a
		/* symlink: libfoo.so --> libfoo.so.x.y.z */
b3940a
		if (slbt_exec_link_create_library_symlink(
b3940a
				dctx,ectx,
b3940a
				false)) {
b3940a
			slbt_free_exec_ctx(actx);
b3940a
			return -1;
b3940a
		}
b3940a
	}
b3940a
f6ccbe
	/* executable */
f6ccbe
	if (!dctx->cctx->rpath && !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);
f6ccbe
			return -1;
f6ccbe
		}
f6ccbe
	}
f6ccbe
2bd749
	/* no wrapper? */
5cc3b3
	if (!dot || strcmp(dot,".la")) {
2bd749
		slbt_free_exec_ctx(actx);
2bd749
		return 0;
2bd749
	}
2bd749
2bd749
	/* hey, yo, let's rap it up */
687567
	if (!(fout = fopen(output,"w"))) {
2bd749
		slbt_free_exec_ctx(actx);
2bd749
		return -1;
2bd749
	}
2bd749
4c76f7
	/* wrapper symlink */
6529aa
	if (slbt_create_symlink(
4c76f7
			dctx,ectx,
4c76f7
			output,
d1091b
			ectx->lafilename,
14ef98
			true))
14ef98
		ret = -1;
14ef98
	else
14ef98
		ret = fprintf(fout,
14ef98
			"# slibtool (pre-alpha) generated file\n\n");
4c76f7
2bd749
	/* all done */
2bd749
	fclose(fout);
2bd749
	slbt_free_exec_ctx(actx);
2bd749
2bd749
	return (ret > 0) ? 0 : -1;
2bd749
}