#include "llvm/Constants.h"
#include "llvm/Instructions.h"
#include "llvm/Bytecode/Writer.h"
-#include <iostream>
-
+#include "llvm/Support/Streams.h"
using namespace llvm;
int main() {
BB->getInstList().push_back(new ReturnInst(Add));
// Output the bytecode file to stdout
- WriteBytecodeToFile(M, std::cout);
+ WriteBytecodeToFile(M, llvm_cout);
// Delete the module and all of its contents.
delete M;
///
void initialize(Module &M);
+ void print(llvm_ostream &o, const Module *M) const {
+ if (o.stream()) print(*o.stream(), M);
+ }
virtual void print(std::ostream &o, const Module *M) const;
void dump() const;
/// dump - Print out this call graph node.
///
void dump() const;
+ void print(llvm_ostream &OS) const {
+ if (OS.stream()) print(*OS.stream());
+ }
void print(std::ostream &OS) const;
//===---------------------------------------------------------------------
#include "llvm/Pass.h"
#include "llvm/Bytecode/Writer.h"
-#include <iostream>
namespace llvm {
+class llvm_ostream;
+
class WriteBytecodePass : public ModulePass {
- std::ostream *Out; // ostream to print on
+ llvm_ostream *Out; // ostream to print on
bool DeleteStream;
bool CompressFile;
public:
WriteBytecodePass()
- : Out(&std::cout), DeleteStream(false), CompressFile(true) {}
- WriteBytecodePass(std::ostream *o, bool DS = false, bool CF = true)
+ : Out(&llvm_cout), DeleteStream(false), CompressFile(true) {}
+ WriteBytecodePass(llvm_ostream *o, bool DS = false, bool CF = true)
: Out(o), DeleteStream(DS), CompressFile(CF) {}
inline ~WriteBytecodePass() {
#ifndef LLVM_BYTECODE_WRITER_H
#define LLVM_BYTECODE_WRITER_H
-#include <iosfwd>
-
namespace llvm {
+ class llvm_ostream;
class Module;
/// WriteBytecodeToFile - Write the specified module to the specified output
/// stream. If compress is set to true, try to use compression when writing
/// out the file. This can never fail if M is a well-formed module.
- void WriteBytecodeToFile(const Module *M, std::ostream &Out,
+ void WriteBytecodeToFile(const Module *M, llvm_ostream &Out,
bool compress = true);
} // End llvm namespace
///
FunctionPass *createLinearScanRegisterAllocator();
+ /// PriorityBasedGraphColoringRegisterAllocator Pass - This pass implements
+ /// the priority-based graph coloring register allocator by Chow & Hennessey,
+ /// a global register allocator.
+ FunctionPass *createGraphColoringRegisterAllocator();
+
/// PrologEpilogCodeInserter Pass - This pass inserts prolog and epilog code,
/// and eliminates abstract frame references.
///
}
bool operator == (const std::ostream &OS) { return &OS == Stream; }
+ bool operator == (const llvm_ostream &OS) { return OS.Stream == Stream; }
};
extern llvm_ostream llvm_null;
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Timer.h"
-#include <iostream>
// FIXME: This should eventually be a FunctionPass that is automatically
// aggregated into a Pass.
// Variable index into a node. We must merge all of the elements of the
// sequential type here.
if (isa<PointerType>(STy))
- std::cerr << "Pointer indexing not handled yet!\n";
+ llvm_cerr << "Pointer indexing not handled yet!\n";
else {
const ArrayType *ATy = cast<ArrayType>(STy);
unsigned ElSize = TD.getTypeSize(CurTy);
if (DisableDirectCallOpt || !isa<Function>(Callee)) {
CalleeNode = getValueDest(*Callee).getNode();
if (CalleeNode == 0) {
- std::cerr << "WARNING: Program is calling through a null pointer?\n"<< *I;
+ llvm_cerr << "WARNING: Program is calling through a null pointer?\n"<< *I;
return; // Calling a null pointer?
}
}
#include "llvm/Assembly/Writer.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/GraphWriter.h"
+#include "llvm/Support/Streams.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Config/config.h"
-#include <iostream>
+#include <ostream>
#include <fstream>
#include <sstream>
using namespace llvm;
Statistic<> NumFoldedNodes ("dsa", "Number of folded nodes (in final graph)");
}
-void DSNode::dump() const { print(std::cerr, 0); }
+void DSNode::dump() const { print(llvm_cerr, 0); }
static std::string getCaption(const DSNode *N, const DSGraph *G) {
std::stringstream OS;
#include "llvm/Analysis/Passes.h"
#include "llvm/Module.h"
#include "llvm/Support/Debug.h"
-#include <iostream>
+#include <ostream>
using namespace llvm;
namespace {
}
// print - Implement the Pass::print method...
+ void print(llvm_ostream O, const Module *M) const {
+ if (O.stream()) print(*O.stream(), M);
+ }
void print(std::ostream &O, const Module *M) const {
assert(ResultGraph && "Result graph has not yet been computed!");
ResultGraph->writeGraphToFile(O, "steensgaards");
// FIXME: We should be able to disable the globals graph for steens!
//ResultGraph->removeDeadNodes(DSGraph::KeepUnreachableGlobals);
- DEBUG(print(std::cerr, &M));
+ print(DOUT, &M);
return false;
}
#include "llvm/Support/Debug.h"
#include "llvm/ADT/Statistic.h"
#include <set>
-#include <iostream>
using namespace llvm;
namespace {
case Instruction::BitCast:
return getNodeForConstantPointer(CE->getOperand(0));
default:
- std::cerr << "Constant Expr not yet handled: " << *CE << "\n";
+ llvm_cerr << "Constant Expr not yet handled: " << *CE << "\n";
assert(0);
}
} else {
case Instruction::BitCast:
return getNodeForConstantPointerTarget(CE->getOperand(0));
default:
- std::cerr << "Constant Expr not yet handled: " << *CE << "\n";
+ llvm_cerr << "Constant Expr not yet handled: " << *CE << "\n";
assert(0);
}
} else {
return;
default:
// Is this something we aren't handling yet?
- std::cerr << "Unknown instruction: " << I;
+ llvm_cerr << "Unknown instruction: " << I;
abort();
}
}
void Andersens::PrintNode(Node *N) {
if (N == &GraphNodes[UniversalSet]) {
- std::cerr << "<universal>";
+ llvm_cerr << "<universal>";
return;
} else if (N == &GraphNodes[NullPtr]) {
- std::cerr << "<nullptr>";
+ llvm_cerr << "<nullptr>";
return;
} else if (N == &GraphNodes[NullObject]) {
- std::cerr << "<null>";
+ llvm_cerr << "<null>";
return;
}
if (Function *F = dyn_cast<Function>(V)) {
if (isa<PointerType>(F->getFunctionType()->getReturnType()) &&
N == getReturnNode(F)) {
- std::cerr << F->getName() << ":retval";
+ llvm_cerr << F->getName() << ":retval";
return;
} else if (F->getFunctionType()->isVarArg() && N == getVarargNode(F)) {
- std::cerr << F->getName() << ":vararg";
+ llvm_cerr << F->getName() << ":vararg";
return;
}
}
if (Instruction *I = dyn_cast<Instruction>(V))
- std::cerr << I->getParent()->getParent()->getName() << ":";
+ llvm_cerr << I->getParent()->getParent()->getName() << ":";
else if (Argument *Arg = dyn_cast<Argument>(V))
- std::cerr << Arg->getParent()->getName() << ":";
+ llvm_cerr << Arg->getParent()->getName() << ":";
if (V->hasName())
- std::cerr << V->getName();
+ llvm_cerr << V->getName();
else
- std::cerr << "(unnamed)";
+ llvm_cerr << "(unnamed)";
if (isa<GlobalValue>(V) || isa<AllocationInst>(V))
if (N == getObject(V))
- std::cerr << "<mem>";
+ llvm_cerr << "<mem>";
}
void Andersens::PrintConstraints() {
- std::cerr << "Constraints:\n";
+ llvm_cerr << "Constraints:\n";
for (unsigned i = 0, e = Constraints.size(); i != e; ++i) {
- std::cerr << " #" << i << ": ";
+ llvm_cerr << " #" << i << ": ";
Constraint &C = Constraints[i];
if (C.Type == Constraint::Store)
- std::cerr << "*";
+ llvm_cerr << "*";
PrintNode(C.Dest);
- std::cerr << " = ";
+ llvm_cerr << " = ";
if (C.Type == Constraint::Load)
- std::cerr << "*";
+ llvm_cerr << "*";
PrintNode(C.Src);
- std::cerr << "\n";
+ llvm_cerr << "\n";
}
}
void Andersens::PrintPointsToGraph() {
- std::cerr << "Points-to graph:\n";
+ llvm_cerr << "Points-to graph:\n";
for (unsigned i = 0, e = GraphNodes.size(); i != e; ++i) {
Node *N = &GraphNodes[i];
- std::cerr << "[" << (N->end() - N->begin()) << "] ";
+ llvm_cerr << "[" << (N->end() - N->begin()) << "] ";
PrintNode(N);
- std::cerr << "\t--> ";
+ llvm_cerr << "\t--> ";
for (Node::iterator I = N->begin(), E = N->end(); I != E; ++I) {
- if (I != N->begin()) std::cerr << ", ";
+ if (I != N->begin()) llvm_cerr << ", ";
PrintNode(*I);
}
- std::cerr << "\n";
+ llvm_cerr << "\n";
}
}
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Support/CallSite.h"
-#include <iostream>
+#include "llvm/Support/Streams.h"
+#include <ostream>
using namespace llvm;
static bool isOnlyADirectCall(Function *F, CallSite CS) {
AU.setPreservesAll();
}
+ void print(llvm_ostream &o, const Module *M) const {
+ if (o.stream()) print(*o.stream(), M);
+ }
+
virtual void print(std::ostream &o, const Module *M) const {
o << "CallGraph Root is: ";
if (Function *F = getRoot()->getFunction())
/// dump - Print out this call graph.
///
inline void dump() const {
- print(std::cerr, Mod);
+ print(llvm_cerr, Mod);
}
CallGraphNode* getExternalCallingNode() const { return ExternalCallingNode; }
}
void CallGraph::dump() const {
- print(std::cerr, 0);
+ print(llvm_cerr, 0);
}
//===----------------------------------------------------------------------===//
OS << "\n";
}
-void CallGraphNode::dump() const { print(std::cerr); }
+void CallGraphNode::dump() const { print(llvm_cerr); }
void CallGraphNode::removeCallEdgeTo(CallGraphNode *Callee) {
for (unsigned i = CalledFunctions.size(); ; --i) {
SCEVHandle IH = SCEVUnknown::get(I); // Get I as a "symbolic" SCEV.
SCEVHandle V = S->evaluateAtIteration(IH);
- //std::cerr << "Evaluated: " << *this << "\n to: " << *V << "\n";
+ //llvm_cerr << "Evaluated: " << *this << "\n to: " << *V << "\n";
return expandInTy(V, Ty);
}
using namespace llvm;
#if 0
-#include <iostream>
-#define SC_DEBUG(X) std::cerr << X
+#include "llvm/Support/Streams.h"
+#define SC_DEBUG(X) llvm_cerr << X
#else
#define SC_DEBUG(X)
#endif
// Used for debugging DefSlot=-1 assertion...
//if (Typ == Type::TypeTy)
- // cerr << "Inserting type '" << cast<Type>(D)->getDescription() << "'!\n";
+ // llvm_cerr << "Inserting type '"<<cast<Type>(D)->getDescription() <<"'!\n";
if (Typ->isDerivedType()) {
int ValSlot;
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/Compressor.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/Program.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
break;
default:
- std::cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
+ llvm_cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
<< " Type '" << T->getDescription() << "'\n";
break;
}
case Type::VoidTyID:
case Type::LabelTyID:
default:
- std::cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
+ llvm_cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
<< " type '" << *CPV->getType() << "'\n";
break;
}
}
}
-void llvm::WriteBytecodeToFile(const Module *M, std::ostream &Out,
+void llvm::WriteBytecodeToFile(const Module *M, llvm_ostream &Out,
bool compress) {
assert(M && "You can't write a null module!!");
// Make sure that std::cout is put into binary mode for systems
// that care.
- if (&Out == std::cout)
+ if (Out == llvm_cout)
sys::Program::ChangeStdoutToBinary();
// Create a vector of unsigned char for the bytecode output. We
compressed_magic[2] = 'v';
compressed_magic[3] = 'c';
- Out.write(compressed_magic,4);
+ Out.stream()->write(compressed_magic,4);
// Compress everything after the magic number (which we altered)
Compressor::compressToStream(
(char*)(FirstByte+4), // Skip the magic number
Buffer.size()-4, // Skip the magic number
- Out // Where to write compressed data
+ *Out.stream() // Where to write compressed data
);
} else {
// We're not compressing, so just write the entire block.
- Out.write((char*)FirstByte, Buffer.size());
+ Out.stream()->write((char*)FirstByte, Buffer.size());
}
// make sure it hits disk now
- Out.flush();
+ Out.stream()->flush();
}
#include "llvm/Bytecode/Writer.h"
#include "llvm/Analysis/Verifier.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/Signals.h"
#include <fstream>
#include <iostream>
#include <memory>
-
using namespace llvm;
static cl::opt<std::string>
}
if (DumpAsm)
- std::cerr << "Here's the assembly:" << M.get();
+ llvm_cerr << "Here's the assembly:" << M.get();
if (OutputFilename != "") { // Specified an output filename?
if (OutputFilename != "-") { // Not stdout?
throw std::string("error opening ") + OutputFilename + "!";
}
- WriteBytecodeToFile(M.get(), *Out);
+ llvm_ostream L(*Out);
+ WriteBytecodeToFile(M.get(), L);
} catch (const ParseError &E) {
- std::cerr << argv[0] << ": " << E.getMessage() << "\n";
+ llvm_cerr << argv[0] << ": " << E.getMessage() << "\n";
return 1;
}
}
catch (const std::string& msg ) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
return 1;
}
#include "llvm/Target/TargetData.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/Path.h"
#include "llvm/System/Program.h"
#include "llvm/Config/alloca.h"
std::ofstream Out(Filename.c_str(), io_mode);
if (!Out.good()) return true;
try {
- WriteBytecodeToFile(M ? M : Program, Out, /*compression=*/true);
+ llvm_ostream L(Out);
+ WriteBytecodeToFile(M ? M : Program, L, /*compression=*/true);
} catch (...) {
return true;
}
//
std::string Filename = "bugpoint-" + ID + ".bc";
if (writeProgramToFile(Filename)) {
- std::cerr << "Error opening file '" << Filename << "' for writing!\n";
+ llvm_cerr << "Error opening file '" << Filename << "' for writing!\n";
return;
}
- std::cout << "Emitted bytecode to '" << Filename << "'\n";
+ llvm_cout << "Emitted bytecode to '" << Filename << "'\n";
if (NoFlyer || PassesToRun.empty()) return;
- std::cout << "\n*** You can reproduce the problem with: ";
- std::cout << "opt " << Filename << " ";
- std::cout << getPassesString(PassesToRun) << "\n";
+ llvm_cout << "\n*** You can reproduce the problem with: ";
+ llvm_cout << "opt " << Filename << " ";
+ llvm_cout << getPassesString(PassesToRun) << "\n";
}
int BugDriver::runPassesAsChild(const std::vector<const PassInfo*> &Passes) {
std::ios::binary;
std::ofstream OutFile(ChildOutput.c_str(), io_mode);
if (!OutFile.good()) {
- std::cerr << "Error opening bytecode file: " << ChildOutput << "\n";
+ llvm_cerr << "Error opening bytecode file: " << ChildOutput << "\n";
return 1;
}
if (Passes[i]->getNormalCtor())
PM.add(Passes[i]->getNormalCtor()());
else
- std::cerr << "Cannot create pass yet: " << Passes[i]->getPassName()
+ llvm_cerr << "Cannot create pass yet: " << Passes[i]->getPassName()
<< "\n";
}
// Check that the module is well formed on completion of optimization
PM.add(createVerifierPass());
// Write bytecode out to disk as the last step...
- PM.add(new WriteBytecodePass(&OutFile));
+ llvm_ostream L(OutFile);
+ PM.add(new WriteBytecodePass(&L));
// Run all queued passes.
PM.run(*Program);
std::string &OutputFilename, bool DeleteOutput,
bool Quiet) const {
// setup the output file name
- std::cout << std::flush;
+ llvm_cout << std::flush;
sys::Path uniqueFilename("bugpoint-output.bc");
std::string ErrMsg;
if (uniqueFilename.makeUnique(true, &ErrMsg)) {
- std::cerr << getToolName() << ": Error making unique filename: "
+ llvm_cerr << getToolName() << ": Error making unique filename: "
<< ErrMsg << "\n";
return(1);
}
// set up the input file name
sys::Path inputFilename("bugpoint-input.bc");
if (inputFilename.makeUnique(true, &ErrMsg)) {
- std::cerr << getToolName() << ": Error making unique filename: "
+ llvm_cerr << getToolName() << ": Error making unique filename: "
<< ErrMsg << "\n";
return(1);
}
std::ios::binary;
std::ofstream InFile(inputFilename.c_str(), io_mode);
if (!InFile.good()) {
- std::cerr << "Error opening bytecode file: " << inputFilename << "\n";
+ llvm_cerr << "Error opening bytecode file: " << inputFilename << "\n";
return(1);
}
- WriteBytecodeToFile(Program,InFile,false);
+ llvm_ostream L(InFile);
+ WriteBytecodeToFile(Program,L,false);
InFile.close();
// setup the child process' arguments
if (!Quiet) {
if (result == 0)
- std::cout << "Success!\n";
+ llvm_cout << "Success!\n";
else if (result > 0)
- std::cout << "Exited with error code '" << result << "'\n";
+ llvm_cout << "Exited with error code '" << result << "'\n";
else if (result < 0) {
if (result == -1)
- std::cout << "Execute failed: " << ErrMsg << "\n";
+ llvm_cout << "Execute failed: " << ErrMsg << "\n";
else
- std::cout << "Crashed with signal #" << abs(result) << "\n";
+ llvm_cout << "Crashed with signal #" << abs(result) << "\n";
}
if (result & 0x01000000)
- std::cout << "Dumped core\n";
+ llvm_cout << "Dumped core\n";
}
// Was the child successful?
std::string BytecodeResult;
if (runPasses(Passes, BytecodeResult, false/*delete*/, true/*quiet*/)) {
if (AutoDebugCrashes) {
- std::cerr << " Error running this sequence of passes"
+ llvm_cerr << " Error running this sequence of passes"
<< " on the input program!\n";
delete OldProgram;
EmitProgressBytecode("pass-error", false);
Module *Ret = ParseInputFile(BytecodeResult);
if (Ret == 0) {
- std::cerr << getToolName() << ": Error reading bytecode file '"
+ llvm_cerr << getToolName() << ": Error reading bytecode file '"
<< BytecodeResult << "'!\n";
exit(1);
}
#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/Signals.h"
+#include <iostream>
#include <memory>
#include <fstream>
-
using namespace llvm;
namespace {
ParseError Err;
std::auto_ptr<Module> M(ParseAssemblyFile(InputFilename,&Err));
if (M.get() == 0) {
- std::cerr << argv[0] << ": " << Err.getMessage() << "\n";
+ llvm_cerr << argv[0] << ": " << Err.getMessage() << "\n";
return 1;
}
if (!Out->good()) {
- std::cerr << argv[0] << ": error opening " << OutputFilename << "!\n";
+ llvm_cerr << argv[0] << ": error opening " << OutputFilename << "!\n";
return 1;
}
Passes.add(createVerifierPass());
// Write bytecode to file...
- Passes.add(new WriteBytecodePass(Out,false,!NoCompress));
+ llvm_ostream L(*Out);
+ Passes.add(new WriteBytecodePass(&L,false,!NoCompress));
// Run our queue of passes all at once now, efficiently.
Passes.run(*M.get());
if (Out != &std::cout) delete Out;
return 0;
} catch (const std::string& msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
} catch (...) {
- std::cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
+ llvm_cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
}
return 1;
}
#include "llvm/Transforms/Scalar.h"
#include "llvm/Support/SystemUtils.h"
#include "llvm/Support/CommandLine.h"
-
+#include "llvm/Support/Streams.h"
using namespace llvm;
namespace {
}
static void dumpArgs(const char **args) {
- std::cerr << *args++;
+ llvm_cerr << *args++;
while (*args)
- std::cerr << ' ' << *args++;
- std::cerr << '\n' << std::flush;
+ llvm_cerr << ' ' << *args++;
+ llvm_cerr << '\n' << std::flush;
}
static inline void addPass(PassManager &PM, Pass *P) {
Passes.add(createVerifierPass());
// Add the pass that writes bytecode to the output file...
- addPass(Passes, new WriteBytecodePass(Out, false, !NoCompress));
+ llvm_ostream L(*Out);
+ addPass(Passes, new WriteBytecodePass(&L, false, !NoCompress));
// Run our queue of passes all at once now, efficiently.
Passes.run(*M);
#include "llvm/Transforms/Scalar.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/Signals.h"
#include "llvm/Support/SystemUtils.h"
#include <fstream>
/// Message - The message to print to standard error.
///
static int PrintAndReturn(const char *progname, const std::string &Message) {
- std::cerr << progname << ": " << Message << "\n";
+ llvm_cerr << progname << ": " << Message << "\n";
return 1;
}
std::string ErrMsg;
sys::Path llvmstub = FindExecutable("llvm-stub.exe", argv[0]);
if (llvmstub.isEmpty()) {
- std::cerr << "Could not find llvm-stub.exe executable!\n";
+ llvm_cerr << "Could not find llvm-stub.exe executable!\n";
exit(1);
}
if (0 != sys::CopyFile(sys::Path(OutputFilename), llvmstub, &ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
exit(1);
}
return PrintAndReturn(argv[0], "Failed to find gcc");
// Generate an assembly language file for the bytecode.
- if (Verbose) std::cout << "Generating Assembly Code\n";
+ if (Verbose) llvm_cout << "Generating Assembly Code\n";
std::string ErrMsg;
if (0 != GenerateAssembly(
AssemblyFile.toString(), RealBytecodeOutput, llc, ErrMsg, Verbose)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 2;
}
- if (Verbose) std::cout << "Generating Native Code\n";
+ if (Verbose) llvm_cout << "Generating Native Code\n";
if (0 != GenerateNative(OutputFilename, AssemblyFile.toString(),
LibPaths, Libraries, gcc, envp, LinkAsLibrary,
NoInternalize, RPath, SOName, ErrMsg, Verbose) ) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 2;
}
return PrintAndReturn(argv[0], "Failed to find gcc");
// Generate an assembly language file for the bytecode.
- if (Verbose) std::cout << "Generating C Source Code\n";
+ if (Verbose) llvm_cout << "Generating C Source Code\n";
std::string ErrMsg;
if (0 != GenerateCFile(
CFile.toString(), RealBytecodeOutput, llc, ErrMsg, Verbose)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 2;
}
- if (Verbose) std::cout << "Generating Native Code\n";
+ if (Verbose) llvm_cout << "Generating Native Code\n";
if (0 != GenerateNative(OutputFilename, CFile.toString(),
LibPaths, Libraries, gcc, envp, LinkAsLibrary,
NoInternalize, RPath, SOName, ErrMsg, Verbose)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 2;
}
// Make the bytecode file readable and directly executable in LLEE
std::string ErrMsg;
if (sys::Path(RealBytecodeOutput).makeExecutableOnDisk(&ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
if (sys::Path(RealBytecodeOutput).makeReadableOnDisk(&ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
}
// Make the output, whether native or script, executable as well...
std::string ErrMsg;
if (sys::Path(OutputFilename).makeExecutableOnDisk(&ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
} catch (const char*msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
exitCode = 1;
} catch (const std::string& msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
exitCode = 2;
} catch (...) {
// This really shouldn't happen, but just in case ....
- std::cerr << argv[0] << ": An unexpected unknown exception occurred.\n";
+ llvm_cerr << argv[0] << ": An unexpected unknown exception occurred.\n";
exitCode = 3;
}
#include "llvm/Bytecode/Writer.h"
#include "llvm/Analysis/Verifier.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Streams.h"
#include "llvm/Support/SystemUtils.h"
#include "llvm/System/Signals.h"
#include <fstream>
#include <iostream>
#include <memory>
-
using namespace llvm;
static cl::opt<std::string>
ParseError Err;
std::auto_ptr<Module> M(ParseAssemblyFile(InputFilename,&Err));
if (M.get() == 0) {
- std::cerr << argv[0] << ": " << Err.getMessage() << "\n";
+ llvm_cerr << argv[0] << ": " << Err.getMessage() << "\n";
return 1;
}
if (!DisableVerify) {
std::string Err;
if (verifyModule(*M.get(), ReturnStatusAction, &Err)) {
- std::cerr << argv[0]
+ llvm_cerr << argv[0]
<< ": assembly parsed, but does not verify as correct!\n";
- std::cerr << Err;
+ llvm_cerr << Err;
return 1;
}
}
- if (DumpAsm) std::cerr << "Here's the assembly:\n" << *M.get();
+ if (DumpAsm) llvm_cerr << "Here's the assembly:\n" << *M.get();
if (OutputFilename != "") { // Specified an output filename?
if (OutputFilename != "-") { // Not stdout?
if (!Force && std::ifstream(OutputFilename.c_str())) {
// If force is not specified, make sure not to overwrite a file!
- std::cerr << argv[0] << ": error opening '" << OutputFilename
+ llvm_cerr << argv[0] << ": error opening '" << OutputFilename
<< "': file exists!\n"
<< "Use -f command line argument to force output\n";
return 1;
if (!Force && std::ifstream(OutputFilename.c_str())) {
// If force is not specified, make sure not to overwrite a file!
- std::cerr << argv[0] << ": error opening '" << OutputFilename
+ llvm_cerr << argv[0] << ": error opening '" << OutputFilename
<< "': file exists!\n"
<< "Use -f command line argument to force output\n";
return 1;
}
if (!Out->good()) {
- std::cerr << argv[0] << ": error opening " << OutputFilename << "!\n";
+ llvm_cerr << argv[0] << ": error opening " << OutputFilename << "!\n";
return 1;
}
if (Force || !CheckBytecodeOutputToConsole(Out,true)) {
- WriteBytecodeToFile(M.get(), *Out, !NoCompress);
+ llvm_ostream L(*Out);
+ WriteBytecodeToFile(M.get(), L, !NoCompress);
}
} catch (const std::string& msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
exitCode = 1;
} catch (...) {
- std::cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
+ llvm_cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
exitCode = 1;
}
#include "llvm/Transforms/IPO.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/Signals.h"
+#include <iostream>
#include <memory>
#include <fstream>
using namespace llvm;
std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename));
if (M.get() == 0) {
- std::cerr << argv[0] << ": bytecode didn't read correctly.\n";
+ llvm_cerr << argv[0] << ": bytecode didn't read correctly.\n";
return 1;
}
// Figure out which function we should extract
Function *F = M.get()->getNamedFunction(ExtractFunc);
if (F == 0) {
- std::cerr << argv[0] << ": program doesn't contain function named '"
+ llvm_cerr << argv[0] << ": program doesn't contain function named '"
<< ExtractFunc << "'!\n";
return 1;
}
if (OutputFilename != "-") { // Not stdout?
if (!Force && std::ifstream(OutputFilename.c_str())) {
// If force is not specified, make sure not to overwrite a file!
- std::cerr << argv[0] << ": error opening '" << OutputFilename
+ llvm_cerr << argv[0] << ": error opening '" << OutputFilename
<< "': file exists!\n"
<< "Use -f command line argument to force output\n";
return 1;
Out = &std::cout;
}
- Passes.add(new WriteBytecodePass(Out)); // Write bytecode to file...
+ llvm_ostream L(*Out);
+ Passes.add(new WriteBytecodePass(&L)); // Write bytecode to file...
Passes.run(*M.get());
if (Out != &std::cout)
delete Out;
return 0;
} catch (const std::string& msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
} catch (...) {
- std::cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
+ llvm_cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
}
return 1;
}
#include "llvm/Target/TargetMachineRegistry.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/Streams.h"
#include "llvm/Support/SystemUtils.h"
#include "llvm/System/Signals.h"
#include <fstream>
-#include <iostream>
#include <memory>
-
using namespace llvm;
// Input/Output Options
/// Message - The message to print to standard error.
///
static int PrintAndReturn(const std::string &Message) {
- std::cerr << progname << ": " << Message << "\n";
+ llvm_cerr << progname << ": " << Message << "\n";
return 1;
}
sys::RemoveFileOnSignal(sys::Path(FileName));
// Write it out
- WriteBytecodeToFile(M, Out, !DisableCompression);
+ llvm_ostream L(Out);
+ WriteBytecodeToFile(M, L, !DisableCompression);
// Close the bytecode file.
Out.close();
std::string ErrMsg;
sys::Path llvmstub = FindExecutable("llvm-stub.exe", argv[0]);
if (llvmstub.isEmpty()) {
- std::cerr << "Could not find llvm-stub.exe executable!\n";
+ llvm_cerr << "Could not find llvm-stub.exe executable!\n";
exit(1);
}
if (0 != sys::CopyFile(sys::Path(OutputFilename), llvmstub, &ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
exit(1);
}
sys::Path target(RealBytecodeOutput);
target.eraseFromDisk();
if (tmp_output.renamePathOnDisk(target, &ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 2;
}
} else
return PrintAndReturn(
"Post-link optimization output is not bytecode");
} else {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 2;
}
}
return PrintAndReturn("Failed to find gcc");
// Generate an assembly language file for the bytecode.
- if (Verbose) std::cout << "Generating Assembly Code\n";
+ if (Verbose) llvm_cout << "Generating Assembly Code\n";
std::string ErrMsg;
if (0 != GenerateAssembly(AssemblyFile.toString(), RealBytecodeOutput,
llc, ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
- if (Verbose) std::cout << "Generating Native Code\n";
+ if (Verbose) llvm_cout << "Generating Native Code\n";
if (0 != GenerateNative(OutputFilename, AssemblyFile.toString(),
LinkItems,gcc,envp,ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
return PrintAndReturn("Failed to find gcc");
// Generate an assembly language file for the bytecode.
- if (Verbose) std::cout << "Generating Assembly Code\n";
+ if (Verbose) llvm_cout << "Generating Assembly Code\n";
std::string ErrMsg;
if (0 != GenerateCFile(
CFile.toString(), RealBytecodeOutput, llc, ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
- if (Verbose) std::cout << "Generating Native Code\n";
+ if (Verbose) llvm_cout << "Generating Native Code\n";
if (0 != GenerateNative(OutputFilename, CFile.toString(), LinkItems,
gcc, envp, ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
// Make the script executable...
std::string ErrMsg;
if (sys::Path(OutputFilename).makeExecutableOnDisk(&ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
// Make the bytecode file readable and directly executable in LLEE as well
if (sys::Path(RealBytecodeOutput).makeExecutableOnDisk(&ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
if (sys::Path(RealBytecodeOutput).makeReadableOnDisk(&ErrMsg)) {
- std::cerr << argv[0] << ": " << ErrMsg << "\n";
+ llvm_cerr << argv[0] << ": " << ErrMsg << "\n";
return 1;
}
}
return 0;
} catch (const std::string& msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
} catch (...) {
- std::cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
+ llvm_cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
}
return 1;
}
#include "llvm/Bytecode/Reader.h"
#include "llvm/Bytecode/Writer.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Streams.h"
#include "llvm/System/Signals.h"
#include "llvm/System/Path.h"
#include <fstream>
#include <iostream>
#include <memory>
-
using namespace llvm;
static cl::list<std::string>
static inline std::auto_ptr<Module> LoadFile(const std::string &FN) {
sys::Path Filename;
if (!Filename.set(FN)) {
- std::cerr << "Invalid file name: '" << FN << "'\n";
+ llvm_cerr << "Invalid file name: '" << FN << "'\n";
return std::auto_ptr<Module>();
}
std::string ErrorMessage;
if (Filename.exists()) {
- if (Verbose) std::cerr << "Loading '" << Filename.c_str() << "'\n";
+ if (Verbose) llvm_cerr << "Loading '" << Filename.c_str() << "'\n";
Module* Result = ParseBytecodeFile(Filename.toString(), &ErrorMessage);
if (Result) return std::auto_ptr<Module>(Result); // Load successful!
if (Verbose) {
- std::cerr << "Error opening bytecode file: '" << Filename.c_str() << "'";
- if (ErrorMessage.size()) std::cerr << ": " << ErrorMessage;
- std::cerr << "\n";
+ llvm_cerr << "Error opening bytecode file: '" << Filename.c_str() << "'";
+ if (ErrorMessage.size()) llvm_cerr << ": " << ErrorMessage;
+ llvm_cerr << "\n";
}
} else {
- std::cerr << "Bytecode file: '" << Filename.c_str()
+ llvm_cerr << "Bytecode file: '" << Filename.c_str()
<< "' does not exist.\n";
}
std::auto_ptr<Module> Composite(LoadFile(InputFilenames[BaseArg]));
if (Composite.get() == 0) {
- std::cerr << argv[0] << ": error loading file '"
+ llvm_cerr << argv[0] << ": error loading file '"
<< InputFilenames[BaseArg] << "'\n";
return 1;
}
for (unsigned i = BaseArg+1; i < InputFilenames.size(); ++i) {
std::auto_ptr<Module> M(LoadFile(InputFilenames[i]));
if (M.get() == 0) {
- std::cerr << argv[0] << ": error loading file '"
+ llvm_cerr << argv[0] << ": error loading file '"
<< InputFilenames[i] << "'\n";
return 1;
}
- if (Verbose) std::cerr << "Linking in '" << InputFilenames[i] << "'\n";
+ if (Verbose) llvm_cerr << "Linking in '" << InputFilenames[i] << "'\n";
if (Linker::LinkModules(Composite.get(), M.get(), &ErrorMessage)) {
- std::cerr << argv[0] << ": link error in '" << InputFilenames[i]
+ llvm_cerr << argv[0] << ": link error in '" << InputFilenames[i]
<< "': " << ErrorMessage << "\n";
return 1;
}
// TODO: Iterate over the -l list and link in any modules containing
// global symbols that have not been resolved so far.
- if (DumpAsm) std::cerr << "Here's the assembly:\n" << *Composite.get();
+ if (DumpAsm) llvm_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())) {
// If force is not specified, make sure not to overwrite a file!
- std::cerr << argv[0] << ": error opening '" << OutputFilename
+ llvm_cerr << argv[0] << ": error opening '" << OutputFilename
<< "': file exists!\n"
<< "Use -f command line argument to force output\n";
return 1;
std::ios::binary;
Out = new std::ofstream(OutputFilename.c_str(), io_mode);
if (!Out->good()) {
- std::cerr << argv[0] << ": error opening '" << OutputFilename << "'!\n";
+ llvm_cerr << argv[0] << ": error opening '" << OutputFilename << "'!\n";
return 1;
}
}
if (verifyModule(*Composite.get())) {
- std::cerr << argv[0] << ": linked module is broken!\n";
+ llvm_cerr << argv[0] << ": linked module is broken!\n";
return 1;
}
- if (Verbose) std::cerr << "Writing bytecode...\n";
- WriteBytecodeToFile(Composite.get(), *Out, !NoCompress);
+ if (Verbose) llvm_cerr << "Writing bytecode...\n";
+ llvm_ostream L(*Out);
+ WriteBytecodeToFile(Composite.get(), L, !NoCompress);
if (Out != &std::cout) delete Out;
return 0;
} catch (const std::string& msg) {
- std::cerr << argv[0] << ": " << msg << "\n";
+ llvm_cerr << argv[0] << ": " << msg << "\n";
} catch (...) {
- std::cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
+ llvm_cerr << argv[0] << ": Unexpected unknown exception occurred.\n";
}
return 1;
}
#include "llvm/Transforms/Scalar.h"
#include "llvm/Analysis/LoadValueNumbering.h"
#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Streams.h"
#include "llvm/LinkTimeOptimizer.h"
#include <fstream>
-#include <iostream>
-
+#include <ostream>
using namespace llvm;
extern "C"
std::string tempFileName(FinalOutputPath.c_str());
tempFileName += "0.bc";
std::ofstream Out(tempFileName.c_str(), io_mode);
- WriteBytecodeToFile(bigOne, Out, true);
+ llvm_ostream L(Out);
+ WriteBytecodeToFile(bigOne, L, true);
}
// Strip leading underscore because it was added to match names
std::string ErrMsg;
sys::Path TempDir = sys::Path::GetTemporaryDirectory(&ErrMsg);
if (TempDir.isEmpty()) {
- std::cerr << "lto: " << ErrMsg << "\n";
+ llvm_cerr << "lto: " << ErrMsg << "\n";
return LTO_WRITE_FAILURE;
}
sys::Path tmpAsmFilePath(TempDir);
if (!tmpAsmFilePath.appendComponent("lto")) {
- std::cerr << "lto: " << ErrMsg << "\n";
+ llvm_cerr << "lto: " << ErrMsg << "\n";
TempDir.eraseFromDisk(true);
return LTO_WRITE_FAILURE;
}
if (tmpAsmFilePath.createTemporaryFileOnDisk(&ErrMsg)) {
- std::cerr << "lto: " << ErrMsg << "\n";
+ llvm_cerr << "lto: " << ErrMsg << "\n";
TempDir.eraseFromDisk(true);
return LTO_WRITE_FAILURE;
}
std::string tempFileName(FinalOutputPath.c_str());
tempFileName += "1.bc";
std::ofstream Out(tempFileName.c_str(), io_mode);
- WriteBytecodeToFile(bigOne, Out, true);
+ llvm_ostream L(Out);
+ WriteBytecodeToFile(bigOne, L, true);
}
targetTriple = bigOne->getTargetTriple();
args.push_back(0);
if (sys::Program::ExecuteAndWait(gcc, &args[0], 0, 0, 1, &ErrMsg)) {
- std::cerr << "lto: " << ErrMsg << "\n";
+ llvm_cerr << "lto: " << ErrMsg << "\n";
return LTO_ASM_FAILURE;
}
#include "llvm/Support/Timer.h"
#include "llvm/LinkAllPasses.h"
#include "llvm/LinkAllVMCore.h"
+#include <iostream>
#include <fstream>
#include <memory>
#include <algorithm>
Passes.add(createVerifierPass());
// Write bytecode out to disk or cout as the last step...
- if (!NoOutput && !AnalyzeOnly)
- Passes.add(new WriteBytecodePass(Out, Out != &std::cout, !NoCompress));
+ if (!NoOutput && !AnalyzeOnly) {
+ llvm_ostream L(*Out);
+ Passes.add(new WriteBytecodePass(&L, Out != &std::cout, !NoCompress));
+ }
// Now that we have all of the passes ready, run them.
Passes.run(*M.get());
projects / oota-llvm.git / commitdiff