replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use binary mode for reading/writing bytecode files 

llvm-svn: 19751
This commit is contained in:
Jeff Cohen 2005-01-22 17:36:17 +00:00
parent e90b0c5469
commit c8f1f4bc8e
12 changed files with 77 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
llvm/lib/Bytecode/Archive/ArchiveWriter.cpp
View File

@ -375,7 +375,9 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress){
// Ensure we can remove the temporary even in the face of an exception
try {
// Create archive file for output.
std::ofstream ArchiveFile(TmpArchive.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
std::ofstream ArchiveFile(TmpArchive.c_str(), io_mode);
// Check for errors opening or creating archive file.
if ( !ArchiveFile.is_open() || ArchiveFile.bad() ) {
@ -413,7 +415,7 @@ Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress){
const char* base = (const char*) arch.map();
// Open the final file to write and check it.
std::ofstream FinalFile(archPath.c_str());
std::ofstream FinalFile(archPath.c_str(), io_mode);
if ( !FinalFile.is_open() || FinalFile.bad() ) {
throw std::string("Error opening archive file: ") + archPath.toString();
}

5
llvm/lib/Support/FileUtilities.cpp
View File

@ -27,13 +27,14 @@ using namespace llvm;
///
bool llvm::DiffFiles(const std::string &FileA, const std::string &FileB,
std::string *Error) {
std::ifstream FileAStream(FileA.c_str());
std::ios::openmode io_mode = std::ios::in | std::ios::binary;
std::ifstream FileAStream(FileA.c_str(), io_mode);
if (!FileAStream) {
if (Error) *Error = "Couldn't open file '" + FileA + "'";
return true;
}
std::ifstream FileBStream(FileB.c_str());
std::ifstream FileBStream(FileB.c_str(), io_mode);
if (!FileBStream) {
if (Error) *Error = "Couldn't open file '" + FileB + "'";
return true;

8
llvm/lib/VMCore/Verifier.cpp
View File

@ -78,17 +78,17 @@ namespace { // Anonymous namespace for class
Verifier()
: Broken(false), RealPass(true), action(AbortProcessAction),
DS(0), msgs( std::ios_base::app | std::ios_base::out ) {}
DS(0), msgs( std::ios::app | std::ios::out ) {}
Verifier( VerifierFailureAction ctn )
: Broken(false), RealPass(true), action(ctn), DS(0),
msgs( std::ios_base::app | std::ios_base::out ) {}
msgs( std::ios::app | std::ios::out ) {}
Verifier(bool AB )
: Broken(false), RealPass(true),
action( AB ? AbortProcessAction : PrintMessageAction), DS(0),
msgs( std::ios_base::app | std::ios_base::out ) {}
msgs( std::ios::app | std::ios::out ) {}
Verifier(DominatorSet &ds)
: Broken(false), RealPass(false), action(PrintMessageAction),
DS(&ds), msgs( std::ios_base::app | std::ios_base::out ) {}
DS(&ds), msgs( std::ios::app | std::ios::out ) {}
bool doInitialization(Module &M) {

24
llvm/tools/bugpoint/OptimizerDriver.cpp
View File

@ -15,6 +15,12 @@
//
//===----------------------------------------------------------------------===//
// Note: as a short term hack, the old Unix-specific code and platform-
// independent code co-exist via conditional compilation until it is verified
// that the new code works correctly on Unix.
#define PLATFORMINDEPENDENT
#include "BugDriver.h"
#include "llvm/Module.h"
#include "llvm/PassManager.h"
@ -24,9 +30,11 @@
#include "llvm/Support/FileUtilities.h"
#include "llvm/System/Path.h"
#include <fstream>
#ifndef PLATFORMINDEPENDENT
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#endif
using namespace llvm;
/// writeProgramToFile - This writes the current "Program" to the named bytecode
@ -34,7 +42,9 @@ using namespace llvm;
///
bool BugDriver::writeProgramToFile(const std::string &Filename,
Module *M) const {
std::ofstream Out(Filename.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
std::ofstream Out(Filename.c_str(), io_mode);
if (!Out.good()) return true;
WriteBytecodeToFile(M ? M : Program, Out, /*compression=*/true);
return false;
@ -76,7 +86,9 @@ void BugDriver::EmitProgressBytecode(const std::string &ID, bool NoFlyer) {
static void RunChild(Module *Program,const std::vector<const PassInfo*> &Passes,
const std::string &OutFilename) {
std::ofstream OutFile(OutFilename.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
std::ofstream OutFile(OutFilename.c_str(), io_mode);
if (!OutFile.good()) {
std::cerr << "Error opening bytecode file: " << OutFilename << "\n";
exit(1);
@ -119,6 +131,7 @@ bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
uniqueFilename.makeUnique();
OutputFilename = uniqueFilename.toString();
#ifndef PLATFORMINDEPENDENT
pid_t child_pid;
switch (child_pid = fork()) {
case -1: // Error occurred
@ -139,12 +152,16 @@ bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
}
bool ExitedOK = WIFEXITED(Status) && WEXITSTATUS(Status) == 0;
#else
bool ExitedOK = false;
#endif
// If we are supposed to delete the bytecode file or if the passes crashed,
// remove it now. This may fail if the file was never created, but that's ok.
if (DeleteOutput || !ExitedOK)
sys::Path(OutputFilename).destroyFile();
#ifndef PLATFORMINDEPENDENT
if (!Quiet) {
if (ExitedOK)
std::cout << "Success!\n";
@ -159,6 +176,7 @@ bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
else
std::cout << "Failed for unknown reason!\n";
}
#endif
// Was the child successful?
return !ExitedOK;

10
llvm/tools/extract/extract.cpp
View File

@ -63,9 +63,8 @@ int main(int argc, char **argv) {
return 1;
}
// In addition to deleting all other functions, we also want to spiff it up a
// little bit. Do this now.
//
// In addition to deleting all other functions, we also want to spiff it
// up a little bit. Do this now.
PassManager Passes;
Passes.add(new TargetData("extract", M.get())); // Use correct TargetData
// Either isolate the function or delete it from the Module
@ -84,8 +83,11 @@ int main(int argc, char **argv) {
<< "Use -f command line argument to force output\n";
return 1;
}
Out = new std::ofstream(OutputFilename.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
Out = new std::ofstream(OutputFilename.c_str(), io_mode);
} else { // Specified stdout
// FIXME: cout is not binary!
Out = &std::cout;
}

5
llvm/tools/gccas/gccas.cpp
View File

@ -164,9 +164,12 @@ int main(int argc, char **argv) {
}
if (OutputFilename == "-")
// FIXME: cout is not binary!
Out = &std::cout;
else {
Out = new std::ofstream(OutputFilename.c_str(), std::ios::out);
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
Out = new std::ofstream(OutputFilename.c_str(), io_mode);
// Make sure that the Out file gets unlinked from the disk if we get a
// signal

4
llvm/tools/gccld/gccld.cpp
View File

@ -238,7 +238,9 @@ int main(int argc, char **argv, char **envp ) {
// Create the output file.
std::string RealBytecodeOutput = OutputFilename;
if (!LinkAsLibrary) RealBytecodeOutput += ".bc";
std::ofstream Out(RealBytecodeOutput.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
std::ofstream Out(RealBytecodeOutput.c_str(), io_mode);
if (!Out.good())
return PrintAndReturn(argv[0], "error opening '" + RealBytecodeOutput +
"' for writing!");

4
llvm/tools/llvm-ar/llvm-ar.cpp
View File

@ -436,7 +436,9 @@ void doExtract() {
}
// Open up a file stream for writing
std::ofstream file(I->getPath().c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
std::ofstream file(I->getPath().c_str(), io_mode);
// Get the data and its length
const char* data = reinterpret_cast<const char*>(I->getData());

31
llvm/tools/llvm-as/llvm-as.cpp
View File

@ -84,25 +84,26 @@ int main(int argc, char **argv) {
<< "Use -f command line argument to force output\n";
return 1;
}
Out = new std::ofstream(OutputFilename.c_str(), std::ios_base::out |
std::ios_base::trunc | std::ios_base::binary);
Out = new std::ofstream(OutputFilename.c_str(), std::ios::out |
std::ios::trunc | std::ios::binary);
} else { // Specified stdout
Out = &std::cout;
// FIXME: cout is not binary!
Out = &std::cout;
}
} else {
if (InputFilename == "-") {
OutputFilename = "-";
Out = &std::cout;
OutputFilename = "-";
Out = &std::cout;
} else {
std::string IFN = InputFilename;
int Len = IFN.length();
if (IFN[Len-3] == '.' && IFN[Len-2] == 'l' && IFN[Len-1] == 'l') {
// Source ends in .ll
OutputFilename = std::string(IFN.begin(), IFN.end()-3);
std::string IFN = InputFilename;
int Len = IFN.length();
if (IFN[Len-3] == '.' && IFN[Len-2] == 'l' && IFN[Len-1] == 'l') {
// Source ends in .ll
OutputFilename = std::string(IFN.begin(), IFN.end()-3);
} else {
OutputFilename = IFN; // Append a .bc to it
}
OutputFilename += ".bc";
OutputFilename = IFN; // Append a .bc to it
}
OutputFilename += ".bc";
if (!Force && std::ifstream(OutputFilename.c_str())) {
// If force is not specified, make sure not to overwrite a file!
@ -112,8 +113,8 @@ int main(int argc, char **argv) {
return 1;
}
Out = new std::ofstream(OutputFilename.c_str(), std::ios_base::out |
std::ios_base::trunc | std::ios_base::binary);
Out = new std::ofstream(OutputFilename.c_str(), std::ios::out |
std::ios::trunc | std::ios::binary);
// Make sure that the Out file gets unlinked from the disk if we get a
// SIGINT
sys::RemoveFileOnSignal(sys::Path(OutputFilename));

4
llvm/tools/llvm-ld/llvm-ld.cpp
View File

@ -186,7 +186,9 @@ static void RemoveEnv(const char * name, char ** const envp) {
void GenerateBytecode(Module* M, const std::string& FileName) {
// Create the output file.
std::ofstream Out(FileName.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
std::ofstream Out(FileName.c_str(), io_mode);
if (!Out.good()) {
PrintAndReturn("error opening '" + FileName + "' for writing!");
return;

5
llvm/tools/llvm-link/llvm-link.cpp
View File

@ -112,6 +112,7 @@ int main(int argc, char **argv) {
if (DumpAsm) std::cerr << "Here's the assembly:\n" << Composite.get();
// FIXME: cout is not binary!
std::ostream *Out = &std::cout; // Default to printing to stdout...
if (OutputFilename != "-") {
if (!Force && std::ifstream(OutputFilename.c_str())) {
@ -121,7 +122,9 @@ int main(int argc, char **argv) {
<< "Use -f command line argument to force output\n";
return 1;
}
Out = new std::ofstream(OutputFilename.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
Out = new std::ofstream(OutputFilename.c_str(), io_mode);
if (!Out->good()) {
std::cerr << argv[0] << ": error opening '" << OutputFilename << "'!\n";
return 1;

9
llvm/tools/opt/opt.cpp
View File

@ -95,6 +95,7 @@ int main(int argc, char **argv) {
}
// Figure out what stream we are supposed to write to...
// FIXME: cout is not binary!
std::ostream *Out = &std::cout; // Default to printing to stdout...
if (OutputFilename != "-") {
if (!Force && std::ifstream(OutputFilename.c_str())) {
@ -104,7 +105,9 @@ int main(int argc, char **argv) {
<< "Use -f command line argument to force output\n";
return 1;
}
Out = new std::ofstream(OutputFilename.c_str());
std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
std::ios::binary;
Out = new std::ofstream(OutputFilename.c_str(), io_mode);
if (!Out->good()) {
std::cerr << argv[0] << ": error opening " << OutputFilename << "!\n";
@ -117,8 +120,8 @@ int main(int argc, char **argv) {
}
// If the output is set to be emitted to standard out, and standard out is a
// console, print out a warning message and refuse to do it. We don't impress
// anyone by spewing tons of binary goo to a terminal.
// console, print out a warning message and refuse to do it. We don't
// impress anyone by spewing tons of binary goo to a terminal.
if (!Force && !NoOutput && CheckBytecodeOutputToConsole(Out,!Quiet)) {
NoOutput = true;
}