288 lines
7.0 KiB
C++
288 lines
7.0 KiB
C++
//===- util.cpp - Utility functions ---------------------------------------===//
|
|
//
|
|
// This file contains utility functions for gccld. It essentially holds
|
|
// anything from the original gccld.cpp source that was either incidental
|
|
// or not inlined.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Module.h"
|
|
#include "Config/string.h"
|
|
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <set>
|
|
|
|
//
|
|
// Function: PrintAndReturn ()
|
|
//
|
|
// Description:
|
|
// Prints a message (usually error message) to standard error (stderr) and
|
|
// returns a value usable for an exit status.
|
|
//
|
|
// Inputs:
|
|
// progname - The name of the program (i.e. argv[0]).
|
|
// Message - The message to print to standard error.
|
|
// Extra - Extra information to print between the program name and thei
|
|
// message. It is optional.
|
|
//
|
|
// Outputs:
|
|
// None.
|
|
//
|
|
// Return value:
|
|
// Returns a value that can be used as the exit status (i.e. for exit()).
|
|
//
|
|
int
|
|
PrintAndReturn (const char *progname,
|
|
const std::string &Message,
|
|
const std::string &Extra = "")
|
|
{
|
|
std::cerr << progname << Extra << ": " << Message << "\n";
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// Function: IsArchive ()
|
|
//
|
|
// Description:
|
|
// Determine if the specified file is an ar archive. It determines this by
|
|
// checking the magic string at the beginning of the file.
|
|
//
|
|
// Inputs:
|
|
// filename - A C++ string containing the name of the file.
|
|
//
|
|
// Outputs:
|
|
// None.
|
|
//
|
|
// Return value:
|
|
// TRUE - The file is an archive.
|
|
// FALSE - The file is not an archive.
|
|
//
|
|
bool
|
|
IsArchive (const std::string &filename)
|
|
{
|
|
std::string ArchiveMagic("!<arch>\012");
|
|
char buf[1 + ArchiveMagic.size()];
|
|
|
|
std::ifstream f(filename.c_str());
|
|
f.read(buf, ArchiveMagic.size());
|
|
buf[ArchiveMagic.size()] = '\0';
|
|
return ArchiveMagic == buf;
|
|
}
|
|
|
|
//
|
|
// Function: GetAllDefinedSymbols ()
|
|
//
|
|
// Description:
|
|
// Find all of the defined symbols in the specified module.
|
|
//
|
|
// Inputs:
|
|
// M - The module in which to find defined symbols.
|
|
//
|
|
// Outputs:
|
|
// DefinedSymbols - A set of C++ strings that will contain the name of all
|
|
// defined symbols.
|
|
//
|
|
// Return value:
|
|
// None.
|
|
//
|
|
void
|
|
GetAllDefinedSymbols (Module *M, std::set<std::string> &DefinedSymbols)
|
|
{
|
|
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
|
|
if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
|
|
DefinedSymbols.insert(I->getName());
|
|
for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
|
|
if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
|
|
DefinedSymbols.insert(I->getName());
|
|
}
|
|
|
|
//
|
|
// Function: GetAllUndefinedSymbols ()
|
|
//
|
|
// Description:
|
|
// This calculates the set of undefined symbols that still exist in an LLVM
|
|
// module. This is a bit tricky because there may be two symbols with the
|
|
// same name but different LLVM types that will be resolved to each other but
|
|
// aren't currently (thus we need to treat it as resolved).
|
|
//
|
|
// Inputs:
|
|
// M - The module in which to find undefined symbols.
|
|
//
|
|
// Outputs:
|
|
// UndefinedSymbols - A set of C++ strings containing the name of all
|
|
// undefined symbols.
|
|
//
|
|
// Return value:
|
|
// None.
|
|
//
|
|
void
|
|
GetAllUndefinedSymbols(Module *M, std::set<std::string> &UndefinedSymbols)
|
|
{
|
|
std::set<std::string> DefinedSymbols;
|
|
UndefinedSymbols.clear(); // Start out empty
|
|
|
|
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
|
|
if (I->hasName()) {
|
|
if (I->isExternal())
|
|
UndefinedSymbols.insert(I->getName());
|
|
else if (!I->hasInternalLinkage())
|
|
DefinedSymbols.insert(I->getName());
|
|
}
|
|
for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
|
|
if (I->hasName()) {
|
|
if (I->isExternal())
|
|
UndefinedSymbols.insert(I->getName());
|
|
else if (!I->hasInternalLinkage())
|
|
DefinedSymbols.insert(I->getName());
|
|
}
|
|
|
|
// Prune out any defined symbols from the undefined symbols set...
|
|
for (std::set<std::string>::iterator I = UndefinedSymbols.begin();
|
|
I != UndefinedSymbols.end(); )
|
|
if (DefinedSymbols.count(*I))
|
|
UndefinedSymbols.erase(I++); // This symbol really is defined!
|
|
else
|
|
++I; // Keep this symbol in the undefined symbols list
|
|
}
|
|
|
|
//
|
|
//
|
|
// Function: copy_env()
|
|
//
|
|
// Description:
|
|
// This function takes an array of environment variables and makes a
|
|
// copy of it. This copy can then be manipulated any way the caller likes
|
|
// without affecting the process's real environment.
|
|
//
|
|
// Inputs:
|
|
// envp - An array of C strings containing an environment.
|
|
//
|
|
// Outputs:
|
|
// None.
|
|
//
|
|
// Return value:
|
|
// NULL - An error occurred.
|
|
//
|
|
// Otherwise, a pointer to a new array of C strings is returned. Every string
|
|
// in the array is a duplicate of the one in the original array (i.e. we do
|
|
// not copy the char *'s from one array to another).
|
|
//
|
|
char **
|
|
copy_env (char ** const envp)
|
|
{
|
|
// The new environment list
|
|
char ** newenv;
|
|
|
|
// The number of entries in the old environment list
|
|
int entries;
|
|
|
|
//
|
|
// Count the number of entries in the old list;
|
|
//
|
|
for (entries = 0; envp[entries] != NULL; entries++)
|
|
{
|
|
;
|
|
}
|
|
|
|
//
|
|
// Add one more entry for the NULL pointer that ends the list.
|
|
//
|
|
++entries;
|
|
|
|
//
|
|
// If there are no entries at all, just return NULL.
|
|
//
|
|
if (entries == 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Allocate a new environment list.
|
|
//
|
|
if ((newenv = new (char *) [entries]) == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// Make a copy of the list. Don't forget the NULL that ends the list.
|
|
//
|
|
entries = 0;
|
|
while (envp[entries] != NULL)
|
|
{
|
|
newenv[entries] = new char[strlen (envp[entries]) + 1];
|
|
strcpy (newenv[entries], envp[entries]);
|
|
++entries;
|
|
}
|
|
newenv[entries] = NULL;
|
|
|
|
return newenv;
|
|
}
|
|
|
|
|
|
//
|
|
// Function: remove_env()
|
|
//
|
|
// Description:
|
|
// Remove the specified environment variable from the environment array.
|
|
//
|
|
// Inputs:
|
|
// name - The name of the variable to remove. It cannot be NULL.
|
|
// envp - The array of environment variables. It cannot be NULL.
|
|
//
|
|
// Outputs:
|
|
// envp - The pointer to the specified variable name is removed.
|
|
//
|
|
// Return value:
|
|
// None.
|
|
//
|
|
// Notes:
|
|
// This is mainly done because functions to remove items from the environment
|
|
// are not available across all platforms. In particular, Solaris does not
|
|
// seem to have an unsetenv() function or a setenv() function (or they are
|
|
// undocumented if they do exist).
|
|
//
|
|
void
|
|
remove_env (const char * name, char ** const envp)
|
|
{
|
|
// Pointer for scanning arrays
|
|
register char * p;
|
|
|
|
// Index for selecting elements of the environment array
|
|
register int index;
|
|
|
|
for (index=0; envp[index] != NULL; index++)
|
|
{
|
|
//
|
|
// Find the first equals sign in the array and make it an EOS character.
|
|
//
|
|
p = strchr (envp[index], '=');
|
|
if (p == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
*p = '\0';
|
|
}
|
|
|
|
//
|
|
// Compare the two strings. If they are equal, zap this string.
|
|
// Otherwise, restore it.
|
|
//
|
|
if (!strcmp (name, envp[index]))
|
|
{
|
|
*envp[index] = '\0';
|
|
}
|
|
else
|
|
{
|
|
*p = '=';
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|