llvm/tools/llvm-ar/llvm-ar.cpp
2003-11-11 22:41:34 +00:00

377 lines
11 KiB
C++

//===-- tools/llvm-ar/llvm-ar.cpp - LLVM archive librarian utility --------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Builds up standard unix archive files (.a) containing LLVM bytecode.
//
//===----------------------------------------------------------------------===//
#include "Support/CommandLine.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Module.h"
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <sys/stat.h>
#include <cstdio>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
using namespace llvm;
using std::string;
using std::vector;
using std::cout;
#define ARFMAG "\n" /* header trailer string */
#define ARMAG "!<arch>\n" /* magic string */
#define SARMAG 8 /* length of magic string */
namespace {
// Each file member is preceded by a file member header. Which is
// of the following format:
//
// char ar_name[16] - '/' terminated file member name.
// If the file name does not fit, a dummy name is used.
// char ar_date[12] - file date in decimal
// char ar_uid[6] - User id of file owner in decimal.
// char ar_gid[6] - Group ID file belongs to in decimal.
// char ar_mode[8] - File mode in octal.
// char ar_size[10] - Size of file in decimal.
// char ar_fmag[2] - Trailer of header file, a newline.
struct ar_hdr {
char name[16];
char date[12];
char uid[6];
char gid[6];
char mode[8];
char size[10];
char fmag[2];
void init() {
memset(name,' ',16);
memset(date,' ',12);
memset(uid,' ',6);
memset(gid,' ',6);
memset(mode,' ',8);
memset(size,' ',10);
memset(fmag,' ',2);
}
};
}
//Option to generate symbol table or not
//running llvm-ar -s is the same as ranlib
cl::opt<bool> SymbolTableOption ("s", cl::desc("Generate an archive symbol table"));
//Archive name
cl::opt<string> Archive (cl::Positional, cl::desc("<archive file>"),
cl::Required);
//For now we require one or more member files, this should change so
//we can just run llvm-ar -s on an archive to generate the symbol
//table
cl::list<string> Members(cl::ConsumeAfter, cl::desc("<archive members>..."));
static inline bool Error(std::string *ErrorStr, const char *Message) {
if (ErrorStr) *ErrorStr = Message;
return true;
}
// WriteSymbolTable - Writes symbol table to ArchiveFile, return false
// on errors. Also returns by reference size of symbol table.
//
// Overview of method:
// 1) Generate the header for the symbol table. This is a normal
// archive member header, but it has a zero length name.
// 2) For each archive member file, stat the file and parse the bytecode
// Store cumulative offset (file size + header size).
// 3) Loop over all the symbols for the current member file,
// add offset entry to offset vector, and add symbol name to its vector.
// Note: The symbol name vector is a vector of chars to speed up calculating
// the total size of the symbol table.
// 4) Update offset vector once we know the total size of symbol table. This is
// because the symbol table appears before all archive member file contents.
// We add the size of magic string, and size of symbol table to each offset.
// 5) If the new updated offset it not even, we add 1 byte to offset because
// a newline will be inserted when writing member files. This adjustment is
// cummulative (ie. each time we have an odd offset we add 1 to total adjustment).
// 6) Lastly, write symbol table to file.
//
bool WriteSymbolTable(std::ofstream &ArchiveFile) {
//Create header for symbol table. This is essentially an empty header with the
//name set to a '/' to indicate its a symbol table.
ar_hdr Hdr;
Hdr.init();
//Name of symbol table is '/'
Hdr.name[0] = '/';
Hdr.name[1] = '\0';
//Set the header trailer to a newline
memcpy(Hdr.fmag,ARFMAG,sizeof(ARFMAG));
//Write header to archive file
ArchiveFile.write((char*)&Hdr, sizeof(Hdr));
unsigned memoff = 0; //Keep Track of total size of files added to archive
vector<unsigned> offsets; //Vector of offsets into archive file
vector<char> names; //Vector of characters that are the symbol names.
//Loop over archive member files, parse bytecode, and generate symbol table.
for(unsigned i=0; i<Members.size(); ++i) {
//Open Member file for reading and copy to buffer
int FD = open(Members[i].c_str(),O_RDONLY);
//Check for errors opening the file.
if (FD == -1) {
std::cerr << "Error opening file!\n";
return false;
}
//Stat the file to get its size.
struct stat StatBuf;
if (stat(Members[i].c_str(), &StatBuf) == -1 || StatBuf.st_size == 0) {
std::cerr << "Error stating file\n";
return false;
}
//Size of file
unsigned Length = StatBuf.st_size;
//Read in file into a buffer.
unsigned char *buf = (unsigned char*)mmap(0, Length,PROT_READ,
MAP_PRIVATE, FD, 0);
//Check if mmap failed.
if (buf == (unsigned char*)MAP_FAILED) {
std::cerr << "Error mmapping file!\n";
return false;
}
//Parse the bytecode file and get all the symbols.
string ErrorStr;
Module *M = ParseBytecodeBuffer(buf,Length,Members[i],&ErrorStr);
//Check for errors parsing bytecode.
//if(ErrorStr) {
//std::cerr << "Error Parsing Bytecode\n";
//return false;
//}
//Loop over function names and global vars and add to symbol maps
for(Module::iterator I = M->begin(), E=M->end(); I != E; ++I) {
//get function name
string NM = ((Function*)I)->getName();
//Loop over the characters in the name and add to symbol name vector
for(unsigned i=0; i<NM.size(); ++i)
names.push_back(NM[i]);
//Each symbol is null terminated.
names.push_back('\0');
//Add offset to vector of offsets
offsets.push_back(memoff);
}
memoff += Length + sizeof(Hdr);
}
//Determine how large our symbol table is.
unsigned symbolTableSize = sizeof(Hdr) + 4 + 4*(offsets.size()) + names.size();
cout << "Symbol Table Size: " << symbolTableSize << "\n";
//Number of symbols should be in network byte order as well
char num[4];
unsigned temp = offsets.size();
num[0] = (temp >> 24) & 255;
num[1] = (temp >> 16) & 255;
num[2] = (temp >> 8) & 255;
num[3] = temp & 255;
//Write number of symbols to archive file
ArchiveFile.write(num,4);
//Adjustment to offset to start files on even byte boundaries
unsigned adjust = 0;
//Update offsets write symbol table to archive.
for(unsigned i=0; i<offsets.size(); ++i) {
char output[4];
offsets[i] = offsets[i] + symbolTableSize + SARMAG;
offsets[i] += adjust;
if((offsets[i] % 2 != 0)) {
adjust++;
offsets[i] += adjust;
}
cout << "Offset: " << offsets[i] << "\n";
output[0] = (offsets[i] >> 24) & 255;
output[1] = (offsets[i] >> 16) & 255;
output[2] = (offsets[i] >> 8) & 255;
output[3] = offsets[i] & 255;
ArchiveFile.write(output,4);
}
//Write out symbol name vector.
for(unsigned i=0; i<names.size(); ++i)
ArchiveFile << names[i];
return true;
}
// AddMemberToArchive - Writes member file to archive. Returns false on errors.
//
// Overview of method:
// 1) Open file, and stat it.
// 2) Fill out header using stat information. If name is longer then 15
// characters, use "dummy" name.
// 3) Write header and file contents to disk.
// 4) Keep track of total offset into file, and insert a newline if it is odd.
//
bool AddMemberToArchive(string Member, std::ofstream &ArchiveFile) {
ar_hdr Hdr; //Header for archive member file.
//stat the file to get info
struct stat StatBuf;
if (stat(Member.c_str(), &StatBuf) == -1 || StatBuf.st_size == 0)
cout << "ERROR\n";
//fill in header
//set name to white spaces
memset(Hdr.name,' ', sizeof(Hdr.name));
//check the size of the name, if less than 15, we can copy it directly
//otherwise we give it a dummy name for now
if(Member.length() < 16)
memcpy(Hdr.name,Member.c_str(),Member.length());
else
memcpy(Hdr.name, "Dummy", 5);
//terminate name with forward slash
Hdr.name[15] = '/';
//file member size in decimal
unsigned Length = StatBuf.st_size;
sprintf(Hdr.size,"%d", Length);
cout << "Size: " << Length << "\n";
//file member user id in decimal
sprintf(Hdr.uid, "%d", StatBuf.st_uid);
//file member group id in decimal
sprintf(Hdr.gid, "%d", StatBuf.st_gid);
//file member date in decimal
sprintf(Hdr.date,"%d", (int)StatBuf.st_mtime);
//file member mode in OCTAL
sprintf(Hdr.mode,"%d", StatBuf.st_mode);
//add our header trailer
memcpy(Hdr.fmag,ARFMAG,sizeof(ARFMAG));
//write header to archive file
ArchiveFile.write((char*)&Hdr, sizeof(Hdr));
//open Member file for reading and copy to buffer
int FD = open(Member.c_str(),O_RDONLY);
if (FD == -1) {
std::cerr << "Error opening file!\n";
return false;
}
unsigned char *buf = (unsigned char*)mmap(0, Length,PROT_READ,
MAP_PRIVATE, FD, 0);
//check if mmap failed
if (buf == (unsigned char*)MAP_FAILED) {
std::cerr << "Error mmapping file!\n";
return false;
}
//write to archive file
ArchiveFile.write((char*)buf,Length);
// Unmmap the memberfile
munmap((char*)buf, Length);
return true;
}
// CreateArchive - Generates archive with or without symbol table.
//
void CreateArchive() {
//Create archive file for output.
std::ofstream ArchiveFile(Archive.c_str());
//Check for errors opening or creating archive file.
if(!ArchiveFile.is_open() || ArchiveFile.bad() ) {
std::cerr << "Error opening Archive File\n";
exit(1);
}
//Write magic string to archive.
ArchiveFile << ARMAG;
//If the '-s' option was specified, generate symbol table.
if(SymbolTableOption) {
cout << "Symbol Table Start: " << ArchiveFile.tellp() << "\n";
if(!WriteSymbolTable(ArchiveFile)) {
std::cerr << "Error creating symbol table. Exiting program.";
exit(1);
}
cout << "Symbol Table End: " << ArchiveFile.tellp() << "\n";
}
//Loop over all member files, and add to the archive.
for(unsigned i=0; i<Members.size(); ++i) {
if(ArchiveFile.tellp() % 2 != 0)
ArchiveFile << ARFMAG;
cout << "Member File Start: " << ArchiveFile.tellp() << "\n";
if(AddMemberToArchive(Members[i],ArchiveFile) != true) {
std::cerr << "Error adding file to archive. Exiting program.";
exit(1);
}
cout << "Member File End: " << ArchiveFile.tellp() << "\n";
}
//Close archive file.
ArchiveFile.close();
}
int main(int argc, char **argv) {
//Parse Command line options
cl::ParseCommandLineOptions(argc, argv, " llvm-ar\n");
//Create archive!
CreateArchive();
return 0;
}