void
SoUnknownEngine::copyContents(const SoFieldContainer *fromFC,
SbBool copyConnections)
//
////////////////////////////////////////////////////////////////////////
{
// Make sure the copy has the correct class name
const SoUnknownEngine *fromUnk = (const SoUnknownEngine *) fromFC;
setClassName(fromUnk->className);
// For each input in the original engine, create a new input and add
// it to the new engine
// NOTE: We can't use SoEngine::copyContents() to copy the field
// data, since that uses SoFieldData::overlay(), which assumes the
// fields have the same offsets in both engines. Instead, we just
// copy the field values ourselves.
const SoFieldData *fromData = fromUnk->getFieldData();
SoFieldData *toData = (SoFieldData *) getFieldData();
int i;
for (i = 0; i < fromData->getNumFields(); i++) {
SoField *fromField = fromData->getField(fromUnk, i);
const SbName fieldName = fromData->getFieldName(i);
SoType fieldType = fromField->getTypeId();
SoField *toField = (SoField *) (fieldType.createInstance());
toField->enableNotify(FALSE);
toField->setContainer(this);
toField->setDefault(TRUE);
toField->enableNotify(TRUE);
toData->addField(this, fieldName.getString(), toField);
toField->setContainer(this);
toField->copyFrom(*fromField);
toField->setIgnored(fromField->isIgnored());
toField->setDefault(fromField->isDefault());
toField->fixCopy(copyConnections);
if (fromField->isConnected() && copyConnections)
toField->copyConnection(fromField);
}
// Copy the outputs
SoEngineOutputData *toOutData = (SoEngineOutputData *) getOutputData();
SoEngineOutputList outList;
fromUnk->getOutputs(outList);
for(i = 0; i < outList.getLength(); i++) {
SoEngineOutput *newOut = new SoEngineOutput;
const SoType outType = outList[i]->getConnectionType();
SbName outName;
getOutputName( outList[i], outName );
toOutData->addOutput(this, outName.getString(), newOut, outType);
newOut->setContainer(this);
}
}
int linkObjToBinary() {
Logger::println("*** Linking executable ***");
// remember output path for later
gExePath = getOutputName();
createDirectoryForFileOrFail(gExePath);
if (global.params.targetTriple->isWindowsMSVCEnvironment()) {
return linkObjToBinaryMSVC(gExePath, useInternalLinker, opts::staticFlag);
}
return linkObjToBinaryGcc(gExePath, useInternalLinker, opts::staticFlag);
}
void ofApp::keyReleased(int key) {
switch (key) {
case 'f':
if (inputFrames->isPlaying()) {
inputFrames->stop();
outputFrames->stop();
}
else {
inputFrames->play();
outputFrames->play();
}
break;
case 'h':
inputFrames->prevFrame();
outputFrames->prevFrame();
currFrameChanged();
break;
case 'l':
inputFrames->nextFrame();
outputFrames->nextFrame();
currFrameChanged();
break;
case 'p':
screenshot();
break;
case '1':
step(1);
break;
case '2':
step(2);
break;
case '3':
step(3);
break;
case '4':
step(5);
break;
case '5':
step(10);
break;
case '6':
step(20);
break;
case 's':
string outputName = getOutputName();
outputFrames->saveFrames(outputName);
break;
}
}
const bool
V3NtkHandler::resetOutName(const uint32_t& index, const string& name) {
// There is an unimplemented optimization: stores the mapping only if name != getNetName(PO[index])
assert (index < _ntk->getOutputSize());
if (name == getOutputName(index)) return true;
if (name.size() && _outNameHash.end() != _outNameHash.find(name)) {
Msg(MSG_ERR) << "Output Name \"" << name << "\" Already Exists !!" << endl;
return false;
}
V3IdxStrHash::iterator it = _outIndexHash.find(index);
if (_outIndexHash.end() != it) {
if (it->second.size()) _outNameHash.erase(_outNameHash.find(it->second));
_outIndexHash[index] = name;
}
else if (name.size()) _outIndexHash.insert(make_pair(index, name));
if (name.size()) _outNameHash.insert(make_pair(name, index)); return true;
}
void
V3NtkHandler::printPrimary() const {
assert (_ntk); Msg(MSG_IFO) << "Primary Inputs = ";
for (uint32_t i = 0; i < _ntk->getInputSize(); ++i) {
if (i && !(i % 5)) Msg(MSG_IFO) << endl << string(strlen("Primary Inputs = "), ' ');
else if (i) Msg(MSG_IFO) << ", "; Msg(MSG_IFO) << getInputName(i);
if (_ntk->getNetWidth(_ntk->getInput(i)) > 1) Msg(MSG_IFO) << "(" << _ntk->getNetWidth(_ntk->getInput(i)) << ")";
}
Msg(MSG_IFO) << endl;
Msg(MSG_IFO) << "Primary Outputs = ";
for (uint32_t i = 0; i < _ntk->getOutputSize(); ++i) {
if (i && !(i % 5)) Msg(MSG_IFO) << endl << string(strlen("Primary Outputs = "), ' ');
else if (i) Msg(MSG_IFO) << ", "; Msg(MSG_IFO) << getOutputName(i);
if (_ntk->getNetWidth(_ntk->getOutput(i)) > 1) Msg(MSG_IFO) << "(" << _ntk->getNetWidth(_ntk->getOutput(i)) << ")";
}
Msg(MSG_IFO) << endl;
Msg(MSG_IFO) << "Primary Inouts = ";
for (uint32_t i = 0; i < _ntk->getInoutSize(); ++i) {
if (i && !(i % 5)) Msg(MSG_IFO) << endl << string(strlen("Primary Inouts = "), ' ');
else if (i) Msg(MSG_IFO) << ", "; Msg(MSG_IFO) << getInoutName(i);
if (_ntk->getNetWidth(_ntk->getInout(i)) > 1) Msg(MSG_IFO) << "(" << _ntk->getNetWidth(_ntk->getInout(i)) << ")";
}
Msg(MSG_IFO) << endl;
}
int getOptModelOutputName(emb_optimizer optim, int name_idx, char y_name[], size_t maxlen, size_t *reqlen)
{
return getOutputName(myModel, name_idx, y_name, maxlen, reqlen);
}
static int linkObjToBinaryWin(bool sharedLib)
{
Logger::println("*** Linking executable ***");
// find link.exe for linking
std::string tool(getLink());
// build arguments
std::vector<std::string> args;
args.push_back("/NOLOGO");
// specify that the image will contain a table of safe exception handlers (32bit only)
if (!global.params.is64bit)
args.push_back("/SAFESEH");
// mark executable to be compatible with Windows Data Execution Prevention feature
args.push_back("/NXCOMPAT");
// use address space layout randomization (ASLR) feature
args.push_back("/DYNAMICBASE");
// because of a LLVM bug
// most of the bug is fixed in LLVM 3.4
#if LDC_LLVM_VER < 304
if (global.params.symdebug)
args.push_back("/LARGEADDRESSAWARE:NO");
else
#endif
args.push_back("/LARGEADDRESSAWARE");
// output debug information
if (global.params.symdebug)
{
args.push_back("/DEBUG");
}
// remove dead code and fold identical COMDATs
if (opts::disableLinkerStripDead)
args.push_back("/OPT:NOREF");
else
{
args.push_back("/OPT:REF");
args.push_back("/OPT:ICF");
}
// specify creation of DLL
if (sharedLib)
args.push_back("/DLL");
// output filename
std::string output = getOutputName(sharedLib);
args.push_back("/OUT:" + output);
// object files
for (unsigned i = 0; i < global.params.objfiles->dim; i++)
{
const char *p = static_cast<const char *>(global.params.objfiles->data[i]);
args.push_back(p);
}
// user libs
for (unsigned i = 0; i < global.params.libfiles->dim; i++)
{
const char *p = static_cast<const char *>(global.params.libfiles->data[i]);
args.push_back(p);
}
// set the global gExePath
gExePath = output;
//assert(gExePath.isValid());
// create path to exe
CreateDirectoryOnDisk(gExePath);
// additional linker switches
for (unsigned i = 0; i < global.params.linkswitches->dim; i++)
{
std::string str(static_cast<const char *>(global.params.linkswitches->data[i]));
if (str.length() > 2)
{
// rewrite common -L and -l switches
if (str[0] == '-' && str[1] == 'L')
str = "/LIBPATH:" + str.substr(2);
else if (str[0] == '-' && str[1] == 'l')
{
str = str.substr(2) + ".lib";
}
}
args.push_back(str);
}
// default libs
// TODO check which libaries are necessary
args.push_back("kernel32.lib");
args.push_back("user32.lib");
args.push_back("gdi32.lib");
args.push_back("winspool.lib");
args.push_back("shell32.lib"); // required for dmain2.d
args.push_back("ole32.lib");
args.push_back("oleaut32.lib");
args.push_back("uuid.lib");
args.push_back("comdlg32.lib");
args.push_back("advapi32.lib");
Logger::println("Linking with: ");
std::vector<std::string>::const_iterator I = args.begin(), E = args.end();
Stream logstr = Logger::cout();
for (; I != E; ++I)
if (!(*I).empty())
logstr << "'" << *I << "'" << " ";
logstr << "\n"; // FIXME where's flush ?
// try to call linker
return executeToolAndWait(tool, args, global.params.verbose);
}
static int linkObjToBinaryGcc(bool sharedLib)
{
Logger::println("*** Linking executable ***");
// find gcc for linking
std::string gcc(getGcc());
// build arguments
std::vector<std::string> args;
// object files
for (unsigned i = 0; i < global.params.objfiles->dim; i++)
{
const char *p = static_cast<const char *>(global.params.objfiles->data[i]);
args.push_back(p);
}
// user libs
for (unsigned i = 0; i < global.params.libfiles->dim; i++)
{
const char *p = static_cast<const char *>(global.params.libfiles->data[i]);
args.push_back(p);
}
// output filename
std::string output = getOutputName(sharedLib);
if (sharedLib)
args.push_back("-shared");
args.push_back("-o");
args.push_back(output);
// set the global gExePath
gExePath = output;
//assert(gExePath.isValid());
// create path to exe
CreateDirectoryOnDisk(gExePath);
#if LDC_LLVM_VER >= 303
// Pass sanitizer arguments to linker. Requires clang.
if (opts::sanitize == opts::AddressSanitizer) {
args.push_back("-fsanitize=address");
}
if (opts::sanitize == opts::MemorySanitizer) {
args.push_back("-fsanitize=memory");
}
if (opts::sanitize == opts::ThreadSanitizer) {
args.push_back("-fsanitize=thread");
}
#endif
// additional linker switches
for (unsigned i = 0; i < global.params.linkswitches->dim; i++)
{
const char *p = static_cast<const char *>(global.params.linkswitches->data[i]);
// Don't push -l and -L switches using -Xlinker, but pass them indirectly
// via GCC. This makes sure user-defined paths take precedence over
// GCC's builtin LIBRARY_PATHs.
if (!p[0] || !(p[0] == '-' && (p[1] == 'l' || p[1] == 'L')))
args.push_back("-Xlinker");
args.push_back(p);
}
// default libs
bool addSoname = false;
switch (global.params.targetTriple.getOS()) {
case llvm::Triple::Linux:
addSoname = true;
args.push_back("-lrt");
if (!opts::disableLinkerStripDead) {
args.push_back("-Wl,--gc-sections");
}
// fallthrough
case llvm::Triple::Darwin:
case llvm::Triple::MacOSX:
args.push_back("-ldl");
// fallthrough
case llvm::Triple::FreeBSD:
addSoname = true;
args.push_back("-lpthread");
args.push_back("-lm");
break;
case llvm::Triple::Solaris:
args.push_back("-lm");
args.push_back("-lumem");
// solaris TODO
break;
#if LDC_LLVM_VER < 305
case llvm::Triple::MinGW32:
// This is really more of a kludge, as linking in the Winsock functions
// should be handled by the pragma(lib, ...) in std.socket, but it
// makes LDC behave as expected for now.
args.push_back("-lws2_32");
break;
#endif
default:
// OS not yet handled, will probably lead to linker errors.
// FIXME: Win32.
break;
}
#if LDC_LLVM_VER >= 305
if (global.params.targetTriple.isWindowsGNUEnvironment())
{
// This is really more of a kludge, as linking in the Winsock functions
// should be handled by the pragma(lib, ...) in std.socket, but it
// makes LDC behave as expected for now.
args.push_back("-lws2_32");
}
#endif
// Only specify -m32/-m64 for architectures where the two variants actually
// exist (as e.g. the GCC ARM toolchain doesn't recognize the switches).
// MIPS does not have -m32/-m64 but requires -mabi=.
if (global.params.targetTriple.get64BitArchVariant().getArch() !=
llvm::Triple::UnknownArch &&
global.params.targetTriple.get32BitArchVariant().getArch() !=
llvm::Triple::UnknownArch) {
if (global.params.targetTriple.get64BitArchVariant().getArch() ==
llvm::Triple::mips64 ||
global.params.targetTriple.get64BitArchVariant().getArch() ==
llvm::Triple::mips64el) {
switch (getMipsABI())
{
case MipsABI::EABI:
args.push_back("-mabi=eabi");
break;
case MipsABI::O32:
args.push_back("-mabi=32");
break;
case MipsABI::N32:
args.push_back("-mabi=n32");
break;
case MipsABI::N64:
args.push_back("-mabi=64");
break;
case MipsABI::Unknown:
break;
}
}
else {
if (global.params.is64bit)
args.push_back("-m64");
else
args.push_back("-m32");
}
}
if (opts::createSharedLib && addSoname) {
std::string soname = opts::soname;
if (!soname.empty()) {
args.push_back("-Wl,-soname," + soname);
}
}
Logger::println("Linking with: ");
std::vector<std::string>::const_iterator I = args.begin(), E = args.end();
Stream logstr = Logger::cout();
for (; I != E; ++I)
if (!(*I).empty())
logstr << "'" << *I << "'" << " ";
logstr << "\n"; // FIXME where's flush ?
// try to call linker
return executeToolAndWait(gcc, args, global.params.verbose);
}
static int linkObjToBinaryMSVC(bool sharedLib) {
Logger::println("*** Linking executable ***");
if (!opts::ccSwitches.empty()) {
error(Loc(), "-Xcc is not supported for MSVC");
fatal();
}
#ifdef _WIN32
windows::setupMsvcEnvironment();
#endif
const std::string tool = "link.exe";
// build arguments
std::vector<std::string> args;
args.push_back("/NOLOGO");
// specify that the image will contain a table of safe exception handlers
// and can handle addresses >2GB (32bit only)
if (!global.params.is64bit) {
args.push_back("/SAFESEH");
args.push_back("/LARGEADDRESSAWARE");
}
// output debug information
if (global.params.symdebug) {
args.push_back("/DEBUG");
}
// remove dead code and fold identical COMDATs
if (opts::disableLinkerStripDead) {
args.push_back("/OPT:NOREF");
} else {
args.push_back("/OPT:REF");
args.push_back("/OPT:ICF");
}
// add C runtime libs
addMscrtLibs(args);
// specify creation of DLL
if (sharedLib) {
args.push_back("/DLL");
}
// output filename
std::string output = getOutputName(sharedLib);
args.push_back("/OUT:" + output);
appendObjectFiles(args);
// Link with profile-rt library when generating an instrumented binary
// profile-rt depends on Phobos (MD5 hashing).
if (global.params.genInstrProf) {
args.push_back("ldc-profile-rt.lib");
// profile-rt depends on ws2_32 for symbol `gethostname`
args.push_back("ws2_32.lib");
}
// user libs
for (unsigned i = 0; i < global.params.libfiles->dim; i++)
args.push_back((*global.params.libfiles)[i]);
// set the global gExePath
gExePath = output;
// assert(gExePath.isValid());
// create path to exe
CreateDirectoryOnDisk(gExePath);
// additional linker switches
auto addSwitch = [&](std::string str) {
if (str.length() > 2) {
// rewrite common -L and -l switches
if (str[0] == '-' && str[1] == 'L') {
str = "/LIBPATH:" + str.substr(2);
} else if (str[0] == '-' && str[1] == 'l') {
str = str.substr(2) + ".lib";
}
}
args.push_back(str);
};
for (const auto& str : opts::linkerSwitches) {
addSwitch(str);
}
for (unsigned i = 0; i < global.params.linkswitches->dim; i++) {
addSwitch(global.params.linkswitches->data[i]);
}
// default libs
// TODO check which libaries are necessary
args.push_back("kernel32.lib");
args.push_back("user32.lib");
args.push_back("gdi32.lib");
args.push_back("winspool.lib");
args.push_back("shell32.lib"); // required for dmain2.d
args.push_back("ole32.lib");
args.push_back("oleaut32.lib");
args.push_back("uuid.lib");
args.push_back("comdlg32.lib");
args.push_back("advapi32.lib");
Logger::println("Linking with: ");
Stream logstr = Logger::cout();
for (const auto &arg : args) {
if (!arg.empty()) {
logstr << "'" << arg << "'"
<< " ";
}
}
logstr << "\n"; // FIXME where's flush ?
// try to call linker
return executeToolAndWait(tool, args, global.params.verbose);
}
static int linkObjToBinaryGcc(bool sharedLib) {
Logger::println("*** Linking executable ***");
// find gcc for linking
const std::string tool = getGcc();
// build arguments
std::vector<std::string> args;
appendObjectFiles(args);
// Link with profile-rt library when generating an instrumented binary.
// profile-rt uses Phobos (MD5 hashing) and therefore must be passed on the
// commandline before Phobos.
if (global.params.genInstrProf) {
#if LDC_LLVM_VER >= 308
if (global.params.targetTriple->isOSLinux()) {
// For Linux, explicitly define __llvm_profile_runtime as undefined
// symbol, so that the initialization part of profile-rt is linked in.
args.push_back(
("-Wl,-u," + llvm::getInstrProfRuntimeHookVarName()).str());
}
#endif
args.push_back("-lldc-profile-rt");
}
// user libs
for (unsigned i = 0; i < global.params.libfiles->dim; i++)
args.push_back((*global.params.libfiles)[i]);
// output filename
std::string output = getOutputName(sharedLib);
if (sharedLib) {
args.push_back("-shared");
}
if (staticFlag) {
args.push_back("-static");
}
args.push_back("-o");
args.push_back(output);
// set the global gExePath
gExePath = output;
// assert(gExePath.isValid());
// create path to exe
CreateDirectoryOnDisk(gExePath);
// Pass sanitizer arguments to linker. Requires clang.
if (opts::sanitize == opts::AddressSanitizer) {
args.push_back("-fsanitize=address");
}
if (opts::sanitize == opts::MemorySanitizer) {
args.push_back("-fsanitize=memory");
}
if (opts::sanitize == opts::ThreadSanitizer) {
args.push_back("-fsanitize=thread");
}
// Add LTO link flags before adding the user link switches, such that the user
// can pass additional options to the LTO plugin.
if (opts::isUsingLTO())
addLTOLinkFlags(args);
// additional linker and cc switches (preserve order across both lists)
for (unsigned ilink = 0, icc = 0;;) {
unsigned linkpos = ilink < opts::linkerSwitches.size()
? opts::linkerSwitches.getPosition(ilink)
: std::numeric_limits<unsigned>::max();
unsigned ccpos = icc < opts::ccSwitches.size()
? opts::ccSwitches.getPosition(icc)
: std::numeric_limits<unsigned>::max();
if (linkpos < ccpos) {
const std::string& p = opts::linkerSwitches[ilink++];
// Don't push -l and -L switches using -Xlinker, but pass them indirectly
// via GCC. This makes sure user-defined paths take precedence over
// GCC's builtin LIBRARY_PATHs.
// Options starting with `-Wl,`, -shared or -static are not handled by
// the linker and must be passed to the driver.
auto str = llvm::StringRef(p);
if (!(str.startswith("-l") || str.startswith("-L") ||
str.startswith("-Wl,") ||
str.startswith("-shared") || str.startswith("-static"))) {
args.push_back("-Xlinker");
}
args.push_back(p);
} else if (ccpos < linkpos) {
args.push_back(opts::ccSwitches[icc++]);
} else {
break;
}
}
// libs added via pragma(lib, libname)
for (unsigned i = 0; i < global.params.linkswitches->dim; i++) {
args.push_back((*global.params.linkswitches)[i]);
}
// default libs
bool addSoname = false;
switch (global.params.targetTriple->getOS()) {
case llvm::Triple::Linux:
addSoname = true;
// Make sure we don't do --gc-sections when generating a profile-
// instrumented binary. The runtime relies on magic sections, which
// would be stripped by gc-section on older version of ld, see bug:
// https://sourceware.org/bugzilla/show_bug.cgi?id=19161
if (!opts::disableLinkerStripDead && !global.params.genInstrProf) {
args.push_back("-Wl,--gc-sections");
}
if (global.params.targetTriple->getEnvironment() == llvm::Triple::Android) {
args.push_back("-ldl");
args.push_back("-lm");
break;
}
args.push_back("-lrt");
// fallthrough
case llvm::Triple::Darwin:
case llvm::Triple::MacOSX:
args.push_back("-ldl");
// fallthrough
case llvm::Triple::FreeBSD:
case llvm::Triple::NetBSD:
case llvm::Triple::OpenBSD:
case llvm::Triple::DragonFly:
addSoname = true;
args.push_back("-lpthread");
args.push_back("-lm");
break;
case llvm::Triple::Solaris:
args.push_back("-lm");
args.push_back("-lumem");
args.push_back("-lsocket");
args.push_back("-lnsl");
break;
default:
// OS not yet handled, will probably lead to linker errors.
// FIXME: Win32.
break;
}
if (global.params.targetTriple->isWindowsGNUEnvironment()) {
// This is really more of a kludge, as linking in the Winsock functions
// should be handled by the pragma(lib, ...) in std.socket, but it
// makes LDC behave as expected for now.
args.push_back("-lws2_32");
}
// Only specify -m32/-m64 for architectures where the two variants actually
// exist (as e.g. the GCC ARM toolchain doesn't recognize the switches).
// MIPS does not have -m32/-m64 but requires -mabi=.
if (global.params.targetTriple->get64BitArchVariant().getArch() !=
llvm::Triple::UnknownArch &&
global.params.targetTriple->get32BitArchVariant().getArch() !=
llvm::Triple::UnknownArch) {
if (global.params.targetTriple->get64BitArchVariant().getArch() ==
llvm::Triple::mips64 ||
global.params.targetTriple->get64BitArchVariant().getArch() ==
llvm::Triple::mips64el) {
switch (getMipsABI()) {
case MipsABI::EABI:
args.push_back("-mabi=eabi");
break;
case MipsABI::O32:
args.push_back("-mabi=32");
break;
case MipsABI::N32:
args.push_back("-mabi=n32");
break;
case MipsABI::N64:
args.push_back("-mabi=64");
break;
case MipsABI::Unknown:
break;
}
} else {
switch (global.params.targetTriple->getArch()) {
case llvm::Triple::arm:
case llvm::Triple::armeb:
case llvm::Triple::aarch64:
case llvm::Triple::aarch64_be:
#if LDC_LLVM_VER == 305
case llvm::Triple::arm64:
case llvm::Triple::arm64_be:
#endif
break;
default:
if (global.params.is64bit) {
args.push_back("-m64");
} else {
args.push_back("-m32");
}
}
}
}
if (global.params.dll && addSoname) {
std::string soname = opts::soname;
if (!soname.empty()) {
args.push_back("-Wl,-soname," + soname);
}
}
Logger::println("Linking with: ");
Stream logstr = Logger::cout();
for (const auto &arg : args) {
if (!arg.empty()) {
logstr << "'" << arg << "'"
<< " ";
}
}
logstr << "\n"; // FIXME where's flush ?
// try to call linker
return executeToolAndWait(tool, args, global.params.verbose);
}
void Sequencer_oss::displayOutputs(std::ostream& out, char* initial) {
for (int i=0; i<getNumOutputs(); i++) {
out << initial << i << ": " << getOutputName(i) << '\n';
}
}
static int linkObjToBinaryWin(bool sharedLib) {
Logger::println("*** Linking executable ***");
std::string tool = "link.exe";
// build arguments
std::vector<std::string> args;
args.push_back("/NOLOGO");
// specify that the image will contain a table of safe exception handlers
// (32bit only)
if (!global.params.is64bit) {
args.push_back("/SAFESEH");
}
// because of a LLVM bug, see LDC issue 442
if (global.params.symdebug) {
args.push_back("/LARGEADDRESSAWARE:NO");
} else {
args.push_back("/LARGEADDRESSAWARE");
}
// output debug information
if (global.params.symdebug) {
args.push_back("/DEBUG");
}
// enable Link-time Code Generation (aka. whole program optimization)
if (global.params.optimize) {
args.push_back("/LTCG");
}
// remove dead code and fold identical COMDATs
if (opts::disableLinkerStripDead) {
args.push_back("/OPT:NOREF");
} else {
args.push_back("/OPT:REF");
args.push_back("/OPT:ICF");
}
// specify creation of DLL
if (sharedLib) {
args.push_back("/DLL");
}
// output filename
std::string output = getOutputName(sharedLib);
args.push_back("/OUT:" + output);
// object files
for (unsigned i = 0; i < global.params.objfiles->dim; i++) {
const char *p = static_cast<const char *>(global.params.objfiles->data[i]);
args.push_back(p);
}
// user libs
for (unsigned i = 0; i < global.params.libfiles->dim; i++) {
const char *p = static_cast<const char *>(global.params.libfiles->data[i]);
args.push_back(p);
}
// set the global gExePath
gExePath = output;
// assert(gExePath.isValid());
// create path to exe
CreateDirectoryOnDisk(gExePath);
// additional linker switches
for (unsigned i = 0; i < global.params.linkswitches->dim; i++) {
std::string str = global.params.linkswitches->data[i];
if (str.length() > 2) {
// rewrite common -L and -l switches
if (str[0] == '-' && str[1] == 'L') {
str = "/LIBPATH:" + str.substr(2);
} else if (str[0] == '-' && str[1] == 'l') {
str = str.substr(2) + ".lib";
}
}
args.push_back(str);
}
// default libs
// TODO check which libaries are necessary
args.push_back("kernel32.lib");
args.push_back("user32.lib");
args.push_back("gdi32.lib");
args.push_back("winspool.lib");
args.push_back("shell32.lib"); // required for dmain2.d
args.push_back("ole32.lib");
args.push_back("oleaut32.lib");
args.push_back("uuid.lib");
args.push_back("comdlg32.lib");
args.push_back("advapi32.lib");
Logger::println("Linking with: ");
Stream logstr = Logger::cout();
for (const auto &arg : args) {
if (!arg.empty()) {
logstr << "'" << arg << "'"
<< " ";
}
}
logstr << "\n"; // FIXME where's flush ?
// try to call linker
return executeMsvcToolAndWait(tool, args, global.params.verbose);
}
