6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-01 02:29:19 +00:00
Code Issues Projects Releases Wiki Activity

Use raw_ostream throughout the AsmPrinter.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@55092 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2008-08-21 00:14:44 +00:00
parent f4a97da407
commit cb37188323
66 changed files with 448 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/CodeGen/AsmPrinter.h
View File

@ -34,6 +34,7 @@ namespace llvm {
class Mangler;
class TargetAsmInfo;
class Type;
class raw_ostream;
/// AsmPrinter - This class is intended to be used as a driving class for all
/// asm writers.
@ -64,7 +65,7 @@ namespace llvm {
public:
/// Output stream on which we're printing assembly code.
///
std::ostream &O;
raw_ostream &O;
/// Target machine description.
///
@ -96,7 +97,7 @@ namespace llvm {
bool IsInTextSection;
protected:
AsmPrinter(std::ostream &o, TargetMachine &TM, const TargetAsmInfo *T);
AsmPrinter(raw_ostream &o, TargetMachine &TM, const TargetAsmInfo *T);
public:
virtual ~AsmPrinter();

3
include/llvm/CodeGen/DwarfWriter.h
View File

@ -31,6 +31,7 @@ class MachineModuleInfo;
class MachineFunction;
class Module;
class TargetAsmInfo;
class raw_ostream;
//===----------------------------------------------------------------------===//
// DwarfWriter - Emits Dwarf debug and exception handling directives.
@ -48,7 +49,7 @@ private:
public:
DwarfWriter(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T);
DwarfWriter(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T);
virtual ~DwarfWriter();
/// SetModuleInfo - Set machine module info when it's known that pass manager

5
include/llvm/CodeGen/FileWriters.h
View File

@ -21,10 +21,11 @@ namespace llvm {
class PassManagerBase;
class MachineCodeEmitter;
class TargetMachine;
class raw_ostream;
MachineCodeEmitter *AddELFWriter(PassManagerBase &FPM, std::ostream &O,
MachineCodeEmitter *AddELFWriter(PassManagerBase &FPM, raw_ostream &O,
TargetMachine &TM);
MachineCodeEmitter *AddMachOWriter(PassManagerBase &FPM, std::ostream &O,
MachineCodeEmitter *AddMachOWriter(PassManagerBase &FPM, raw_ostream &O,
TargetMachine &TM);
} // end llvm namespace

5
include/llvm/CodeGen/GCMetadataPrinter.h
View File

@ -29,6 +29,7 @@
namespace llvm {
class GCMetadataPrinter;
class raw_ostream;
/// GCMetadataPrinterRegistry - The GC assembly printer registry uses all the
/// defaults from Registry.
@ -63,10 +64,10 @@ namespace llvm {
iterator end() { return S->end(); }
/// beginAssembly/finishAssembly - Emit module metadata as assembly code.
virtual void beginAssembly(std::ostream &OS, AsmPrinter &AP,
virtual void beginAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI);
virtual void finishAssembly(std::ostream &OS, AsmPrinter &AP,
virtual void finishAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI);
virtual ~GCMetadataPrinter();

10
include/llvm/CodeGen/MachineInstr.h
View File

@ -258,6 +258,11 @@ public:
}
void print(std::ostream &OS, const TargetMachine *TM = 0) const;
void print(std::ostream *OS) const { if (OS) print(*OS); }
void print(raw_ostream *OS, const TargetMachine *TM) const {
if (OS) print(*OS, TM);
}
void print(raw_ostream &OS, const TargetMachine *TM = 0) const;
void print(raw_ostream *OS) const { if (OS) print(*OS); }
void dump() const;
//===--------------------------------------------------------------------===//
@ -316,6 +321,11 @@ inline std::ostream& operator<<(std::ostream &OS, const MachineInstr &MI) {
return OS;
}
inline raw_ostream& operator<<(raw_ostream &OS, const MachineInstr &MI) {
MI.print(OS);
return OS;
}
} // End llvm namespace
#endif

7
include/llvm/CodeGen/MachineOperand.h
View File

@ -26,6 +26,7 @@ class GlobalValue;
class MachineInstr;
class TargetMachine;
class MachineRegisterInfo;
class raw_ostream;
/// MachineOperand class - Representation of each machine instruction operand.
///
@ -117,6 +118,7 @@ public:
const MachineInstr *getParent() const { return ParentMI; }
void print(std::ostream &os, const TargetMachine *TM = 0) const;
void print(raw_ostream &os, const TargetMachine *TM = 0) const;
/// Accessors that tell you what kind of MachineOperand you're looking at.
///
@ -425,6 +427,11 @@ inline std::ostream &operator<<(std::ostream &OS, const MachineOperand &MO) {
return OS;
}
inline raw_ostream &operator<<(raw_ostream &OS, const MachineOperand& MO) {
MO.print(OS, 0);
return OS;
}
} // End llvm namespace
#endif

35
include/llvm/Support/raw_ostream.h
View File

@ -14,6 +14,7 @@
#ifndef LLVM_SUPPORT_RAW_OSTREAM_H
#define LLVM_SUPPORT_RAW_OSTREAM_H
#include "llvm/ADT/StringExtras.h"
#include <cassert>
#include <cstring>
#include <string>
@ -72,7 +73,11 @@ public:
return write(Str, strlen(Str));
}
raw_ostream &operator<<(unsigned N) {
raw_ostream &operator<<(const std::string& Str) {
return write(Str.data(), Str.length());
}
raw_ostream &operator<<(uint64_t N) {
// Zero is a special case.
if (N == 0)
return *this << '0';
@ -88,6 +93,34 @@ public:
return write(CurPtr, EndPtr-CurPtr);
}
raw_ostream &operator<<(int64_t N) {
if (N < 0) {
if (OutBufCur >= OutBufEnd)
flush_impl();
*OutBufCur++ = '-';
N = -N;
}
return this->operator<<(static_cast<uint64_t>(N));
}
raw_ostream &operator<<(uint32_t N) {
return this->operator<<(static_cast<uint64_t>(N));
}
raw_ostream &operator<<(int32_t N) {
return this->operator<<(static_cast<int64_t>(N));
}
raw_ostream &operator<<(size_t N) {
return this->operator<<(static_cast<uint64_t>(N));
}
raw_ostream &operator<<(double N) {
return this->operator<<(ftostr(N));
}
raw_ostream &write(const char *Ptr, unsigned Size) {
if (OutBufCur+Size > OutBufEnd)

9
include/llvm/Target/TargetMachine.h
View File

@ -35,6 +35,7 @@ class PassManager;
class Pass;
class TargetMachOWriterInfo;
class TargetELFWriterInfo;
class raw_ostream;
// Relocation model types.
namespace Reloc {
@ -196,7 +197,7 @@ public:
/// is not supported.
///
virtual FileModel::Model addPassesToEmitFile(PassManagerBase &,
std::ostream &,
raw_ostream &,
CodeGenFileType,
bool /*Fast*/) {
return FileModel::None;
@ -227,7 +228,7 @@ public:
/// require having the entire module at once. This is not recommended, do not
/// use this.
virtual bool WantsWholeFile() const { return false; }
virtual bool addPassesToEmitWholeFile(PassManager &, std::ostream &,
virtual bool addPassesToEmitWholeFile(PassManager &, raw_ostream &,
CodeGenFileType, bool /*Fast*/) {
return true;
}
@ -253,7 +254,7 @@ public:
/// target-specific passes in standard locations.
///
virtual FileModel::Model addPassesToEmitFile(PassManagerBase &PM,
std::ostream &Out,
raw_ostream &Out,
CodeGenFileType FileType,
bool Fast);
@ -309,7 +310,7 @@ public:
/// the asmprinter, if asm emission is supported. If this is not supported,
/// 'true' should be returned.
virtual bool addAssemblyEmitter(PassManagerBase &, bool /*Fast*/,
std::ostream &) {
raw_ostream &) {
return true;
}

22
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
View File

@ -21,7 +21,7 @@
#include "llvm/CodeGen/MachineJumpTableInfo.h"
#include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/Streams.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
@ -31,11 +31,12 @@
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include <cerrno>
using namespace llvm;
char AsmPrinter::ID = 0;
AsmPrinter::AsmPrinter(std::ostream &o, TargetMachine &tm,
AsmPrinter::AsmPrinter(raw_ostream &o, TargetMachine &tm,
const TargetAsmInfo *T)
: MachineFunctionPass((intptr_t)&ID), FunctionNumber(0), O(o),
TM(tm), TAI(T), TRI(tm.getRegisterInfo()),
@ -268,8 +269,9 @@ void AsmPrinter::EmitConstantPool(unsigned Alignment, const char *Section,
EmitAlignment(Alignment);
for (unsigned i = 0, e = CP.size(); i != e; ++i) {
O << TAI->getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
<< CP[i].second << ":\t\t\t\t\t" << TAI->getCommentString() << ' ';
WriteTypeSymbolic(O, CP[i].first.getType(), 0);
<< CP[i].second << ":\t\t\t\t\t";
// O << TAI->getCommentString() << ' ' <<
// WriteTypeSymbolic(O, CP[i].first.getType(), 0);
O << '\n';
if (CP[i].first.isMachineConstantPoolEntry())
EmitMachineConstantPoolValue(CP[i].first.Val.MachineCPVal);
@ -495,7 +497,7 @@ void AsmPrinter::PrintULEB128(unsigned Value) const {
unsigned Byte = Value & 0x7f;
Value >>= 7;
if (Value) Byte |= 0x80;
O << "0x" << std::hex << Byte << std::dec;
O << "0x" << utohexstr(Byte);
if (Value) O << ", ";
} while (Value);
}
@ -511,7 +513,7 @@ void AsmPrinter::PrintSLEB128(int Value) const {
Value >>= 7;
IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
if (IsMore) Byte |= 0x80;
O << "0x" << std::hex << Byte << std::dec;
O << "0x" << utohexstr(Byte);
if (IsMore) O << ", ";
} while (IsMore);
}
@ -523,7 +525,7 @@ void AsmPrinter::PrintSLEB128(int Value) const {
/// PrintHex - Print a value as a hexidecimal value.
///
void AsmPrinter::PrintHex(int Value) const {
O << "0x" << std::hex << Value << std::dec;
O << "0x" << utohexstr(static_cast<unsigned>(Value));
}
/// EOL - Print a newline character to asm stream. If a comment is present
@ -622,7 +624,7 @@ static inline char toOctal(int X) {
/// printStringChar - Print a char, escaped if necessary.
///
static void printStringChar(std::ostream &O, unsigned char C) {
static void printStringChar(raw_ostream &O, char C) {
if (C == '"') {
O << "\\\"";
} else if (C == '\\') {
@ -706,7 +708,7 @@ void AsmPrinter::EmitAlignment(unsigned NumBits, const GlobalValue *GV,
unsigned FillValue = TAI->getTextAlignFillValue();
UseFillExpr &= IsInTextSection && FillValue;
if (UseFillExpr) O << ",0x" << std::hex << FillValue << std::dec;
if (UseFillExpr) O << ",0x" << utohexstr(FillValue);
O << '\n';
}
@ -855,7 +857,7 @@ void AsmPrinter::EmitConstantValueOnly(const Constant *CV) {
/// printAsCString - Print the specified array as a C compatible string, only if
/// the predicate isString is true.
///
static void printAsCString(std::ostream &O, const ConstantArray *CVA,
static void printAsCString(raw_ostream &O, const ConstantArray *CVA,
unsigned LastElt) {
assert(CVA->isString() && "Array is not string compatible!");

11
lib/CodeGen/AsmPrinter/DwarfWriter.cpp
View File

@ -28,6 +28,7 @@
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Path.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
@ -820,7 +821,7 @@ protected:
//
/// O - Stream to .s file.
///
std::ostream &O;
raw_ostream &O;
/// Asm - Target of Dwarf emission.
///
@ -856,7 +857,7 @@ protected:
const char * const Flavor;
unsigned SetCounter;
Dwarf(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T,
Dwarf(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T,
const char *flavor)
: O(OS)
, Asm(A)
@ -2673,7 +2674,7 @@ public:
//===--------------------------------------------------------------------===//
// Main entry points.
//
DwarfDebug(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
DwarfDebug(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
: Dwarf(OS, A, T, "dbg")
, CompileUnits()
, AbbreviationsSet(InitAbbreviationsSetSize)
@ -3479,7 +3480,7 @@ public:
//===--------------------------------------------------------------------===//
// Main entry points.
//
DwarfException(std::ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
DwarfException(raw_ostream &OS, AsmPrinter *A, const TargetAsmInfo *T)
: Dwarf(OS, A, T, "eh")
, shouldEmitTable(false)
, shouldEmitMoves(false)
@ -3879,7 +3880,7 @@ void DIE::dump() {
/// DwarfWriter Implementation
///
DwarfWriter::DwarfWriter(std::ostream &OS, AsmPrinter *A,
DwarfWriter::DwarfWriter(raw_ostream &OS, AsmPrinter *A,
const TargetAsmInfo *T) {
DE = new DwarfException(OS, A, T);
DD = new DwarfDebug(OS, A, T);

11
lib/CodeGen/AsmPrinter/OcamlGCPrinter.cpp
View File

@ -15,6 +15,7 @@
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/CodeGen/GCMetadataPrinter.h"
#include "llvm/Module.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
@ -25,10 +26,10 @@ namespace {
class VISIBILITY_HIDDEN OcamlGCMetadataPrinter : public GCMetadataPrinter {
public:
void beginAssembly(std::ostream &OS, AsmPrinter &AP,
void beginAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI);
void finishAssembly(std::ostream &OS, AsmPrinter &AP,
void finishAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI);
};
@ -39,7 +40,7 @@ Y("ocaml", "ocaml 3.10-compatible collector");
void llvm::linkOcamlGCPrinter() { }
static void EmitCamlGlobal(const Module &M, std::ostream &OS, AsmPrinter &AP,
static void EmitCamlGlobal(const Module &M, raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI, const char *Id) {
const std::string &MId = M.getModuleIdentifier();
@ -59,7 +60,7 @@ static void EmitCamlGlobal(const Module &M, std::ostream &OS, AsmPrinter &AP,
OS << Mangled << ":\n";
}
void OcamlGCMetadataPrinter::beginAssembly(std::ostream &OS, AsmPrinter &AP,
void OcamlGCMetadataPrinter::beginAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI) {
AP.SwitchToTextSection(TAI.getTextSection());
EmitCamlGlobal(getModule(), OS, AP, TAI, "code_begin");
@ -84,7 +85,7 @@ void OcamlGCMetadataPrinter::beginAssembly(std::ostream &OS, AsmPrinter &AP,
/// (FrameSize and LiveOffsets would overflow). FrameTablePrinter will abort if
/// either condition is detected in a function which uses the GC.
///
void OcamlGCMetadataPrinter::finishAssembly(std::ostream &OS, AsmPrinter &AP,
void OcamlGCMetadataPrinter::finishAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI) {
const char *AddressDirective;
int AddressAlignLog;

9
lib/CodeGen/ELFWriter.cpp
View File

@ -44,6 +44,7 @@
#include "llvm/Support/Mangler.h"
#include "llvm/Support/OutputBuffer.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h"
#include <list>
using namespace llvm;
@ -51,7 +52,7 @@ char ELFWriter::ID = 0;
/// AddELFWriter - Concrete function to add the ELF writer to the function pass
/// manager.
MachineCodeEmitter *llvm::AddELFWriter(PassManagerBase &PM,
std::ostream &O,
raw_ostream &O,
TargetMachine &TM) {
ELFWriter *EW = new ELFWriter(O, TM);
PM.add(EW);
@ -193,7 +194,7 @@ bool ELFCodeEmitter::finishFunction(MachineFunction &F) {
// ELFWriter Implementation
//===----------------------------------------------------------------------===//
ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm)
ELFWriter::ELFWriter(raw_ostream &o, TargetMachine &tm)
: MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) {
e_flags = 0; // e_flags defaults to 0, no flags.
@ -536,7 +537,7 @@ void ELFWriter::OutputSectionsAndSectionTable() {
if (S.Align)
for (size_t NewFileOff = (FileOff+S.Align-1) & ~(S.Align-1);
FileOff != NewFileOff; ++FileOff)
O.put((char)0xAB);
O << (char)0xAB;
O.write((char*)&S.SectionData[0], S.SectionData.size());
FileOff += S.SectionData.size();
@ -557,7 +558,7 @@ void ELFWriter::OutputSectionsAndSectionTable() {
// Align output for the section table.
for (size_t NewFileOff = (FileOff+TableAlign-1) & ~(TableAlign-1);
FileOff != NewFileOff; ++FileOff)
O.put((char)0xAB);
O << (char)0xAB;
// Emit the section table itself.
O.write((char*)&Table[0], Table.size());

5
lib/CodeGen/ELFWriter.h
View File

@ -23,6 +23,7 @@ namespace llvm {
class Mangler;
class MachineCodeEmitter;
class ELFCodeEmitter;
class raw_ostream;
/// ELFWriter - This class implements the common target-independent code for
/// writing ELF files. Targets should derive a class from this to
@ -37,7 +38,7 @@ namespace llvm {
return *(MachineCodeEmitter*)MCE;
}
ELFWriter(std::ostream &O, TargetMachine &TM);
ELFWriter(raw_ostream &O, TargetMachine &TM);
~ELFWriter();
typedef std::vector<unsigned char> DataBuffer;
@ -45,7 +46,7 @@ namespace llvm {
protected:
/// Output stream to send the resultant object file to.
///
std::ostream &O;
raw_ostream &O;
/// Target machine description.
///

4
lib/CodeGen/GCMetadataPrinter.cpp
View File

@ -19,12 +19,12 @@ GCMetadataPrinter::GCMetadataPrinter() { }
GCMetadataPrinter::~GCMetadataPrinter() { }
void GCMetadataPrinter::beginAssembly(std::ostream &OS, AsmPrinter &AP,
void GCMetadataPrinter::beginAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI) {
// Default is no action.
}
void GCMetadataPrinter::finishAssembly(std::ostream &OS, AsmPrinter &AP,
void GCMetadataPrinter::finishAssembly(raw_ostream &OS, AsmPrinter &AP,
const TargetAsmInfo &TAI) {
// Default is no action.
}

3
lib/CodeGen/LLVMTargetMachine.cpp
View File

@ -22,6 +22,7 @@
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
static cl::opt<bool> PrintLSR("print-lsr-output", cl::Hidden,
@ -50,7 +51,7 @@ DisablePostRAScheduler("disable-post-RA-scheduler",
FileModel::Model
LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
std::ostream &Out,
raw_ostream &Out,
CodeGenFileType FileType,
bool Fast) {
// Standard LLVM-Level Passes.

5
lib/CodeGen/MachOWriter.cpp
View File

@ -37,6 +37,7 @@
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/OutputBuffer.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cstring>
using namespace llvm;
@ -44,7 +45,7 @@ using namespace llvm;
/// AddMachOWriter - Concrete function to add the Mach-O writer to the function
/// pass manager.
MachineCodeEmitter *llvm::AddMachOWriter(PassManagerBase &PM,
std::ostream &O,
raw_ostream &O,
TargetMachine &TM) {
MachOWriter *MOW = new MachOWriter(O, TM);
PM.add(MOW);
@ -334,7 +335,7 @@ void MachOCodeEmitter::emitJumpTables(MachineJumpTableInfo *MJTI) {
//===----------------------------------------------------------------------===//
char MachOWriter::ID = 0;
MachOWriter::MachOWriter(std::ostream &o, TargetMachine &tm)
MachOWriter::MachOWriter(raw_ostream &o, TargetMachine &tm)
: MachineFunctionPass((intptr_t)&ID), O(o), TM(tm) {
is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
isLittleEndian = TM.getTargetData()->isLittleEndian();

5
lib/CodeGen/MachOWriter.h
View File

@ -29,6 +29,7 @@ namespace llvm {
class MachineCodeEmitter;
class MachOCodeEmitter;
class OutputBuffer;
class raw_ostream;
/// MachOSym - This struct contains information about each symbol that is
/// added to logical symbol table for the module. This is eventually
@ -90,7 +91,7 @@ namespace llvm {
return *(MachineCodeEmitter*)MCE;
}
MachOWriter(std::ostream &O, TargetMachine &TM);
MachOWriter(raw_ostream &O, TargetMachine &TM);
virtual ~MachOWriter();
virtual const char *getPassName() const {
@ -101,7 +102,7 @@ namespace llvm {
protected:
/// Output stream to send the resultant object file to.
///
std::ostream &O;
raw_ostream &O;
/// Target machine description.
///

22
lib/Support/raw_ostream.cpp
View File

@ -19,15 +19,15 @@ using namespace llvm;
#if defined(_MSC_VER)
#include <io.h>
#ifndef STDIN_FILENO
# define STDIN_FILENO 0
#endif
#ifndef STDOUT_FILENO
# define STDOUT_FILENO 1
#endif
#ifndef STDERR_FILENO
# define STDERR_FILENO 2
#endif
#ifndef STDIN_FILENO
# define STDIN_FILENO 0
#endif
#ifndef STDOUT_FILENO
# define STDOUT_FILENO 1
#endif
#ifndef STDERR_FILENO
# define STDERR_FILENO 2
#endif
#endif
// An out of line virtual method to provide a home for the class vtable.
@ -82,14 +82,14 @@ void raw_stderr_ostream::handle() {}
/// outs() - This returns a reference to a raw_ostream for standard output.
/// Use it like: outs() << "foo" << "bar";
raw_ostream &outs() {
raw_ostream &llvm::outs() {
static raw_stdout_ostream S;
return S;
}
/// errs() - This returns a reference to a raw_ostream for standard error.
/// Use it like: errs() << "foo" << "bar";
raw_ostream &errs() {
raw_ostream &llvm::errs() {
static raw_stderr_ostream S;
return S;
}

3
lib/Target/ARM/ARM.h
View File

@ -23,6 +23,7 @@ namespace llvm {
class ARMTargetMachine;
class FunctionPass;
class MachineCodeEmitter;
class raw_ostream;
// Enums corresponding to ARM condition codes
namespace ARMCC {
@ -87,7 +88,7 @@ inline static const char *ARMCondCodeToString(ARMCC::CondCodes CC) {
}
FunctionPass *createARMISelDag(ARMTargetMachine &TM);
FunctionPass *createARMCodePrinterPass(std::ostream &O, ARMTargetMachine &TM);
FunctionPass *createARMCodePrinterPass(raw_ostream &O, ARMTargetMachine &TM);
FunctionPass *createARMCodeEmitterPass(ARMTargetMachine &TM,
MachineCodeEmitter &MCE);
FunctionPass *createARMLoadStoreOptimizationPass();

7
lib/Target/ARM/ARMTargetMachine.cpp
View File

@ -18,6 +18,7 @@
#include "llvm/PassManager.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachineRegistry.h"
#include "llvm/Target/TargetOptions.h"
using namespace llvm;
@ -143,7 +144,7 @@ bool ARMTargetMachine::addPreEmitPass(PassManagerBase &PM, bool Fast) {
}
bool ARMTargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
raw_ostream &Out) {
// Output assembly language.
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
@ -163,7 +164,7 @@ bool ARMTargetMachine::addCodeEmitter(PassManagerBase &PM, bool Fast,
if (DumpAsm) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(*cerr.stream(), *this));
PM.add(AsmPrinterCtor(errs(), *this));
}
return false;
@ -176,7 +177,7 @@ bool ARMTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,
if (DumpAsm) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(*cerr.stream(), *this));
PM.add(AsmPrinterCtor(errs(), *this));
}
return false;

4
lib/Target/ARM/ARMTargetMachine.h
View File

@ -38,7 +38,7 @@ class ARMTargetMachine : public LLVMTargetMachine {
protected:
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(std::ostream &o,
typedef FunctionPass *(*AsmPrinterCtorFn)(raw_ostream &o,
ARMTargetMachine &tm);
static AsmPrinterCtorFn AsmPrinterCtor;
@ -70,7 +70,7 @@ public:
virtual bool addInstSelector(PassManagerBase &PM, bool Fast);
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
virtual bool addCodeEmitter(PassManagerBase &PM, bool Fast,
bool DumpAsm, MachineCodeEmitter &MCE);
virtual bool addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,

9
lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp
View File

@ -35,6 +35,7 @@
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <cctype>
using namespace llvm;
@ -42,7 +43,7 @@ STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
struct VISIBILITY_HIDDEN ARMAsmPrinter : public AsmPrinter {
ARMAsmPrinter(std::ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
ARMAsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
: AsmPrinter(O, TM, T), DW(O, this, T), MMI(NULL), AFI(NULL),
InCPMode(false) {
Subtarget = &TM.getSubtarget<ARMSubtarget>();
@ -342,7 +343,7 @@ void ARMAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
}
}
static void printSOImm(std::ostream &O, int64_t V, const TargetAsmInfo *TAI) {
static void printSOImm(raw_ostream &O, int64_t V, const TargetAsmInfo *TAI) {
assert(V < (1 << 12) && "Not a valid so_imm value!");
unsigned Imm = ARM_AM::getSOImmValImm(V);
unsigned Rot = ARM_AM::getSOImmValRot(V);
@ -824,7 +825,7 @@ bool ARMAsmPrinter::doInitialization(Module &M) {
/// PrintUnmangledNameSafely - Print out the printable characters in the name.
/// Don't print things like \n or \0.
static void PrintUnmangledNameSafely(const Value *V, std::ostream &OS) {
static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
Name != E; ++Name)
if (isprint(*Name))
@ -1030,7 +1031,7 @@ bool ARMAsmPrinter::doFinalization(Module &M) {
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
///
FunctionPass *llvm::createARMCodePrinterPass(std::ostream &o,
FunctionPass *llvm::createARMCodePrinterPass(raw_ostream &o,
ARMTargetMachine &tm) {
return new ARMAsmPrinter(o, tm, tm.getTargetAsmInfo());
}

3
lib/Target/Alpha/Alpha.h
View File

@ -23,9 +23,10 @@ namespace llvm {
class FunctionPass;
class TargetMachine;
class MachineCodeEmitter;
class raw_ostream;
FunctionPass *createAlphaISelDag(AlphaTargetMachine &TM);
FunctionPass *createAlphaCodePrinterPass(std::ostream &OS,
FunctionPass *createAlphaCodePrinterPass(raw_ostream &OS,
TargetMachine &TM);
FunctionPass *createAlphaPatternInstructionSelector(TargetMachine &TM);
FunctionPass *createAlphaCodeEmitterPass(AlphaTargetMachine &TM,

5
lib/Target/Alpha/AlphaAsmPrinter.cpp
View File

@ -24,6 +24,7 @@
#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
@ -35,7 +36,7 @@ namespace {
/// Unique incrementer for label values for referencing Global values.
///
AlphaAsmPrinter(std::ostream &o, TargetMachine &tm, const TargetAsmInfo *T)
AlphaAsmPrinter(raw_ostream &o, TargetMachine &tm, const TargetAsmInfo *T)
: AsmPrinter(o, tm, T) {
}
@ -65,7 +66,7 @@ namespace {
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
///
FunctionPass *llvm::createAlphaCodePrinterPass(std::ostream &o,
FunctionPass *llvm::createAlphaCodePrinterPass(raw_ostream &o,
TargetMachine &tm) {
return new AlphaAsmPrinter(o, tm, tm.getTargetAsmInfo());
}

5
lib/Target/Alpha/AlphaTargetMachine.cpp
View File

@ -17,6 +17,7 @@
#include "llvm/Module.h"
#include "llvm/PassManager.h"
#include "llvm/Target/TargetMachineRegistry.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@ -78,7 +79,7 @@ bool AlphaTargetMachine::addPreEmitPass(PassManagerBase &PM, bool Fast) {
return false;
}
bool AlphaTargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
raw_ostream &Out) {
PM.add(createAlphaLLRPPass(*this));
PM.add(createAlphaCodePrinterPass(Out, *this));
return false;
@ -87,7 +88,7 @@ bool AlphaTargetMachine::addCodeEmitter(PassManagerBase &PM, bool Fast,
bool DumpAsm, MachineCodeEmitter &MCE) {
PM.add(createAlphaCodeEmitterPass(*this, MCE));
if (DumpAsm)
PM.add(createAlphaCodePrinterPass(*cerr.stream(), *this));
PM.add(createAlphaCodePrinterPass(errs(), *this));
return false;
}
bool AlphaTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM,

2
lib/Target/Alpha/AlphaTargetMachine.h
View File

@ -61,7 +61,7 @@ public:
virtual bool addInstSelector(PassManagerBase &PM, bool Fast);
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
virtual bool addCodeEmitter(PassManagerBase &PM, bool Fast,
bool DumpAsm, MachineCodeEmitter &MCE);
virtual bool addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,

202
lib/Target/CBackend/CBackend.cpp
View File

@ -39,6 +39,7 @@
#include "llvm/Support/InstVisitor.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/MathExtras.h"
@ -76,7 +77,7 @@ namespace {
/// CWriter - This class is the main chunk of code that converts an LLVM
/// module to a C translation unit.
class CWriter : public FunctionPass, public InstVisitor<CWriter> {
std::ostream &Out;
raw_ostream &Out;
IntrinsicLowering *IL;
Mangler *Mang;
LoopInfo *LI;
@ -90,7 +91,7 @@ namespace {
public:
static char ID;
explicit CWriter(std::ostream &o)
explicit CWriter(raw_ostream &o)
: FunctionPass((intptr_t)&ID), Out(o), IL(0), Mang(0), LI(0),
TheModule(0), TAsm(0), TD(0) {}
@ -126,16 +127,24 @@ namespace {
return false;
}
std::ostream &printType(std::ostream &Out, const Type *Ty,
raw_ostream &printType(raw_ostream &Out, const Type *Ty,
bool isSigned = false,
const std::string &VariableName = "",
bool IgnoreName = false,
const PAListPtr &PAL = PAListPtr());
std::ostream &printSimpleType(std::ostream &Out, const Type *Ty,
std::ostream &printType(std::ostream &Out, const Type *Ty,
bool isSigned = false,
const std::string &VariableName = "",
bool IgnoreName = false,
const PAListPtr &PAL = PAListPtr());
raw_ostream &printSimpleType(raw_ostream &Out, const Type *Ty,
bool isSigned,
const std::string &NameSoFar = "");
std::ostream &printSimpleType(std::ostream &Out, const Type *Ty,
bool isSigned,
const std::string &NameSoFar = "");
void printStructReturnPointerFunctionType(std::ostream &Out,
void printStructReturnPointerFunctionType(raw_ostream &Out,
const PAListPtr &PAL,
const PointerType *Ty);
@ -398,7 +407,7 @@ bool CBackendNameAllUsedStructsAndMergeFunctions::runOnModule(Module &M) {
/// printStructReturnPointerFunctionType - This is like printType for a struct
/// return type, except, instead of printing the type as void (*)(Struct*, ...)
/// print it as "Struct (*)(...)", for struct return functions.
void CWriter::printStructReturnPointerFunctionType(std::ostream &Out,
void CWriter::printStructReturnPointerFunctionType(raw_ostream &Out,
const PAListPtr &PAL,
const PointerType *TheTy) {
const FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
@ -433,6 +442,51 @@ void CWriter::printStructReturnPointerFunctionType(std::ostream &Out,
/*isSigned=*/PAL.paramHasAttr(0, ParamAttr::SExt), tstr);
}
raw_ostream &
CWriter::printSimpleType(raw_ostream &Out, const Type *Ty, bool isSigned,
const std::string &NameSoFar) {
assert((Ty->isPrimitiveType() || Ty->isInteger() || isa<VectorType>(Ty)) &&
"Invalid type for printSimpleType");
switch (Ty->getTypeID()) {
case Type::VoidTyID: return Out << "void " << NameSoFar;
case Type::IntegerTyID: {
unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
if (NumBits == 1)
return Out << "bool " << NameSoFar;
else if (NumBits <= 8)
return Out << (isSigned?"signed":"unsigned") << " char " << NameSoFar;
else if (NumBits <= 16)
return Out << (isSigned?"signed":"unsigned") << " short " << NameSoFar;
else if (NumBits <= 32)
return Out << (isSigned?"signed":"unsigned") << " int " << NameSoFar;
else if (NumBits <= 64)
return Out << (isSigned?"signed":"unsigned") << " long long "<< NameSoFar;
else {
assert(NumBits <= 128 && "Bit widths > 128 not implemented yet");
return Out << (isSigned?"llvmInt128":"llvmUInt128") << " " << NameSoFar;
}
}
case Type::FloatTyID: return Out << "float " << NameSoFar;
case Type::DoubleTyID: return Out << "double " << NameSoFar;
// Lacking emulation of FP80 on PPC, etc., we assume whichever of these is
// present matches host 'long double'.
case Type::X86_FP80TyID:
case Type::PPC_FP128TyID:
case Type::FP128TyID: return Out << "long double " << NameSoFar;
case Type::VectorTyID: {
const VectorType *VTy = cast<VectorType>(Ty);
return printSimpleType(Out, VTy->getElementType(), isSigned,
" __attribute__((vector_size(" +
utostr(TD->getABITypeSize(VTy)) + " ))) " + NameSoFar);
}
default:
cerr << "Unknown primitive type: " << *Ty << "\n";
abort();
}
}
std::ostream &
CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned,
const std::string &NameSoFar) {
@ -478,6 +532,111 @@ CWriter::printSimpleType(std::ostream &Out, const Type *Ty, bool isSigned,
}
}
// Pass the Type* and the variable name and this prints out the variable
// declaration.
//
raw_ostream &CWriter::printType(raw_ostream &Out, const Type *Ty,
bool isSigned, const std::string &NameSoFar,
bool IgnoreName, const PAListPtr &PAL) {
if (Ty->isPrimitiveType() || Ty->isInteger() || isa<VectorType>(Ty)) {
printSimpleType(Out, Ty, isSigned, NameSoFar);
return Out;
}
// Check to see if the type is named.
if (!IgnoreName || isa<OpaqueType>(Ty)) {
std::map<const Type *, std::string>::iterator I = TypeNames.find(Ty);
if (I != TypeNames.end()) return Out << I->second << ' ' << NameSoFar;
}
switch (Ty->getTypeID()) {
case Type::FunctionTyID: {
const FunctionType *FTy = cast<FunctionType>(Ty);
std::stringstream FunctionInnards;
FunctionInnards << " (" << NameSoFar << ") (";
unsigned Idx = 1;
for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I) {
const Type *ArgTy = *I;
if (PAL.paramHasAttr(Idx, ParamAttr::ByVal)) {
assert(isa<PointerType>(ArgTy));
ArgTy = cast<PointerType>(ArgTy)->getElementType();
}
if (I != FTy->param_begin())
FunctionInnards << ", ";
printType(FunctionInnards, ArgTy,
/*isSigned=*/PAL.paramHasAttr(Idx, ParamAttr::SExt), "");
++Idx;
}
if (FTy->isVarArg()) {
if (FTy->getNumParams())
FunctionInnards << ", ...";
} else if (!FTy->getNumParams()) {
FunctionInnards << "void";
}
FunctionInnards << ')';
std::string tstr = FunctionInnards.str();
printType(Out, FTy->getReturnType(),
/*isSigned=*/PAL.paramHasAttr(0, ParamAttr::SExt), tstr);
return Out;
}
case Type::StructTyID: {
const StructType *STy = cast<StructType>(Ty);
Out << NameSoFar + " {\n";
unsigned Idx = 0;
for (StructType::element_iterator I = STy->element_begin(),
E = STy->element_end(); I != E; ++I) {
Out << " ";
printType(Out, *I, false, "field" + utostr(Idx++));
Out << ";\n";
}
Out << '}';
if (STy->isPacked())
Out << " __attribute__ ((packed))";
return Out;
}
case Type::PointerTyID: {
const PointerType *PTy = cast<PointerType>(Ty);
std::string ptrName = "*" + NameSoFar;
if (isa<ArrayType>(PTy->getElementType()) ||
isa<VectorType>(PTy->getElementType()))
ptrName = "(" + ptrName + ")";
if (!PAL.isEmpty())
// Must be a function ptr cast!
return printType(Out, PTy->getElementType(), false, ptrName, true, PAL);
return printType(Out, PTy->getElementType(), false, ptrName);
}
case Type::ArrayTyID: {
const ArrayType *ATy = cast<ArrayType>(Ty);
unsigned NumElements = ATy->getNumElements();
if (NumElements == 0) NumElements = 1;
// Arrays are wrapped in structs to allow them to have normal
// value semantics (avoiding the array "decay").
Out << NameSoFar << " { ";
printType(Out, ATy->getElementType(), false,
"array[" + utostr(NumElements) + "]");
return Out << "; }";
}
case Type::OpaqueTyID: {
static int Count = 0;
std::string TyName = "struct opaque_" + itostr(Count++);
assert(TypeNames.find(Ty) == TypeNames.end());
TypeNames[Ty] = TyName;
return Out << TyName << ' ' << NameSoFar;
}
default:
assert(0 && "Unhandled case in getTypeProps!");
abort();
}
return Out;
}
// Pass the Type* and the variable name and this prints out the variable
// declaration.
//
@ -1427,7 +1586,7 @@ void CWriter::writeOperandWithCast(Value* Operand, const ICmpInst &Cmp) {
// generateCompilerSpecificCode - This is where we add conditional compilation
// directives to cater to specific compilers as need be.
//
static void generateCompilerSpecificCode(std::ostream& Out,
static void generateCompilerSpecificCode(raw_ostream& Out,
const TargetData *TD) {
// Alloca is hard to get, and we don't want to include stdlib.h here.
Out << "/* get a declaration for alloca */\n"
@ -1871,31 +2030,31 @@ void CWriter::printFloatingPointConstants(Function &F) {
double Val = FPC->getValueAPF().convertToDouble();
uint64_t i = FPC->getValueAPF().convertToAPInt().getZExtValue();
Out << "static const ConstantDoubleTy FPConstant" << FPCounter++
<< " = 0x" << std::hex << i << std::dec
<< " = 0x" << utohexstr(i)
<< "ULL; /* " << Val << " */\n";
} else if (FPC->getType() == Type::FloatTy) {
float Val = FPC->getValueAPF().convertToFloat();
uint32_t i = (uint32_t)FPC->getValueAPF().convertToAPInt().
getZExtValue();
Out << "static const ConstantFloatTy FPConstant" << FPCounter++
<< " = 0x" << std::hex << i << std::dec
<< " = 0x" << utohexstr(i)
<< "U; /* " << Val << " */\n";
} else if (FPC->getType() == Type::X86_FP80Ty) {
// api needed to prevent premature destruction
APInt api = FPC->getValueAPF().convertToAPInt();
const uint64_t *p = api.getRawData();
Out << "static const ConstantFP80Ty FPConstant" << FPCounter++
<< " = { 0x" << std::hex
<< ((uint16_t)p[1] | (p[0] & 0xffffffffffffLL)<<16)
<< "ULL, 0x" << (uint16_t)(p[0] >> 48) << ",{0,0,0}"
<< "}; /* Long double constant */\n" << std::dec;
<< " = { 0x"
<< utohexstr((uint16_t)p[1] | (p[0] & 0xffffffffffffLL)<<16)
<< "ULL, 0x" << utohexstr((uint16_t)(p[0] >> 48)) << ",{0,0,0}"
<< "}; /* Long double constant */\n";
} else if (FPC->getType() == Type::PPC_FP128Ty) {
APInt api = FPC->getValueAPF().convertToAPInt();
const uint64_t *p = api.getRawData();
Out << "static const ConstantFP128Ty FPConstant" << FPCounter++
<< " = { 0x" << std::hex
<< p[0] << ", 0x" << p[1]
<< "}; /* Long double constant */\n" << std::dec;
<< " = { 0x"
<< utohexstr(p[0]) << ", 0x" << utohexstr(p[1])
<< "}; /* Long double constant */\n";
} else
assert(0 && "Unknown float type!");
@ -2869,11 +3028,16 @@ bool CWriter::visitBuiltinCall(CallInst &I, Intrinsic::ID ID,
case Intrinsic::dbg_stoppoint: {
// If we use writeOperand directly we get a "u" suffix which is rejected
// by gcc.
std::stringstream SPIStr;
DbgStopPointInst &SPI = cast<DbgStopPointInst>(I);
SPI.getDirectory()->print(SPIStr);
Out << "\n#line "
<< SPI.getLine()
<< " \"" << SPI.getDirectory()
<< SPI.getFileName() << "\"\n";
<< " \"";
Out << SPIStr.str();
SPIStr.clear();
SPI.getFileName()->print(SPIStr);
Out << SPIStr.str() << "\"\n";
return true;
}
case Intrinsic::x86_sse_cmp_ss:
@ -3375,7 +3539,7 @@ void CWriter::visitExtractValueInst(ExtractValueInst &EVI) {
//===----------------------------------------------------------------------===//
bool CTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
std::ostream &o,
raw_ostream &o,
CodeGenFileType FileType,
bool Fast) {
if (FileType != TargetMachine::AssemblyFile) return true;

2
lib/Target/CBackend/CTargetMachine.h
View File

@ -26,7 +26,7 @@ struct CTargetMachine : public TargetMachine {
: DataLayout(&M) {}
virtual bool WantsWholeFile() const { return true; }
virtual bool addPassesToEmitWholeFile(PassManager &PM, std::ostream &Out,
virtual bool addPassesToEmitWholeFile(PassManager &PM, raw_ostream &Out,
CodeGenFileType FileType, bool Fast);
// This class always works, but shouldn't be the default in most cases.

3
lib/Target/CellSPU/SPU.h
View File

@ -20,9 +20,10 @@
namespace llvm {
class SPUTargetMachine;
class FunctionPass;
class raw_ostream;
FunctionPass *createSPUISelDag(SPUTargetMachine &TM);
FunctionPass *createSPUAsmPrinterPass(std::ostream &o, SPUTargetMachine &tm);
FunctionPass *createSPUAsmPrinterPass(raw_ostream &o, SPUTargetMachine &tm);
/*--== Utility functions/predicates/etc used all over the place: --==*/
//! Predicate test for a signed 10-bit value

7
lib/Target/CellSPU/SPUAsmPrinter.cpp
View File

@ -30,6 +30,7 @@
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
@ -47,7 +48,7 @@ namespace {
struct VISIBILITY_HIDDEN SPUAsmPrinter : public AsmPrinter {
std::set<std::string> FnStubs, GVStubs;
SPUAsmPrinter(std::ostream &O, TargetMachine &TM, const TargetAsmInfo *T) :
SPUAsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T) :
AsmPrinter(O, TM, T)
{
}
@ -275,7 +276,7 @@ namespace {
DwarfWriter DW;
MachineModuleInfo *MMI;
LinuxAsmPrinter(std::ostream &O, SPUTargetMachine &TM,
LinuxAsmPrinter(raw_ostream &O, SPUTargetMachine &TM,
const TargetAsmInfo *T) :
SPUAsmPrinter(O, TM, T),
DW(O, this, T),
@ -651,7 +652,7 @@ bool LinuxAsmPrinter::doFinalization(Module &M) {
/// assembly code for a MachineFunction to the given output stream, in a format
/// that the Linux SPU assembler can deal with.
///
FunctionPass *llvm::createSPUAsmPrinterPass(std::ostream &o,
FunctionPass *llvm::createSPUAsmPrinterPass(raw_ostream &o,
SPUTargetMachine &tm) {
return new LinuxAsmPrinter(o, tm, tm.getTargetAsmInfo());
}

2
lib/Target/CellSPU/SPUTargetMachine.cpp
View File

@ -79,7 +79,7 @@ SPUTargetMachine::addInstSelector(PassManagerBase &PM, bool Fast)
}
bool SPUTargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
raw_ostream &Out) {
PM.add(createSPUAsmPrinterPass(Out, *this));
return false;
}

2
lib/Target/CellSPU/SPUTargetMachine.h
View File

@ -85,7 +85,7 @@ public:
// Pass Pipeline Configuration
virtual bool addInstSelector(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
};
} // end namespace llvm

21
lib/Target/CppBackend/CPPBackend.cpp
View File

@ -29,6 +29,7 @@
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Streams.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Config/config.h"
#include <algorithm>
#include <set>
@ -86,7 +87,7 @@ namespace {
/// module to a C++ translation unit.
class CppWriter : public ModulePass {
const char* progname;
std::ostream &Out;
raw_ostream &Out;
const Module *TheModule;
uint64_t uniqueNum;
TypeMap TypeNames;
@ -101,7 +102,7 @@ namespace {
public:
static char ID;
explicit CppWriter(std::ostream &o) :
explicit CppWriter(raw_ostream &o) :
ModulePass((intptr_t)&ID), Out(o), uniqueNum(0), is_inline(false) {}
virtual const char *getPassName() const { return "C++ backend"; }
@ -154,7 +155,7 @@ namespace {
};
static unsigned indent_level = 0;
inline std::ostream& nl(std::ostream& Out, int delta = 0) {
inline raw_ostream& nl(raw_ostream& Out, int delta = 0) {
Out << "\n";
if (delta >= 0 || indent_level >= unsigned(-delta))
indent_level += delta;
@ -252,13 +253,13 @@ namespace {
else
Out << StrVal << "f";
} else if (CFP->getType() == Type::DoubleTy)
Out << "BitsToDouble(0x" << std::hex
<< CFP->getValueAPF().convertToAPInt().getZExtValue()
<< std::dec << "ULL) /* " << StrVal << " */";
Out << "BitsToDouble(0x"
<< utohexstr(CFP->getValueAPF().convertToAPInt().getZExtValue())
<< "ULL) /* " << StrVal << " */";
else
Out << "BitsToFloat(0x" << std::hex
<< (uint32_t)CFP->getValueAPF().convertToAPInt().getZExtValue()
<< std::dec << "U) /* " << StrVal << " */";
Out << "BitsToFloat(0x"
<< utohexstr((uint32_t)CFP->getValueAPF().convertToAPInt().getZExtValue())
<< "U) /* " << StrVal << " */";
Out << ")";
#if HAVE_PRINTF_A
}
@ -1982,7 +1983,7 @@ char CppWriter::ID = 0;
//===----------------------------------------------------------------------===//
bool CPPTargetMachine::addPassesToEmitWholeFile(PassManager &PM,
std::ostream &o,
raw_ostream &o,
CodeGenFileType FileType,
bool Fast) {
if (FileType != TargetMachine::AssemblyFile) return true;

4
lib/Target/CppBackend/CPPTargetMachine.h
View File

@ -19,6 +19,8 @@
namespace llvm {
class raw_ostream;
struct CPPTargetMachine : public TargetMachine {
const TargetData DataLayout; // Calculates type size & alignment
@ -26,7 +28,7 @@ struct CPPTargetMachine : public TargetMachine {
: DataLayout(&M) {}
virtual bool WantsWholeFile() const { return true; }
virtual bool addPassesToEmitWholeFile(PassManager &PM, std::ostream &Out,
virtual bool addPassesToEmitWholeFile(PassManager &PM, raw_ostream &Out,
CodeGenFileType FileType, bool Fast);
// This class always works, but shouldn't be the default in most cases.

3
lib/Target/IA64/IA64.h
View File

@ -20,6 +20,7 @@ namespace llvm {
class IA64TargetMachine;
class FunctionPass;
class raw_ostream;
/// createIA64DAGToDAGInstructionSelector - This pass converts an LLVM
/// function into IA64 machine code in a sane, DAG->DAG transform.
@ -36,7 +37,7 @@ FunctionPass *createIA64BundlingPass(IA64TargetMachine &TM);
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
///
FunctionPass *createIA64CodePrinterPass(std::ostream &o, IA64TargetMachine &tm);
FunctionPass *createIA64CodePrinterPass(raw_ostream &o, IA64TargetMachine &tm);
} // End llvm namespace

7
lib/Target/IA64/IA64AsmPrinter.cpp
View File

@ -26,6 +26,7 @@
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/Statistic.h"
using namespace llvm;
@ -35,7 +36,7 @@ namespace {
struct IA64AsmPrinter : public AsmPrinter {
std::set<std::string> ExternalFunctionNames, ExternalObjectNames;
IA64AsmPrinter(std::ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
IA64AsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
: AsmPrinter(O, TM, T) {
}
@ -336,7 +337,7 @@ void IA64AsmPrinter::printModuleLevelGV(const GlobalVariable* GVar) {
O << "\t.size " << name << ',' << Size << '\n';
}
O << name << ":\t\t\t\t// " << *C << '\n';
O << name << ":\n";
EmitGlobalConstant(C);
}
@ -370,7 +371,7 @@ bool IA64AsmPrinter::doFinalization(Module &M) {
/// assembly code for a MachineFunction to the given output stream, using
/// the given target machine description.
///
FunctionPass *llvm::createIA64CodePrinterPass(std::ostream &o,
FunctionPass *llvm::createIA64CodePrinterPass(raw_ostream &o,
IA64TargetMachine &tm) {
return new IA64AsmPrinter(o, tm, tm.getTargetAsmInfo());
}

2
lib/Target/IA64/IA64TargetMachine.cpp
View File

@ -82,7 +82,7 @@ bool IA64TargetMachine::addPreEmitPass(PassManagerBase &PM, bool Fast) {
return true;
}
bool IA64TargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
raw_ostream &Out) {
PM.add(createIA64CodePrinterPass(Out, *this));
return false;
}

2
lib/Target/IA64/IA64TargetMachine.h
View File

@ -51,7 +51,7 @@ public:
virtual bool addInstSelector(PassManagerBase &PM, bool Fast);
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
};
} // End llvm namespace

10
lib/Target/MSIL/MSILWriter.cpp
View File

@ -35,7 +35,7 @@ namespace {
: DataLayout(&M) {}
virtual bool WantsWholeFile() const { return true; }
virtual bool addPassesToEmitWholeFile(PassManager &PM, std::ostream &Out,
virtual bool addPassesToEmitWholeFile(PassManager &PM, raw_ostream &Out,
CodeGenFileType FileType, bool Fast);
// This class always works, but shouldn't be the default in most cases.
@ -1191,7 +1191,7 @@ void MSILWriter::printBasicBlock(const BasicBlock* BB) {
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) {
const Instruction* Inst = I;
// Comment llvm original instruction
Out << "\n//" << *Inst << "\n";
// Out << "\n//" << *Inst << "\n";
// Do not handle PHI instruction in current block
if (Inst->getOpcode()==Instruction::PHI) continue;
// Print instruction
@ -1367,8 +1367,8 @@ void MSILWriter::printStaticInitializerList() {
for (std::vector<StaticInitializer>::const_iterator I = InitList.begin(),
E = InitList.end(); I!=E; ++I) {
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(I->constant)) {
Out << "\n// Init " << getValueName(VarI->first) << ", offset " <<
utostr(I->offset) << ", type "<< *I->constant->getType() << "\n\n";
// Out << "\n// Init " << getValueName(VarI->first) << ", offset " <<
// utostr(I->offset) << ", type "<< *I->constant->getType() << "\n\n";
// Load variable address
printValueLoad(VarI->first);
// Add offset
@ -1648,7 +1648,7 @@ void MSILWriter::printExternals() {
// External Interface declaration
//===----------------------------------------------------------------------===//
bool MSILTarget::addPassesToEmitWholeFile(PassManager &PM, std::ostream &o,
bool MSILTarget::addPassesToEmitWholeFile(PassManager &PM, raw_ostream &o,
CodeGenFileType FileType, bool Fast)
{
if (FileType != TargetMachine::AssemblyFile) return true;

5
lib/Target/MSIL/MSILWriter.h
View File

@ -22,6 +22,7 @@
#include "llvm/Analysis/FindUsedTypes.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineRegistry.h"
@ -75,7 +76,7 @@ namespace {
}
public:
std::ostream &Out;
raw_ostream &Out;
Module* ModulePtr;
const TargetData* TD;
Mangler* Mang;
@ -85,7 +86,7 @@ namespace {
StaticInitList;
const std::set<const Type *>* UsedTypes;
static char ID;
MSILWriter(std::ostream &o) : FunctionPass((intptr_t)&ID), Out(o) {
MSILWriter(raw_ostream &o) : FunctionPass((intptr_t)&ID), Out(o) {
UniqID = 0;
}

3
lib/Target/Mips/Mips.h
View File

@ -21,10 +21,11 @@ namespace llvm {
class MipsTargetMachine;
class FunctionPass;
class MachineCodeEmitter;
class raw_ostream;
FunctionPass *createMipsISelDag(MipsTargetMachine &TM);
FunctionPass *createMipsDelaySlotFillerPass(MipsTargetMachine &TM);
FunctionPass *createMipsCodePrinterPass(std::ostream &OS,
FunctionPass *createMipsCodePrinterPass(raw_ostream &OS,
MipsTargetMachine &TM);
} // end namespace llvm;

10
lib/Target/Mips/MipsAsmPrinter.cpp
View File

@ -37,6 +37,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include <cctype>
using namespace llvm;
@ -48,7 +49,7 @@ namespace {
const MipsSubtarget *Subtarget;
MipsAsmPrinter(std::ostream &O, MipsTargetMachine &TM,
MipsAsmPrinter(raw_ostream &O, MipsTargetMachine &TM,
const TargetAsmInfo *T):
AsmPrinter(O, TM, T) {
Subtarget = &TM.getSubtarget<MipsSubtarget>();
@ -89,7 +90,7 @@ namespace {
/// assembly code for a MachineFunction to the given output stream,
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
FunctionPass *llvm::createMipsCodePrinterPass(std::ostream &o,
FunctionPass *llvm::createMipsCodePrinterPass(raw_ostream &o,
MipsTargetMachine &tm)
{
return new MipsAsmPrinter(o, tm, tm.getTargetAsmInfo());
@ -175,10 +176,9 @@ printSavedRegsBitmask(MachineFunction &MF)
void MipsAsmPrinter::
printHex32(unsigned int Value)
{
O << "0x" << std::hex;
O << "0x";
for (int i = 7; i >= 0; i--)
O << std::hex << ( (Value & (0xF << (i*4))) >> (i*4) );
O << std::dec;
O << utohexstr( (Value & (0xF << (i*4))) >> (i*4) );
}
//===----------------------------------------------------------------------===//

2
lib/Target/Mips/MipsTargetMachine.cpp
View File

@ -117,7 +117,7 @@ addPreEmitPass(PassManagerBase &PM, bool Fast)
// true if AssemblyEmitter is supported
bool MipsTargetMachine::
addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out)
raw_ostream &Out)
{
// Output assembly language.
PM.add(createMipsCodePrinterPass(Out, *this));

4
lib/Target/Mips/MipsTargetMachine.h
View File

@ -22,6 +22,8 @@
#include "llvm/Target/TargetFrameInfo.h"
namespace llvm {
class raw_ostream;
class MipsTargetMachine : public LLVMTargetMachine {
MipsSubtarget Subtarget;
const TargetData DataLayout; // Calculates type size & alignment
@ -58,7 +60,7 @@ namespace llvm {
virtual bool addInstSelector(PassManagerBase &PM, bool Fast);
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
};
/// MipselTargetMachine - Mipsel target machine.

3
lib/Target/PIC16/PIC16.h
View File

@ -22,9 +22,10 @@ namespace llvm {
class FunctionPassManager;
class FunctionPass;
class MachineCodeEmitter;
class raw_ostream;
FunctionPass *createPIC16ISelDag(PIC16TargetMachine &TM);
FunctionPass *createPIC16CodePrinterPass(std::ostream &OS,
FunctionPass *createPIC16CodePrinterPass(raw_ostream &OS,
PIC16TargetMachine &TM);
} // end namespace llvm;

7
lib/Target/PIC16/PIC16AsmPrinter.cpp
View File

@ -31,6 +31,7 @@
#include "llvm/Support/Debug.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
@ -43,7 +44,7 @@ STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
struct VISIBILITY_HIDDEN PIC16AsmPrinter : public AsmPrinter {
PIC16AsmPrinter(std::ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
PIC16AsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
: AsmPrinter(O, TM, T) {
}
@ -109,7 +110,7 @@ namespace {
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
///
FunctionPass *llvm::createPIC16CodePrinterPass(std::ostream &o,
FunctionPass *llvm::createPIC16CodePrinterPass(raw_ostream &o,
PIC16TargetMachine &tm) {
return new PIC16AsmPrinter(o, tm, tm.getTargetAsmInfo());
}
@ -275,7 +276,7 @@ printOperand(const MachineInstr *MI, int opNum, const char *Modifier)
}
static void
printSOImm(std::ostream &O, int64_t V, const TargetAsmInfo *TAI)
printSOImm(raw_ostream &O, int64_t V, const TargetAsmInfo *TAI)
{
assert(V < (1 << 12) && "Not a valid so_imm value!");

2
lib/Target/PIC16/PIC16TargetMachine.cpp
View File

@ -61,7 +61,7 @@ bool PIC16TargetMachine::addPreEmitPass(PassManagerBase &PM, bool Fast)
}
bool PIC16TargetMachine::
addAssemblyEmitter(PassManagerBase &PM, bool Fast, std::ostream &Out)
addAssemblyEmitter(PassManagerBase &PM, bool Fast, raw_ostream &Out)
{
// Output assembly language.
PM.add(createPIC16CodePrinterPass(Out, *this));

2
lib/Target/PIC16/PIC16TargetMachine.h
View File

@ -54,7 +54,7 @@ public:
virtual bool addPrologEpilogInserter(PassManagerBase &PM, bool Fast);
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
};
} // end namespace llvm

11
lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp
View File

@ -36,6 +36,7 @@
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
@ -52,7 +53,7 @@ namespace {
std::set<std::string> FnStubs, GVStubs;
const PPCSubtarget &Subtarget;
PPCAsmPrinter(std::ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
PPCAsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
: AsmPrinter(O, TM, T), Subtarget(TM.getSubtarget<PPCSubtarget>()) {
}
@ -295,7 +296,7 @@ namespace {
DwarfWriter DW;
MachineModuleInfo *MMI;
PPCLinuxAsmPrinter(std::ostream &O, PPCTargetMachine &TM,
PPCLinuxAsmPrinter(raw_ostream &O, PPCTargetMachine &TM,
const TargetAsmInfo *T)
: PPCAsmPrinter(O, TM, T), DW(O, this, T), MMI(0) {
}
@ -327,7 +328,7 @@ namespace {
DwarfWriter DW;
MachineModuleInfo *MMI;
PPCDarwinAsmPrinter(std::ostream &O, PPCTargetMachine &TM,
PPCDarwinAsmPrinter(raw_ostream &O, PPCTargetMachine &TM,
const TargetAsmInfo *T)
: PPCAsmPrinter(O, TM, T), DW(O, this, T), MMI(0) {
}
@ -649,7 +650,7 @@ bool PPCLinuxAsmPrinter::doInitialization(Module &M) {
/// PrintUnmangledNameSafely - Print out the printable characters in the name.
/// Don't print things like \n or \0.
static void PrintUnmangledNameSafely(const Value *V, std::ostream &OS) {
static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
Name != E; ++Name)
if (isprint(*Name))
@ -1107,7 +1108,7 @@ bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
/// for a MachineFunction to the given output stream, in a format that the
/// Darwin assembler can deal with.
///
FunctionPass *llvm::createPPCAsmPrinterPass(std::ostream &o,
FunctionPass *llvm::createPPCAsmPrinterPass(raw_ostream &o,
PPCTargetMachine &tm) {
const PPCSubtarget *Subtarget = &tm.getSubtarget<PPCSubtarget>();

3
lib/Target/PowerPC/PPC.h
View File

@ -25,10 +25,11 @@ namespace llvm {
class PPCTargetMachine;
class FunctionPass;
class MachineCodeEmitter;
class raw_ostream;
FunctionPass *createPPCBranchSelectionPass();
FunctionPass *createPPCISelDag(PPCTargetMachine &TM);
FunctionPass *createPPCAsmPrinterPass(std::ostream &OS,
FunctionPass *createPPCAsmPrinterPass(raw_ostream &OS,
PPCTargetMachine &TM);
FunctionPass *createPPCCodeEmitterPass(PPCTargetMachine &TM,
MachineCodeEmitter &MCE);

7
lib/Target/PowerPC/PPCTargetMachine.cpp
View File

@ -18,6 +18,7 @@
#include "llvm/PassManager.h"
#include "llvm/Target/TargetMachineRegistry.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
// Register the targets
@ -134,7 +135,7 @@ bool PPCTargetMachine::addPreEmitPass(PassManagerBase &PM, bool Fast) {
}
bool PPCTargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
raw_ostream &Out) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(Out, *this));
@ -167,7 +168,7 @@ bool PPCTargetMachine::addCodeEmitter(PassManagerBase &PM, bool Fast,
if (DumpAsm) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(*cerr.stream(), *this));
PM.add(AsmPrinterCtor(errs(), *this));
}
return false;
@ -180,7 +181,7 @@ bool PPCTargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,
if (DumpAsm) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(*cerr.stream(), *this));
PM.add(AsmPrinterCtor(errs(), *this));
}
return false;

4
lib/Target/PowerPC/PPCTargetMachine.h
View File

@ -44,7 +44,7 @@ protected:
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(std::ostream &o,
typedef FunctionPass *(*AsmPrinterCtorFn)(raw_ostream &o,
PPCTargetMachine &tm);
static AsmPrinterCtorFn AsmPrinterCtor;
@ -78,7 +78,7 @@ public:
virtual bool addInstSelector(PassManagerBase &PM, bool Fast);
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
virtual bool addCodeEmitter(PassManagerBase &PM, bool Fast,
bool DumpAsm, MachineCodeEmitter &MCE);
virtual bool addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,

3
lib/Target/Sparc/Sparc.h
View File

@ -21,9 +21,10 @@
namespace llvm {
class FunctionPass;
class TargetMachine;
class raw_ostream;
FunctionPass *createSparcISelDag(TargetMachine &TM);
FunctionPass *createSparcCodePrinterPass(std::ostream &OS, TargetMachine &TM);
FunctionPass *createSparcCodePrinterPass(raw_ostream &OS, TargetMachine &TM);
FunctionPass *createSparcDelaySlotFillerPass(TargetMachine &TM);
FunctionPass *createSparcFPMoverPass(TargetMachine &TM);
} // end namespace llvm;

5
lib/Target/Sparc/SparcAsmPrinter.cpp
View File

@ -26,6 +26,7 @@
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/CommandLine.h"
@ -39,7 +40,7 @@ STATISTIC(EmittedInsts, "Number of machine instrs printed");
namespace {
struct VISIBILITY_HIDDEN SparcAsmPrinter : public AsmPrinter {
SparcAsmPrinter(std::ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
SparcAsmPrinter(raw_ostream &O, TargetMachine &TM, const TargetAsmInfo *T)
: AsmPrinter(O, TM, T) {
}
@ -75,7 +76,7 @@ namespace {
/// using the given target machine description. This should work
/// regardless of whether the function is in SSA form.
///
FunctionPass *llvm::createSparcCodePrinterPass(std::ostream &o,
FunctionPass *llvm::createSparcCodePrinterPass(raw_ostream &o,
TargetMachine &tm) {
return new SparcAsmPrinter(o, tm, tm.getTargetAsmInfo());
}

2
lib/Target/Sparc/SparcTargetMachine.cpp
View File

@ -75,7 +75,7 @@ bool SparcTargetMachine::addPreEmitPass(PassManagerBase &PM, bool Fast) {
}
bool SparcTargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
raw_ostream &Out) {
// Output assembly language.
PM.add(createSparcCodePrinterPass(Out, *this));
return false;

2
lib/Target/Sparc/SparcTargetMachine.h
View File

@ -49,7 +49,7 @@ public:
virtual bool addInstSelector(PassManagerBase &PM, bool Fast);
virtual bool addPreEmitPass(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
};
} // end namespace llvm

3
lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.cpp
View File

@ -28,6 +28,7 @@
#include "llvm/ADT/StringExtras.h"
#include "llvm/CodeGen/MachineJumpTableInfo.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetOptions.h"
using namespace llvm;
@ -84,7 +85,7 @@ static X86MachineFunctionInfo calculateFunctionInfo(const Function *F,
/// PrintUnmangledNameSafely - Print out the printable characters in the name.
/// Don't print things like \n or \0.
static void PrintUnmangledNameSafely(const Value *V, std::ostream &OS) {
static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
Name != E; ++Name)
if (isprint(*Name))

2
lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.h
View File

@ -34,7 +34,7 @@ struct VISIBILITY_HIDDEN X86ATTAsmPrinter : public AsmPrinter {
const X86Subtarget *Subtarget;
X86ATTAsmPrinter(std::ostream &O, X86TargetMachine &TM,
X86ATTAsmPrinter(raw_ostream &O, X86TargetMachine &TM,
const TargetAsmInfo *T)
: AsmPrinter(O, TM, T), DW(O, this, T), MMI(0) {
Subtarget = &TM.getSubtarget<X86Subtarget>();

2
lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp
View File

@ -23,7 +23,7 @@ using namespace llvm;
/// for a MachineFunction to the given output stream, using the given target
/// machine description.
///
FunctionPass *llvm::createX86CodePrinterPass(std::ostream &o,
FunctionPass *llvm::createX86CodePrinterPass(raw_ostream &o,
X86TargetMachine &tm) {
const X86Subtarget *Subtarget = &tm.getSubtarget<X86Subtarget>();

3
lib/Target/X86/AsmPrinter/X86IntelAsmPrinter.h
View File

@ -20,11 +20,12 @@
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/raw_ostream.h"
namespace llvm {
struct VISIBILITY_HIDDEN X86IntelAsmPrinter : public AsmPrinter {
X86IntelAsmPrinter(std::ostream &O, X86TargetMachine &TM,
X86IntelAsmPrinter(raw_ostream &O, X86TargetMachine &TM,
const TargetAsmInfo *T)
: AsmPrinter(O, TM, T) {
}

3
lib/Target/X86/X86.h
View File

@ -22,6 +22,7 @@ namespace llvm {
class X86TargetMachine;
class FunctionPass;
class MachineCodeEmitter;
class raw_ostream;
/// createX86ISelDag - This pass converts a legalized DAG into a
/// X86-specific DAG, ready for instruction scheduling.
@ -38,7 +39,7 @@ FunctionPass *createX86FloatingPointStackifierPass();
/// assembly code for a MachineFunction to the given output stream,
/// using the given target machine description.
///
FunctionPass *createX86CodePrinterPass(std::ostream &o, X86TargetMachine &tm);
FunctionPass *createX86CodePrinterPass(raw_ostream &o, X86TargetMachine &tm);
/// createX86CodeEmitterPass - Return a pass that emits the collected X86 code
/// to the specified MCE object.

7
lib/Target/X86/X86TargetMachine.cpp
View File

@ -18,6 +18,7 @@
#include "llvm/PassManager.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Target/TargetMachineRegistry.h"
using namespace llvm;
@ -189,7 +190,7 @@ bool X86TargetMachine::addPostRegAlloc(PassManagerBase &PM, bool Fast) {
}
bool X86TargetMachine::addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out) {
raw_ostream &Out) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(Out, *this));
@ -218,7 +219,7 @@ bool X86TargetMachine::addCodeEmitter(PassManagerBase &PM, bool Fast,
if (DumpAsm) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(*cerr.stream(), *this));
PM.add(AsmPrinterCtor(errs(), *this));
}
return false;
@ -230,7 +231,7 @@ bool X86TargetMachine::addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,
if (DumpAsm) {
assert(AsmPrinterCtor && "AsmPrinter was not linked in");
if (AsmPrinterCtor)
PM.add(AsmPrinterCtor(*cerr.stream(), *this));
PM.add(AsmPrinterCtor(errs(), *this));
}
return false;

6
lib/Target/X86/X86TargetMachine.h
View File

@ -25,6 +25,8 @@
#include "X86ISelLowering.h"
namespace llvm {
class raw_ostream;
class X86TargetMachine : public LLVMTargetMachine {
X86Subtarget Subtarget;
@ -41,7 +43,7 @@ protected:
// To avoid having target depend on the asmprinter stuff libraries, asmprinter
// set this functions to ctor pointer at startup time if they are linked in.
typedef FunctionPass *(*AsmPrinterCtorFn)(std::ostream &o,
typedef FunctionPass *(*AsmPrinterCtorFn)(raw_ostream &o,
X86TargetMachine &tm);
static AsmPrinterCtorFn AsmPrinterCtor;
@ -75,7 +77,7 @@ public:
virtual bool addPreRegAlloc(PassManagerBase &PM, bool Fast);
virtual bool addPostRegAlloc(PassManagerBase &PM, bool Fast);
virtual bool addAssemblyEmitter(PassManagerBase &PM, bool Fast,
std::ostream &Out);
raw_ostream &Out);
virtual bool addCodeEmitter(PassManagerBase &PM, bool Fast,
bool DumpAsm, MachineCodeEmitter &MCE);
virtual bool addSimpleCodeEmitter(PassManagerBase &PM, bool Fast,

27
tools/llc/llc.cpp
View File

@ -31,6 +31,7 @@
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/PluginLoader.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Analysis/Verifier.h"
#include "llvm/System/Signals.h"
#include "llvm/Config/config.h"
@ -106,10 +107,10 @@ GetFileNameRoot(const std::string &InputFilename) {
return outputFilename;
}
static std::ostream *GetOutputStream(const char *ProgName) {
static raw_ostream *GetOutputStream(const char *ProgName) {
if (OutputFilename != "") {
if (OutputFilename == "-")
return &std::cout;
return &outs();
// Specified an output filename?
if (!Force && std::ifstream(OutputFilename.c_str())) {
@ -123,12 +124,13 @@ static std::ostream *GetOutputStream(const char *ProgName) {
// SIGINT
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
return new std::ofstream(OutputFilename.c_str());
std::string error;
return new raw_fd_ostream(OutputFilename.c_str(), error);
}
if (InputFilename == "-") {
OutputFilename = "-";
return &std::cout;
return &outs();
}
OutputFilename = GetFileNameRoot(InputFilename);
@ -165,9 +167,10 @@ static std::ostream *GetOutputStream(const char *ProgName) {
// SIGINT
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
std::ostream *Out = new std::ofstream(OutputFilename.c_str());
if (!Out->good()) {
std::cerr << ProgName << ": error opening " << OutputFilename << "!\n";
std::string error;
raw_ostream *Out = new raw_fd_ostream(OutputFilename.c_str(), error);
if (!error.empty()) {
std::cerr << error;
delete Out;
return 0;
}
@ -229,7 +232,7 @@ int main(int argc, char **argv) {
TargetMachine &Target = *target.get();
// Figure out where we are going to send the output...
std::ostream *Out = GetOutputStream(argv[0]);
raw_ostream *Out = GetOutputStream(argv[0]);
if (Out == 0) return 1;
// If this target requires addPassesToEmitWholeFile, do it now. This is
@ -244,7 +247,7 @@ int main(int argc, char **argv) {
if (Target.addPassesToEmitWholeFile(PM, *Out, FileType, Fast)) {
std::cerr << argv[0] << ": target does not support generation of this"
<< " file type!\n";
if (Out != &std::cout) delete Out;
if (Out != &outs()) delete Out;
// And the Out file is empty and useless, so remove it now.
sys::Path(OutputFilename).eraseFromDisk();
return 1;
@ -271,7 +274,7 @@ int main(int argc, char **argv) {
case FileModel::Error:
std::cerr << argv[0] << ": target does not support generation of this"
<< " file type!\n";
if (Out != &std::cout) delete Out;
if (Out != &outs()) delete Out;
// And the Out file is empty and useless, so remove it now.
sys::Path(OutputFilename).eraseFromDisk();
return 1;
@ -288,7 +291,7 @@ int main(int argc, char **argv) {
if (Target.addPassesToEmitFileFinish(Passes, MCE, Fast)) {
std::cerr << argv[0] << ": target does not support generation of this"
<< " file type!\n";
if (Out != &std::cout) delete Out;
if (Out != &outs()) delete Out;
// And the Out file is empty and useless, so remove it now.
sys::Path(OutputFilename).eraseFromDisk();
return 1;
@ -306,7 +309,7 @@ int main(int argc, char **argv) {
}
// Delete the ostream if it's not a stdout stream
if (Out != &std::cout) delete Out;
if (Out != &outs()) delete Out;
return 0;
}

13
tools/lto/LTOCodeGenerator.cpp
View File

@ -27,6 +27,7 @@
#include "llvm/Support/SystemUtils.h"
#include "llvm/Support/Mangler.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Signals.h"
#include "llvm/Analysis/Passes.h"
#include "llvm/Analysis/LoopPass.h"
@ -162,9 +163,12 @@ const void* LTOCodeGenerator::compile(size_t* length, std::string& errMsg)
sys::RemoveFileOnSignal(uniqueAsmPath);
// generate assembly code
std::ofstream asmFile(uniqueAsmPath.c_str());
bool genResult = this->generateAssemblyCode(asmFile, errMsg);
asmFile.close();
std::string error;
bool genResult = false;
{
raw_fd_ostream asmFile(uniqueAsmPath.c_str(), error);
genResult = this->generateAssemblyCode(asmFile, errMsg);
}
if ( genResult ) {
if ( uniqueAsmPath.exists() )
uniqueAsmPath.eraseFromDisk();
@ -309,7 +313,8 @@ void LTOCodeGenerator::applyScopeRestrictions()
}
/// Optimize merged modules using various IPO passes
bool LTOCodeGenerator::generateAssemblyCode(std::ostream& out, std::string& errMsg)
bool LTOCodeGenerator::generateAssemblyCode(raw_ostream& out,
std::string& errMsg)
{
if ( this->determineTarget(errMsg) )
return true;

6
tools/lto/LTOCodeGenerator.h
View File

@ -25,6 +25,8 @@
//
// C++ class which implements the opaque lto_code_gen_t
//
class llvm::raw_ostream;
class LTOCodeGenerator {
public:
static const char* getVersionString();
@ -41,8 +43,8 @@ public:
const void* compile(size_t* length, std::string& errMsg);
void setCodeGenDebugOptions(const char *opts);
private:
bool generateAssemblyCode(std::ostream& out,
std::string& errMsg);
bool generateAssemblyCode(llvm::raw_ostream& out,
std::string& errMsg);
bool assemble(const std::string& asmPath,
const std::string& objPath, std::string& errMsg);
void applyScopeRestrictions();