if (!Node->getName().empty())
return Node->getName().str();
- string_ostream OS;
+ std::string Str;
+ raw_string_ostream OS(Str);
+
Node->printAsOperand(OS, false);
return OS.str();
}
static std::string getCompleteNodeLabel(const BasicBlock *Node,
const Function *) {
enum { MaxColumns = 80 };
- string_ostream OS;
+ std::string Str;
+ raw_string_ostream OS(Str);
if (Node->getName().empty()) {
Node->printAsOperand(OS, false);
if (SuccNo == 0) return "def";
- string_ostream OS;
+ std::string Str;
+ raw_string_ostream OS(Str);
SwitchInst::ConstCaseIt Case =
SwitchInst::ConstCaseIt::fromSuccessorIndex(SI, SuccNo);
OS << Case.getCaseValue()->getValue();
class ObjectBufferStream : public ObjectBuffer {
void anchor() override;
public:
- ObjectBufferStream() {}
+ ObjectBufferStream() : OS(SV) {}
virtual ~ObjectBufferStream() {}
raw_ostream &getOStream() { return OS; }
void flush()
{
+ OS.flush();
+
// Make the data accessible via the ObjectBuffer::Buffer
- Buffer.reset(MemoryBuffer::getMemBuffer(OS.str(), "", false));
+ Buffer.reset(MemoryBuffer::getMemBuffer(StringRef(SV.data(), SV.size()),
+ "",
+ false));
}
protected:
- small_string_ostream<4096> OS; // Working buffer into which we JIT.
+ SmallVector<char, 4096> SV; // Working buffer into which we JIT.
+ raw_svector_ostream OS; // streaming wrapper
};
} // namespace llvm
O << "|" << DOT::EscapeString(NodeDesc);
}
- string_ostream EdgeSourceLabels;
+ std::string edgeSourceLabels;
+ raw_string_ostream EdgeSourceLabels(edgeSourceLabels);
bool hasEdgeSourceLabels = getEdgeSourceLabels(EdgeSourceLabels, Node);
if (hasEdgeSourceLabels) {
typename std::enable_if<has_ScalarTraits<T>::value,void>::type
yamlize(IO &io, T &Val, bool) {
if ( io.outputting() ) {
- llvm::string_ostream Buffer;
+ std::string Storage;
+ llvm::raw_string_ostream Buffer(Storage);
ScalarTraits<T>::output(Val, io.getContext(), Buffer);
StringRef Str = Buffer.str();
io.scalarString(Str, ScalarTraits<T>::mustQuote(Str));
#define LLVM_SUPPORT_RAW_OSTREAM_H
#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DataTypes.h"
namespace llvm {
class format_object_base;
+ template <typename T>
+ class SmallVectorImpl;
namespace sys {
namespace fs {
/// current_pos - Return the current position within the stream, not
/// counting the bytes currently in the buffer.
uint64_t current_pos() const override;
-
-protected:
- // This constructor is specified not to access \p O provided for storage as it
- // may not yet be initialized at construction time.
- explicit raw_svector_ostream(SmallVectorImpl<char> &O, std::nullptr_t)
- : OS(O){};
- void init();
-
public:
/// Construct a new raw_svector_ostream.
///
~raw_null_ostream();
};
-/// string_ostream - A raw_ostream that builds a string. This is a
-/// raw_svector_ostream with storage.
-template <unsigned InternalLen>
-class small_string_ostream : public raw_svector_ostream {
- SmallVector<char, InternalLen> Buffer;
- // There's no need to flush explicitly.
- using raw_svector_ostream::flush;
-
-public:
- small_string_ostream() : raw_svector_ostream(Buffer, nullptr) { init(); }
-
- void clear() {
- flush();
- Buffer.clear();
- }
-};
-
-typedef small_string_ostream<128> string_ostream;
-
} // end llvm namespace
#endif
void EmitString(raw_ostream &O) {
// Escape the string.
- small_string_ostream<256> Str;
- Str.write_escaped(AggregateString);
+ SmallString<256> Str;
+ raw_svector_ostream(Str).write_escaped(AggregateString);
AggregateString = Str.str();
O << " \"";
LLVMBool LLVMVerifyModule(LLVMModuleRef M, LLVMVerifierFailureAction Action,
char **OutMessages) {
raw_ostream *DebugOS = Action != LLVMReturnStatusAction ? &errs() : nullptr;
- string_ostream MsgsOS;
+ std::string Messages;
+ raw_string_ostream MsgsOS(Messages);
LLVMBool Result = verifyModule(*unwrap(M), OutMessages ? &MsgsOS : DebugOS);
if (Action == LLVMAbortProcessAction && Result)
report_fatal_error("Broken module found, compilation aborted!");
- if (OutMessages) {
- MsgsOS << '\0';
- *OutMessages = strdup(MsgsOS.str().data());
- }
+ if (OutMessages)
+ *OutMessages = strdup(MsgsOS.str().c_str());
return Result;
}
std::string getNodeLabel(const BasicBlock *Node,
const BlockFrequencyInfo *Graph) {
- string_ostream OS;
+ std::string Result;
+ raw_string_ostream OS(Result);
- OS << Node->getName() << ":";
+ OS << Node->getName().str() << ":";
switch (ViewBlockFreqPropagationDAG) {
case GVDT_Fraction:
Graph->printBlockFreq(OS, Node);
"never reach this point.");
}
- return OS.str();
+ return Result;
}
};
const DataLayout *DL;
TargetLibraryInfo *TLI;
- string_ostream MessagesStr;
+ std::string Messages;
+ raw_string_ostream MessagesStr;
static char ID; // Pass identification, replacement for typeid
- Lint() : FunctionPass(ID) {
+ Lint() : FunctionPass(ID), MessagesStr(Messages) {
initializeLintPass(*PassRegistry::getPassRegistry());
}
TLI = &getAnalysis<TargetLibraryInfo>();
visit(F);
dbgs() << MessagesStr.str();
- MessagesStr.clear();
+ Messages.clear();
return false;
}
using namespace llvm;
static std::string getTypeString(Type *T) {
- string_ostream Result;
- Result << *T;
- return Result.str();
+ std::string Result;
+ raw_string_ostream Tmp(Result);
+ Tmp << *T;
+ return Tmp.str();
}
/// Run: module ::= toplevelentity*
// Otherwise report the problem to the user.
{
- string_ostream OS;
+ std::string S;
+ raw_string_ostream OS(S);
OS << "Unsupported expression in static initializer: ";
CE->printAsOperand(OS, /*PrintType=*/false,
!AP.MF ? nullptr : AP.MF->getFunction()->getParent());
}
}
if (Error) {
- string_ostream Msg;
+ std::string msg;
+ raw_string_ostream Msg(msg);
Msg << "invalid operand in inline asm: '" << AsmStr << "'";
MMI->getModule()->getContext().emitError(LocCookie, Msg.str());
}
}
}
if (Error) {
- string_ostream Msg;
+ std::string msg;
+ raw_string_ostream Msg(msg);
Msg << "invalid operand in inline asm: '" << AsmStr << "'";
MMI->getModule()->getContext().emitError(LocCookie, Msg.str());
}
// Emit the inline asm to a temporary string so we can emit it through
// EmitInlineAsm.
- small_string_ostream<256> OS;
+ SmallString<256> StringData;
+ raw_svector_ostream OS(StringData);
// The variant of the current asmprinter.
int AsmPrinterVariant = MAI->getAssemblerDialect();
}
OS << Counter;
} else {
- string_ostream Msg;
+ std::string msg;
+ raw_string_ostream Msg(msg);
Msg << "Unknown special formatter '" << Code
<< "' for machine instr: " << *MI;
report_fatal_error(Msg.str());
std::string getNodeLabel(const MachineBasicBlock *Node,
const MachineBlockFrequencyInfo *Graph) {
- string_ostream OS;
+ std::string Result;
+ raw_string_ostream OS(Result);
- OS << Node->getName() << ":";
+ OS << Node->getName().str() << ":";
switch (ViewMachineBlockFreqPropagationDAG) {
case GVDT_Fraction:
Graph->printBlockFreq(OS, Node);
"never reach this point.");
}
- return OS.str();
+ return Result;
}
};
///
/// Only used by debug logging.
static std::string getBlockName(MachineBasicBlock *BB) {
- string_ostream OS;
+ std::string Result;
+ raw_string_ostream OS(Result);
OS << "BB#" << BB->getNumber()
<< " (derived from LLVM BB '" << BB->getName() << "')";
- return OS.str();
+ OS.flush();
+ return Result;
}
/// \brief Helper to print the number of a MBB.
///
/// Only used by debug logging.
static std::string getBlockNum(MachineBasicBlock *BB) {
- string_ostream OS;
+ std::string Result;
+ raw_string_ostream OS(Result);
OS << "BB#" << BB->getNumber();
- return OS.str();
+ OS.flush();
+ return Result;
}
#endif
const char *Prefix = isLinkerPrivate ? DL->getLinkerPrivateGlobalPrefix() :
DL->getPrivateGlobalPrefix();
- small_string_ostream<60> Name;
- Name << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
+ SmallString<60> Name;
+ raw_svector_ostream(Name)
+ << Prefix << "JTI" << getFunctionNumber() << '_' << JTI;
return Ctx.GetOrCreateSymbol(Name.str());
}
}
static std::string getNodeLabel(const SUnit *SU, const ScheduleDAG *G) {
- string_ostream SS;
+ std::string Str;
+ raw_string_ostream SS(Str);
const ScheduleDAGMI *DAG = static_cast<const ScheduleDAGMI*>(G);
const SchedDFSResult *DFS = DAG->hasVRegLiveness() ?
static_cast<const ScheduleDAGMILive*>(G)->getDFSResult() : nullptr;
}
std::string ScheduleDAGInstrs::getGraphNodeLabel(const SUnit *SU) const {
- string_ostream oss;
+ std::string s;
+ raw_string_ostream oss(s);
if (SU == &EntrySU)
oss << "<entry>";
else if (SU == &ExitSU)
void SelectionDAGISel::CannotYetSelect(SDNode *N) {
- string_ostream Msg;
+ std::string msg;
+ raw_string_ostream Msg(msg);
Msg << "Cannot select: ";
if (N->getOpcode() != ISD::INTRINSIC_W_CHAIN &&
}
std::string ScheduleDAGSDNodes::getGraphNodeLabel(const SUnit *SU) const {
- string_ostream O;
+ std::string s;
+ raw_string_ostream O(s);
O << "SU(" << SU->NodeNum << "): ";
if (SU->getNode()) {
SmallVector<SDNode *, 4> GluedNodes;
if (SCDesc->isValid() && !DefMI->getOperand(DefOperIdx).isImplicit()
&& !DefMI->getDesc().OpInfo[DefOperIdx].isOptionalDef()
&& SchedModel.isComplete()) {
- string_ostream Err;
- Err << "DefIdx " << DefIdx << " exceeds machine model writes for "
- << *DefMI;
- report_fatal_error(Err.str());
+ std::string Err;
+ raw_string_ostream ss(Err);
+ ss << "DefIdx " << DefIdx << " exceeds machine model writes for "
+ << *DefMI;
+ report_fatal_error(ss.str());
}
#endif
// FIXME: Automatically giving all implicit defs defaultDefLatency is
Entries.back()->parseInstructions(Data, &Offset, EndStructureOffset);
if (Offset != EndStructureOffset) {
- string_ostream Str;
- Str << format("Parsing entry instructions at %lx failed", StartOffset);
- report_fatal_error(Str.str());
+ std::string Str;
+ raw_string_ostream OS(Str);
+ OS << format("Parsing entry instructions at %lx failed", StartOffset);
+ report_fatal_error(Str);
}
}
}
/*===-- Error handling ----------------------------------------------------===*/
-static char *LLVMCreateMessage(string_ostream &OS) {
- OS << '\0';
- return strdup(OS.str().data());
-}
-
char *LLVMCreateMessage(const char *Message) {
return strdup(Message);
}
}
char *LLVMGetDiagInfoDescription(LLVMDiagnosticInfoRef DI) {
- string_ostream Msg;
- DiagnosticPrinterRawOStream DP(Msg);
+ std::string MsgStorage;
+ raw_string_ostream Stream(MsgStorage);
+ DiagnosticPrinterRawOStream DP(Stream);
+
unwrap(DI)->print(DP);
- return LLVMCreateMessage(Msg);
+ Stream.flush();
+
+ return LLVMCreateMessage(MsgStorage.c_str());
}
LLVMDiagnosticSeverity LLVMGetDiagInfoSeverity(LLVMDiagnosticInfoRef DI){
}
char *LLVMPrintModuleToString(LLVMModuleRef M) {
- string_ostream os;
+ std::string buf;
+ raw_string_ostream os(buf);
+
unwrap(M)->print(os, nullptr);
- return LLVMCreateMessage(os);
+ os.flush();
+
+ return strdup(buf.c_str());
}
/*--.. Operations on inline assembler ......................................--*/
}
char *LLVMPrintTypeToString(LLVMTypeRef Ty) {
- string_ostream os;
+ std::string buf;
+ raw_string_ostream os(buf);
if (unwrap(Ty))
unwrap(Ty)->print(os);
else
os << "Printing <null> Type";
- return LLVMCreateMessage(os);
+ os.flush();
+
+ return strdup(buf.c_str());
}
/*--.. Operations on integer types .........................................--*/
}
char* LLVMPrintValueToString(LLVMValueRef Val) {
- string_ostream os;
+ std::string buf;
+ raw_string_ostream os(buf);
if (unwrap(Val))
unwrap(Val)->print(os);
else
os << "Printing <null> Value";
- return LLVMCreateMessage(os);
+ os.flush();
+
+ return strdup(buf.c_str());
}
void LLVMReplaceAllUsesWith(LLVMValueRef OldVal, LLVMValueRef NewVal) {
}
std::string DataLayout::getStringRepresentation() const {
- string_ostream OS;
+ std::string Result;
+ raw_string_ostream OS(Result);
OS << (LittleEndian ? "e" : "E");
}
// Otherwise, print the message with a prefix based on the severity.
- string_ostream Msg;
- DiagnosticPrinterRawOStream DP(Msg);
+ std::string MsgStorage;
+ raw_string_ostream Stream(MsgStorage);
+ DiagnosticPrinterRawOStream DP(Stream);
DI.print(DP);
-
+ Stream.flush();
switch (DI.getSeverity()) {
case DS_Error:
- errs() << "error: " << Msg.str() << "\n";
+ errs() << "error: " << MsgStorage << "\n";
exit(1);
case DS_Warning:
- errs() << "warning: " << Msg.str() << "\n";
+ errs() << "warning: " << MsgStorage << "\n";
break;
case DS_Remark:
- errs() << "remark: " << Msg.str() << "\n";
+ errs() << "remark: " << MsgStorage << "\n";
break;
case DS_Note:
- errs() << "note: " << Msg.str() << "\n";
+ errs() << "note: " << MsgStorage << "\n";
break;
}
}
if(!*OutM) {
if (OutMessage) {
- string_ostream os;
+ std::string buf;
+ raw_string_ostream os(buf);
+
Diag.print(nullptr, os, false);
- os << '\0';
- *OutMessage = strdup(os.str().data());
+ os.flush();
+
+ *OutMessage = strdup(buf.c_str());
}
return 1;
}
break;
}
// Create the string that will be reported to the external diagnostic handler.
- string_ostream Msg;
- DiagnosticPrinterRawOStream DP(Msg);
+ std::string MsgStorage;
+ raw_string_ostream Stream(MsgStorage);
+ DiagnosticPrinterRawOStream DP(Stream);
DI.print(DP);
-
- // Null-terminate the C string.
- Msg << '\0';
+ Stream.flush();
// If this method has been called it means someone has set up an external
// diagnostic handler. Assert on that.
assert(DiagHandler && "Invalid diagnostic handler");
- (*DiagHandler)(Severity, Msg.str().data(), DiagContext);
+ (*DiagHandler)(Severity, MsgStorage.c_str(), DiagContext);
}
void
raw_ostream &OS = GetCommentOS();
SmallString<256> Code;
SmallVector<MCFixup, 4> Fixups;
- {
- raw_svector_ostream VecOS(Code);
- Emitter->EncodeInstruction(Inst, VecOS, Fixups, STI);
- }
+ raw_svector_ostream VecOS(Code);
+ Emitter->EncodeInstruction(Inst, VecOS, Fixups, STI);
+ VecOS.flush();
// If we are showing fixups, create symbolic markers in the encoded
// representation. We do this by making a per-bit map to the fixup item index,
}
MCSymbol *MCContext::CreateLinkerPrivateTempSymbol() {
- small_string_ostream<128> NameSV;
- NameSV << MAI->getLinkerPrivateGlobalPrefix() << "tmp" << NextUniqueID++;
- return CreateSymbol(NameSV.str());
+ SmallString<128> NameSV;
+ raw_svector_ostream(NameSV)
+ << MAI->getLinkerPrivateGlobalPrefix() << "tmp" << NextUniqueID++;
+ return CreateSymbol(NameSV);
}
MCSymbol *MCContext::CreateTempSymbol() {
- small_string_ostream<128> NameSV;
- NameSV << MAI->getPrivateGlobalPrefix() << "tmp" << NextUniqueID++;
- return CreateSymbol(NameSV.str());
+ SmallString<128> NameSV;
+ raw_svector_ostream(NameSV)
+ << MAI->getPrivateGlobalPrefix() << "tmp" << NextUniqueID++;
+ return CreateSymbol(NameSV);
}
unsigned MCContext::NextInstance(unsigned LocalLabelVal) {
const MCDisassembler *DisAsm = DC->getDisAsm();
MCInstPrinter *IP = DC->getIP();
MCDisassembler::DecodeStatus S;
- small_string_ostream<64> Annotations;
+ SmallVector<char, 64> InsnStr;
+ raw_svector_ostream Annotations(InsnStr);
S = DisAsm->getInstruction(Inst, Size, MemoryObject, PC,
/*REMOVE*/ nulls(), Annotations);
switch (S) {
return 0;
case MCDisassembler::Success: {
+ Annotations.flush();
+ StringRef AnnotationsStr = Annotations.str();
+
SmallVector<char, 64> InsnStr;
raw_svector_ostream OS(InsnStr);
formatted_raw_ostream FormattedOS(OS);
- IP->printInst(&Inst, FormattedOS, Annotations.str());
+ IP->printInst(&Inst, FormattedOS, AnnotationsStr);
if (DC->getOptions() & LLVMDisassembler_Option_PrintLatency)
emitLatency(DC, Inst);
void MCDwarfLineAddr::Emit(MCStreamer *MCOS, int64_t LineDelta,
uint64_t AddrDelta) {
MCContext &Context = MCOS->getContext();
- small_string_ostream<256> OS;
+ SmallString<256> Tmp;
+ raw_svector_ostream OS(Tmp);
MCDwarfLineAddr::Encode(Context, LineDelta, AddrDelta, OS);
MCOS->EmitBytes(OS.str());
}
void MCDwarfFrameEmitter::EmitAdvanceLoc(MCObjectStreamer &Streamer,
uint64_t AddrDelta) {
MCContext &Context = Streamer.getContext();
- small_string_ostream<256> OS;
+ SmallString<256> Tmp;
+ raw_svector_ostream OS(Tmp);
MCDwarfFrameEmitter::EncodeAdvanceLoc(Context, AddrDelta, OS);
Streamer.EmitBytes(OS.str());
}
}
// Build the IR assembly string.
- string_ostream OS;
+ std::string AsmStringIR;
+ raw_string_ostream OS(AsmStringIR);
const char *AsmStart = SrcMgr.getMemoryBuffer(0)->getBufferStart();
const char *AsmEnd = SrcMgr.getMemoryBuffer(0)->getBufferEnd();
array_pod_sort(AsmStrRewrites.begin(), AsmStrRewrites.end(), rewritesSort);
}
case AOK_DotOperator:
// Insert the dot if the user omitted it.
- if (OS.str().back() != '.')
+ OS.flush();
+ if (AsmStringIR.back() != '.')
OS << '.';
OS << AR.Val;
break;
static void printRelocationTargetName(const MachOObjectFile *O,
const MachO::any_relocation_info &RE,
- raw_ostream &fmt) {
+ raw_string_ostream &fmt) {
bool IsScattered = O->isRelocationScattered(RE);
// Target of a scattered relocation is an address. In the interest of
unsigned Arch = this->getArch();
- string_ostream fmt;
+ std::string fmtbuf;
+ raw_string_ostream fmt(fmtbuf);
unsigned Type = this->getAnyRelocationType(RE);
bool IsPCRel = this->getAnyRelocationPCRel(RE);
} else
printRelocationTargetName(this, RE, fmt);
- StringRef fmtbuf = fmt.str();
+ fmt.flush();
Result.append(fmtbuf.begin(), fmtbuf.end());
return object_error::success;
}
}
std::string Arg::getAsString(const ArgList &Args) const {
- small_string_ostream<256> OS;
+ SmallString<256> Res;
+ llvm::raw_svector_ostream OS(Res);
ArgStringList ASL;
render(Args, ASL);
break;
case Option::RenderCommaJoinedStyle: {
- small_string_ostream<256> OS;
+ SmallString<256> Res;
+ llvm::raw_svector_ostream OS(Res);
OS << getSpelling();
for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
if (i) OS << ',';
// printOptionDiff - Specializations for printing basic value types.
//
-#define PRINT_OPT_DIFF(T) \
- void parser<T>::printOptionDiff(const Option &O, T V, OptionValue<T> D, \
- size_t GlobalWidth) const { \
- printOptionName(O, GlobalWidth); \
- string_ostream SS; \
- SS << V; \
- outs() << "= " << SS.str(); \
- size_t NumSpaces = MaxOptWidth > SS.tell() ? MaxOptWidth - SS.tell() : 0; \
- outs().indent(NumSpaces) << " (default: "; \
- if (D.hasValue()) \
- outs() << D.getValue(); \
- else \
- outs() << "*no default*"; \
- outs() << ")\n"; \
- }
+#define PRINT_OPT_DIFF(T) \
+ void parser<T>:: \
+ printOptionDiff(const Option &O, T V, OptionValue<T> D, \
+ size_t GlobalWidth) const { \
+ printOptionName(O, GlobalWidth); \
+ std::string Str; \
+ { \
+ raw_string_ostream SS(Str); \
+ SS << V; \
+ } \
+ outs() << "= " << Str; \
+ size_t NumSpaces = MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0;\
+ outs().indent(NumSpaces) << " (default: "; \
+ if (D.hasValue()) \
+ outs() << D.getValue(); \
+ else \
+ outs() << "*no default*"; \
+ outs() << ")\n"; \
+ } \
PRINT_OPT_DIFF(bool)
PRINT_OPT_DIFF(boolOrDefault)
// and we only need to set the vector size when the data is flushed.
raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
- init();
-}
-
-void raw_svector_ostream::init() {
// Set up the initial external buffer. We make sure that the buffer has at
// least 128 bytes free; raw_ostream itself only requires 64, but we want to
// make sure that we don't grow the buffer unnecessarily on destruction (when
break;
else if (Step < 0 && From < To)
break;
- string_ostream Name;
- Name << format(Format.c_str(), unsigned(From));
- Record *Rec = Records.getDef(Name.str());
+ std::string Name;
+ raw_string_ostream OS(Name);
+ OS << format(Format.c_str(), unsigned(From));
+ Record *Rec = Records.getDef(OS.str());
if (!Rec)
- PrintFatalError(Loc, "No def named '" + Name.str() + "': " +
- Expr->getAsString());
+ PrintFatalError(Loc, "No def named '" + Name + "': " +
+ Expr->getAsString());
// Try to reevaluate Rec in case it is a set.
if (const RecVec *Result = ST.expand(Rec))
Elts.insert(Result->begin(), Result->end());
if (ItemType) {
ListRecTy *ListType = dyn_cast<ListRecTy>(ItemType);
if (!ListType) {
- string_ostream ss;
+ std::string s;
+ raw_string_ostream ss(s);
ss << "Type mismatch for list, expected list type, got "
<< ItemType->getAsString();
TokError(ss.str());
// Otherwise report the problem to the user.
{
- string_ostream OS;
+ std::string S;
+ raw_string_ostream OS(S);
OS << "Unsupported expression in static initializer: ";
CE->printAsOperand(OS, /*PrintType=*/ false,
!AP.MF ? nullptr : AP.MF->getFunction()->getParent());
LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T,
LLVMModuleRef M, LLVMCodeGenFileType codegen, char** ErrorMessage,
LLVMMemoryBufferRef *OutMemBuf) {
- string_ostream Code;
- formatted_raw_ostream Out(Code);
+ std::string CodeString;
+ raw_string_ostream OStream(CodeString);
+ formatted_raw_ostream Out(OStream);
bool Result = LLVMTargetMachineEmit(T, M, Out, codegen, ErrorMessage);
+ OStream.flush();
- StringRef Buffer = Code.str();
- *OutMemBuf = LLVMCreateMemoryBufferWithMemoryRangeCopy(Buffer.data(),
- Buffer.size(), "");
+ std::string &Data = OStream.str();
+ *OutMemBuf = LLVMCreateMemoryBufferWithMemoryRangeCopy(Data.c_str(),
+ Data.length(), "");
return Result;
}
if (Match3 == Match_Success) MatchChars[NumMatches++] = Suffixes[2];
if (Match4 == Match_Success) MatchChars[NumMatches++] = Suffixes[3];
- small_string_ostream<128> OS;
+ SmallString<126> Msg;
+ raw_svector_ostream OS(Msg);
OS << "ambiguous instructions require an explicit suffix (could be ";
for (unsigned i = 0; i != NumMatches; ++i) {
if (i != 0)
unsigned RelaxedOp = getRelaxedOpcode(Inst.getOpcode());
if (RelaxedOp == Inst.getOpcode()) {
- small_string_ostream<256> OS;
+ SmallString<256> Tmp;
+ raw_svector_ostream OS(Tmp);
Inst.dump_pretty(OS);
OS << "\n";
report_fatal_error("unexpected instruction to relax: " + OS.str());
}
void X86AsmPrinter::GenerateExportDirective(const MCSymbol *Sym, bool IsData) {
- small_string_ostream<128> OS;
+ SmallString<128> Directive;
+ raw_svector_ostream OS(Directive);
StringRef Name = Sym->getName();
if (Subtarget->isTargetKnownWindowsMSVC())
OS << ",data";
}
- OutStreamer.EmitBytes(OS.str());
+ OS.flush();
+ OutStreamer.EmitBytes(Directive);
}
void X86AsmPrinter::EmitEndOfAsmFile(Module &M) {
}
void XCoreAsmPrinter::EmitInstruction(const MachineInstr *MI) {
- small_string_ostream<128> O;
+ SmallString<128> Str;
+ raw_svector_ostream O(Str);
switch (MI->getOpcode()) {
case XCore::DBG_VALUE:
}
std::string getTypeName(Type *T) {
- string_ostream OS;
+ std::string TypeName;
+ raw_string_ostream TypeStream(TypeName);
if (T)
- T->print(OS);
+ T->print(TypeStream);
else
- OS << "Printing <null> Type";
- return OS.str();
+ TypeStream << "Printing <null> Type";
+ TypeStream.flush();
+ return TypeName;
}
/// Returns the MDNode that represents type T if it is already created, or 0
}
ReturnBlock = new GCOVBlock(i++, os);
- string_ostream FnNameLine;
- FnNameLine << getFunctionName(SP) << SP.getLineNumber();
- FuncChecksum = hash_value(FnNameLine.str());
+ std::string FunctionNameAndLine;
+ raw_string_ostream FNLOS(FunctionNameAndLine);
+ FNLOS << getFunctionName(SP) << SP.getLineNumber();
+ FNLOS.flush();
+ FuncChecksum = hash_value(FunctionNameAndLine);
}
~GCOVFunction() {
}
std::string getEdgeDestinations() {
- string_ostream EdgeDestinations;
+ std::string EdgeDestinations;
+ raw_string_ostream EDOS(EdgeDestinations);
Function *F = Blocks.begin()->first->getParent();
for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) {
GCOVBlock &Block = *Blocks[I];
for (int i = 0, e = Block.OutEdges.size(); i != e; ++i)
- EdgeDestinations << Block.OutEdges[i]->Number;
+ EDOS << Block.OutEdges[i]->Number;
}
- return EdgeDestinations.str();
+ return EdgeDestinations;
}
uint32_t getFuncChecksum() {
if (PoisonStack && MS.TrackOrigins) {
setOrigin(&I, getCleanOrigin());
- small_string_ostream<2048> StackDescription;
+ SmallString<2048> StackDescriptionStorage;
+ raw_svector_ostream StackDescription(StackDescriptionStorage);
// We create a string with a description of the stack allocation and
// pass it into __msan_set_alloca_origin.
// It will be printed by the run-time if stack-originated UMR is found.
// of line at the module level and to provide a very simple format
// encoding the information herein. Both of these makes it simpler to
// parse the annotations by a simple external program.
- string_ostream os;
+ std::string Str;
+ raw_string_ostream os(Str);
os << "(" << Inst->getParent()->getParent()->getName() << ",%"
<< Inst->getName() << ")";
Hash = cast<MDString>(Node->getOperand(0));
}
} else if (Argument *Arg = dyn_cast<Argument>(Ptr)) {
- string_ostream os;
+ std::string str;
+ raw_string_ostream os(str);
os << "(" << Arg->getParent()->getName() << ",%" << Arg->getName()
<< ")";
Hash = MDString::get(Arg->getContext(), os.str());
}
static std::string SequenceToString(Sequence A) {
- string_ostream os;
+ std::string str;
+ raw_string_ostream os(str);
os << A;
return os.str();
}
Vars[i].Alignment = std::max(Vars[i].Alignment, kMinAlignment);
std::stable_sort(Vars.begin(), Vars.end(), CompareVars);
- small_string_ostream<2048> StackDescription;
+ SmallString<2048> StackDescriptionStorage;
+ raw_svector_ostream StackDescription(StackDescriptionStorage);
StackDescription << NumVars;
Layout->FrameAlignment = std::max(Granularity, Vars[0].Alignment);
SmallVector<uint8_t, 64> &SB(Layout->ShadowBytes);
/// Optimization analysis message produced during vectorization. Messages inform
/// the user why vectorization did not occur.
class Report {
- string_ostream Message;
+ std::string Message;
+ raw_string_ostream Out;
Instruction *Instr;
public:
- Report(Instruction *I = nullptr) : Instr(I) {
- Message << "loop not vectorized: ";
+ Report(Instruction *I = nullptr) : Out(Message), Instr(I) {
+ Out << "loop not vectorized: ";
}
template <typename A> Report &operator<<(const A &Value) {
- Message << Value;
+ Out << Value;
return *this;
}
Instruction *getInstr() { return Instr; }
- StringRef str() { return Message.str(); }
- operator Twine() { return Message.str(); }
+ std::string &str() { return Out.str(); }
+ operator Twine() { return Out.str(); }
};
/// InnerLoopVectorizer vectorizes loops which contain only one basic
#ifndef NDEBUG
/// \return string containing a file name and a line # for the given loop.
static std::string getDebugLocString(const Loop *L) {
- if (!L)
- return std::string();
-
- string_ostream OS;
- const DebugLoc LoopDbgLoc = L->getStartLoc();
- if (!LoopDbgLoc.isUnknown())
- LoopDbgLoc.print(L->getHeader()->getContext(), OS);
- else
- // Just print the module name.
- OS << L->getHeader()->getParent()->getParent()->getModuleIdentifier();
- return OS.str();
+ std::string Result;
+ if (L) {
+ raw_string_ostream OS(Result);
+ const DebugLoc LoopDbgLoc = L->getStartLoc();
+ if (!LoopDbgLoc.isUnknown())
+ LoopDbgLoc.print(L->getHeader()->getContext(), OS);
+ else
+ // Just print the module name.
+ OS << L->getHeader()->getParent()->getParent()->getModuleIdentifier();
+ OS.flush();
+ }
+ return Result;
}
#endif
std::vector<std::pair<unsigned, unsigned>> &MemberOffsetRefs) {
unsigned StartOffset = 0;
unsigned MemberNum = 0;
- string_ostream NameOS;
+ std::string NameBuf;
+ raw_string_ostream NameOS(NameBuf);
unsigned NumSyms = 0;
LLVMContext &Context = getGlobalContext();
for (ArrayRef<NewArchiveIterator>::iterator I = Members.begin(),
Out << "<o>";
// Escape special chars and print the instruction in mnemonic form.
- string_ostream OS;
+ std::string Str;
+ raw_string_ostream OS(Str);
IP->printInst(&(*i)->getInsts()->at(ii).Inst, OS, "");
Out << DOT::EscapeString(OS.str());
}
if (Symbols.empty())
Symbols.push_back(std::make_pair(0, name));
- small_string_ostream<40> Comments;
+
+ SmallString<40> Comments;
+ raw_svector_ostream CommentStream(Comments);
StringRef Bytes;
if (error(Section.getContents(Bytes)))
MCInst Inst;
if (DisAsm->getInstruction(Inst, Size, memoryObject,
- SectionAddr + Index, DebugOut, Comments)) {
+ SectionAddr + Index,
+ DebugOut, CommentStream)) {
outs() << format("%8" PRIx64 ":", SectionAddr + Index);
if (!NoShowRawInsn) {
outs() << "\t";
DumpBytes(StringRef(Bytes.data() + Index, Size));
}
IP->printInst(&Inst, outs(), "");
- outs() << Comments.str();
+ outs() << CommentStream.str();
Comments.clear();
outs() << "\n";
} else {
static std::string formatSymbol(StringRef Name, uint64_t Address,
uint64_t Offset = 0) {
- string_ostream OS;
+ std::string Buffer;
+ raw_string_ostream OS(Buffer);
if (!Name.empty())
OS << Name << " ";
static std::string formatSymbol(const Dumper::Context &Ctx,
const coff_section *Section, uint64_t Offset,
uint32_t Displacement) {
- string_ostream OS;
+ std::string Buffer;
+ raw_string_ostream OS(Buffer);
StringRef Name;
SymbolRef Symbol;
OS << format(" +0x%X (0x%" PRIX64 ")", Displacement, Offset);
else
OS << format(" (0x%" PRIX64 ")", Offset);
-
return OS.str();
}
}
std::string DumpFunction(const Function *F) {
- string_ostream Result;
- Result << "" << *F;
- return Result.str();
+ std::string Result;
+ raw_string_ostream(Result) << "" << *F;
+ return Result;
}
class RecordingJITMemoryManager : public JITMemoryManager {
SMDiagnostic Error;
bool success =
nullptr != ParseAssemblyString(assembly, M, Error, M->getContext());
- string_ostream errMsg;
- Error.print("", errMsg);
- EXPECT_TRUE(success) << errMsg.str();
+ std::string errMsg;
+ raw_string_ostream os(errMsg);
+ Error.print("", os);
+ EXPECT_TRUE(success) << os.str();
return success;
}
// variable values.
if (!VariableUses.empty()) {
for (unsigned i = 0, e = VariableUses.size(); i != e; ++i) {
- small_string_ostream<256> OS;
+ SmallString<256> Msg;
+ raw_svector_ostream OS(Msg);
StringRef Var = VariableUses[i].first;
if (Var[0] == '@') {
std::string Value;
// Default case: unhandled opcode
o << " default:\n"
- << " string_ostream Msg;\n"
+ << " std::string msg;\n"
+ << " raw_string_ostream Msg(msg);\n"
<< " Msg << \"Not supported instr: \" << MI;\n"
<< " report_fatal_error(Msg.str());\n"
<< " }\n"
}
static std::string createJSONText(size_t MemoryMB, unsigned ValueSize) {
- llvm::string_ostream OS;
- OS << "[\n";
+ std::string JSONText;
+ llvm::raw_string_ostream Stream(JSONText);
+ Stream << "[\n";
size_t MemoryBytes = MemoryMB * 1024 * 1024;
- while (OS.tell() < MemoryBytes) {
- OS << " {\n"
- << " \"key1\": \"" << std::string(ValueSize, '*') << "\",\n"
- << " \"key2\": \"" << std::string(ValueSize, '*') << "\",\n"
- << " \"key3\": \"" << std::string(ValueSize, '*') << "\"\n"
- << " }";
- if (OS.tell() < MemoryBytes)
- OS << ",";
- OS << "\n";
+ while (JSONText.size() < MemoryBytes) {
+ Stream << " {\n"
+ << " \"key1\": \"" << std::string(ValueSize, '*') << "\",\n"
+ << " \"key2\": \"" << std::string(ValueSize, '*') << "\",\n"
+ << " \"key3\": \"" << std::string(ValueSize, '*') << "\"\n"
+ << " }";
+ Stream.flush();
+ if (JSONText.size() < MemoryBytes) Stream << ",";
+ Stream << "\n";
}
- OS << "]\n";
- return OS.str();
+ Stream << "]\n";
+ Stream.flush();
+ return JSONText;
}
int main(int argc, char **argv) {
projects / oota-llvm.git / commitdiff