bool FixItRewriter::WriteFixedFile(FileID ID, llvm::raw_ostream &OS) { const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(ID); if (!RewriteBuf) return true; RewriteBuf->write(OS); OS.flush(); return false; }
bool FixItRewriter::WriteFixedFile(FileID ID, llvm::raw_ostream &OS) { const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(ID); if (!RewriteBuf) return true; OS << std::string(RewriteBuf->begin(), RewriteBuf->end()); OS.flush(); return false; }
// This function exits the program. void printVersion(llvm::raw_ostream &OS) { OS << "LDC - the LLVM D compiler (" << global.ldc_version << "):\n"; OS << " based on DMD " << global.version << " and LLVM " << global.llvm_version << "\n"; OS << " built with " << ldc::built_with_Dcompiler_version << "\n"; #if defined(__has_feature) #if __has_feature(address_sanitizer) OS << " compiled with address sanitizer enabled\n"; #endif #endif OS << " Default target: " << llvm::sys::getDefaultTargetTriple() << "\n"; std::string CPU = llvm::sys::getHostCPUName(); if (CPU == "generic") { CPU = "(unknown)"; } OS << " Host CPU: " << CPU << "\n"; OS << " http://dlang.org - http://wiki.dlang.org/LDC\n"; OS << "\n"; // Without explicitly flushing here, only the target list is visible when // redirecting stdout to a file. OS.flush(); llvm::TargetRegistry::printRegisteredTargetsForVersion( #if LDC_LLVM_VER >= 600 OS #endif ); exit(EXIT_SUCCESS); }
void ClangInternalState::printAST(llvm::raw_ostream& Out, ASTContext& C) { TranslationUnitDecl* TU = C.getTranslationUnitDecl(); unsigned Indentation = 0; bool PrintInstantiation = false; std::string ErrMsg; clang::PrintingPolicy policy = C.getPrintingPolicy(); TU->print(Out, policy, Indentation, PrintInstantiation); // TODO: For future when we relpace the bump allocation with slab. // //Out << "Allocated memory: " << C.getAllocatedMemory(); //Out << "Side table allocated memory: " << C.getSideTableAllocatedMemory(); Out.flush(); }
void OptTable::PrintHelp(llvm::raw_ostream &OS, const char *Name, const char *Title, bool ShowHidden) const { OS << "OVERVIEW: " << Title << "\n"; OS << '\n'; OS << "USAGE: " << Name << " [options] <inputs>\n"; OS << '\n'; // Render help text into a map of group-name to a list of (option, help) // pairs. typedef std::map<std::string, std::vector<std::pair<std::string, const char*> > > helpmap_ty; helpmap_ty GroupedOptionHelp; for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { unsigned Id = i + 1; // FIXME: Split out option groups. if (getOptionKind(Id) == Option::GroupClass) continue; if (!ShowHidden && isOptionHelpHidden(Id)) continue; if (const char *Text = getOptionHelpText(Id)) { const char *HelpGroup = getOptionHelpGroup(*this, Id); const std::string &OptName = getOptionHelpName(*this, Id); GroupedOptionHelp[HelpGroup].push_back(std::make_pair(OptName, Text)); } } for (helpmap_ty::iterator it = GroupedOptionHelp .begin(), ie = GroupedOptionHelp.end(); it != ie; ++it) { if (it != GroupedOptionHelp .begin()) OS << "\n"; PrintHelpOptionList(OS, it->first, it->second); } OS.flush(); }
void ClangInternalState::printMacroDefinitions(llvm::raw_ostream& Out, const clang::Preprocessor& PP) { stdstrstream contentsOS; PP.printMacros(contentsOS); Out << "Ordered Alphabetically:\n"; std::vector<std::string> elems; { // Split the string into lines. char delim = '\n'; std::stringstream ss(contentsOS.str()); std::string item; while (std::getline(ss, item, delim)) { elems.push_back(item); } // Sort them alphabetically std::sort(elems.begin(), elems.end()); } for(std::vector<std::string>::iterator I = elems.begin(), E = elems.end(); I != E; ++I) Out << *I << '\n'; Out.flush(); }
static void printProfileData(const ProfileData &Profile, llvm::raw_ostream &OS) { // Time is first to allow for sorting by it. std::vector<std::pair<llvm::TimeRecord, StringRef>> Timers; TimeRecord Total; for (const auto& P : Profile.Records) { Timers.emplace_back(P.getValue(), P.getKey()); Total += P.getValue(); } std::sort(Timers.begin(), Timers.end()); std::string Line = "===" + std::string(73, '-') + "===\n"; OS << Line; if (Total.getUserTime()) OS << " ---User Time---"; if (Total.getSystemTime()) OS << " --System Time--"; if (Total.getProcessTime()) OS << " --User+System--"; OS << " ---Wall Time---"; if (Total.getMemUsed()) OS << " ---Mem---"; OS << " --- Name ---\n"; // Loop through all of the timing data, printing it out. for (auto I = Timers.rbegin(), E = Timers.rend(); I != E; ++I) { I->first.print(Total, OS); OS << I->second << '\n'; } Total.print(Total, OS); OS << "Total\n"; OS << Line << "\n"; OS.flush(); }
void swift::markup::printInlinesUnder(const MarkupASTNode *Node, llvm::raw_ostream &OS, bool PrintDecorators) { auto printChildren = [](const ArrayRef<const MarkupASTNode *> Children, llvm::raw_ostream &OS) { for (auto Child = Children.begin(); Child != Children.end(); Child++) swift::markup::printInlinesUnder(*Child, OS); }; switch (Node->getKind()) { case swift::markup::ASTNodeKind::HTML: { auto H = cast<HTML>(Node); OS << H->getLiteralContent(); break; } case swift::markup::ASTNodeKind::InlineHTML: { auto IH = cast<InlineHTML>(Node); OS << IH->getLiteralContent(); break; } case swift::markup::ASTNodeKind::HRule: OS << '\n'; break; case swift::markup::ASTNodeKind::Text: { auto T = cast<Text>(Node); OS << T->getLiteralContent(); break; } case swift::markup::ASTNodeKind::SoftBreak: OS << ' '; break; case swift::markup::ASTNodeKind::LineBreak: OS << '\n'; break; case swift::markup::ASTNodeKind::Code: { auto C = cast<Code>(Node); if (PrintDecorators) OS << '`'; OS << C->getLiteralContent(); if (PrintDecorators) OS << '`'; break; } case swift::markup::ASTNodeKind::CodeBlock: { auto CB = cast<CodeBlock>(Node); if (PrintDecorators) OS << "``"; OS << CB->getLiteralContent(); if (PrintDecorators) OS << "``"; break; } case swift::markup::ASTNodeKind::Emphasis: { auto E = cast<Emphasis>(Node); if (PrintDecorators) OS << '*'; printChildren(E->getChildren(), OS); if (PrintDecorators) OS << '*'; break; } case swift::markup::ASTNodeKind::Strong: { auto S = cast<Strong>(Node); if (PrintDecorators) OS << "**"; printChildren(S->getChildren(), OS); if (PrintDecorators) OS << "**"; break; } default: printChildren(Node->getChildren(), OS); } OS.flush(); }
/* * Disassemble a function, using the LLVM MC disassembler. * * See also: * - http://blog.llvm.org/2010/01/x86-disassembler.html * - http://blog.llvm.org/2010/04/intro-to-llvm-mc-project.html */ static size_t disassemble(const void* func, llvm::raw_ostream & Out) { using namespace llvm; const uint8_t *bytes = (const uint8_t *)func; /* * Limit disassembly to this extent */ const uint64_t extent = 96 * 1024; uint64_t max_pc = 0; /* * Initialize all used objects. */ std::string Triple = sys::getDefaultTargetTriple(); std::string Error; const Target *T = TargetRegistry::lookupTarget(Triple, Error); #if HAVE_LLVM >= 0x0304 OwningPtr<const MCAsmInfo> AsmInfo(T->createMCAsmInfo(*T->createMCRegInfo(Triple), Triple)); #else OwningPtr<const MCAsmInfo> AsmInfo(T->createMCAsmInfo(Triple)); #endif if (!AsmInfo) { Out << "error: no assembly info for target " << Triple << "\n"; Out.flush(); return 0; } unsigned int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); OwningPtr<const MCRegisterInfo> MRI(T->createMCRegInfo(Triple)); if (!MRI) { Out << "error: no register info for target " << Triple.c_str() << "\n"; Out.flush(); return 0; } OwningPtr<const MCInstrInfo> MII(T->createMCInstrInfo()); if (!MII) { Out << "error: no instruction info for target " << Triple.c_str() << "\n"; Out.flush(); return 0; } #if HAVE_LLVM >= 0x0305 OwningPtr<const MCSubtargetInfo> STI(T->createMCSubtargetInfo(Triple, sys::getHostCPUName(), "")); OwningPtr<MCContext> MCCtx(new MCContext(AsmInfo.get(), MRI.get(), 0)); OwningPtr<const MCDisassembler> DisAsm(T->createMCDisassembler(*STI, *MCCtx)); #else OwningPtr<const MCSubtargetInfo> STI(T->createMCSubtargetInfo(Triple, sys::getHostCPUName(), "")); OwningPtr<const MCDisassembler> DisAsm(T->createMCDisassembler(*STI)); #endif if (!DisAsm) { Out << "error: no disassembler for target " << Triple << "\n"; Out.flush(); return 0; } OwningPtr<MCInstPrinter> Printer( T->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *MII, *MRI, *STI)); if (!Printer) { Out << "error: no instruction printer for target " << Triple.c_str() << "\n"; Out.flush(); return 0; } TargetOptions options; #if defined(DEBUG) options.JITEmitDebugInfo = true; #endif #if defined(PIPE_ARCH_X86) options.StackAlignmentOverride = 4; #endif #if defined(DEBUG) || defined(PROFILE) options.NoFramePointerElim = true; #endif OwningPtr<TargetMachine> TM(T->createTargetMachine(Triple, sys::getHostCPUName(), "", options)); #if HAVE_LLVM >= 0x0306 const TargetInstrInfo *TII = TM->getSubtargetImpl()->getInstrInfo(); #else const TargetInstrInfo *TII = TM->getInstrInfo(); #endif /* * Wrap the data in a MemoryObject */ BufferMemoryObject memoryObject((const uint8_t *)bytes, extent); uint64_t pc; pc = 0; while (true) { MCInst Inst; uint64_t Size; /* * Print address. We use addresses relative to the start of the function, * so that between runs. */ Out << llvm::format("%6lu:\t", (unsigned long)pc); if (!DisAsm->getInstruction(Inst, Size, memoryObject, pc, nulls(), nulls())) { Out << "invalid"; pc += 1; } /* * Output the bytes in hexidecimal format. */ if (0) { unsigned i; for (i = 0; i < Size; ++i) { Out << llvm::format("%02x ", ((const uint8_t*)bytes)[pc + i]); } for (; i < 16; ++i) { Out << " "; } } /* * Print the instruction. */ Printer->printInst(&Inst, Out, ""); /* * Advance. */ pc += Size; const MCInstrDesc &TID = TII->get(Inst.getOpcode()); /* * Keep track of forward jumps to a nearby address. */ if (TID.isBranch()) { for (unsigned i = 0; i < Inst.getNumOperands(); ++i) { const MCOperand &operand = Inst.getOperand(i); if (operand.isImm()) { uint64_t jump; /* * FIXME: Handle both relative and absolute addresses correctly. * EDInstInfo actually has this info, but operandTypes and * operandFlags enums are not exposed in the public interface. */ if (1) { /* * PC relative addr. */ jump = pc + operand.getImm(); } else { /* * Absolute addr. */ jump = (uint64_t)operand.getImm(); } /* * Output the address relative to the function start, given * that MC will print the addresses relative the current pc. */ Out << "\t\t; " << jump; /* * Ignore far jumps given it could be actually a tail return to * a random address. */ if (jump > max_pc && jump < extent) { max_pc = jump; } } } } Out << "\n"; /* * Stop disassembling on return statements, if there is no record of a * jump to a successive address. */ if (TID.isReturn()) { if (pc > max_pc) { break; } } } /* * Print GDB command, useful to verify output. */ if (0) { _debug_printf("disassemble %p %p\n", bytes, bytes + pc); } Out << "\n"; Out.flush(); return pc; }
/* * Disassemble a function, using the LLVM MC disassembler. * * See also: * - http://blog.llvm.org/2010/01/x86-disassembler.html * - http://blog.llvm.org/2010/04/intro-to-llvm-mc-project.html */ static size_t disassemble(const void* func, llvm::raw_ostream & Out) { const uint8_t *bytes = (const uint8_t *)func; /* * Limit disassembly to this extent */ const uint64_t extent = 96 * 1024; /* * Initialize all used objects. */ std::string Triple = llvm::sys::getProcessTriple(); LLVMDisasmContextRef D = LLVMCreateDisasm(Triple.c_str(), NULL, 0, NULL, NULL); char outline[1024]; if (!D) { Out << "error: couldn't create disassembler for triple " << Triple << "\n"; return 0; } uint64_t pc; pc = 0; while (pc < extent) { size_t Size; /* * Print address. We use addresses relative to the start of the function, * so that between runs. */ Out << llvm::format("%6lu:\t", (unsigned long)pc); Size = LLVMDisasmInstruction(D, (uint8_t *)bytes + pc, extent - pc, 0, outline, sizeof outline); if (!Size) { Out << "invalid\n"; pc += 1; break; } /* * Output the bytes in hexidecimal format. */ if (0) { unsigned i; for (i = 0; i < Size; ++i) { Out << llvm::format("%02x ", bytes[pc + i]); } for (; i < 16; ++i) { Out << " "; } } /* * Print the instruction. */ Out << outline; Out << "\n"; /* * Stop disassembling on return statements, if there is no record of a * jump to a successive address. * * XXX: This currently assumes x86 */ if (Size == 1 && bytes[pc] == 0xc3) { break; } /* * Advance. */ pc += Size; if (pc >= extent) { Out << "disassembly larger than " << extent << "bytes, aborting\n"; break; } } Out << "\n"; Out.flush(); LLVMDisasmDispose(D); /* * Print GDB command, useful to verify output. */ if (0) { _debug_printf("disassemble %p %p\n", bytes, bytes + pc); } return pc; }
void print(llvm::raw_ostream& out) { out << "\n\nCodeGen:\n"; //llvm::SmallPtrSet<llvm::GlobalValue*, 10> WeakRefReferences; out << " WeakRefReferences (llvm::SmallPtrSet<llvm::GlobalValue*, 10>) @"; out << " " << &Builder->WeakRefReferences << "\n"; for(auto I = Builder->WeakRefReferences.begin(), E = Builder->WeakRefReferences.end(); I != E; ++I) { (*I)->print(out); out << "\n"; } //llvm::StringMap<GlobalDecl> DeferredDecls; out << " DeferredDecls (llvm::StringMap<GlobalDecl>) @ "; out << &Builder->DeferredDecls << "\n"; for(auto I = Builder->DeferredDecls.begin(), E = Builder->DeferredDecls.end(); I != E; ++I) { out << I->first.str().c_str(); I->second.getDecl()->print(out); out << "\n"; } //std::vector<DeferredGlobal> DeferredDeclsToEmit; out << " DeferredDeclsToEmit (std::vector<DeferredGlobal>) @ "; out << &Builder->DeferredDeclsToEmit << "\n"; for(auto I = Builder->DeferredDeclsToEmit.begin(), E = Builder->DeferredDeclsToEmit.end(); I != E; ++I) { I->GD.getDecl()->print(out); I->GV->print(out); out << "\n"; } //std::vector<GlobalDecl> Aliases; out << " Aliases (std::vector<GlobalDecl>) @ "; out << &Builder->Aliases << "\n"; for(auto I = Builder->Aliases.begin(), E = Builder->Aliases.end(); I != E; ++I) { I->getDecl()->print(out); out << "\n"; } //typedef llvm::StringMap<llvm::TrackingVH<llvm::Constant> > // ReplacementsTy; //ReplacementsTy Replacements; out << " Replacements (llvm::StringMap<llvm::TrackingVH<llvm::Constant> >"; out << " @" << &Builder->Replacements << "\n"; for(auto I = Builder->Replacements.begin(), E = Builder->Replacements.end(); I != E; ++I) { out << I->getKey().str().c_str(); (*I->getValue()).print(out); out << "\n"; } //std::vector<const CXXRecordDecl*> DeferredVTables; out << " DeferredVTables (std::vector<const CXXRecordDecl*> @ "; out << &Builder->DeferredVTables << "\n"; for(auto I = Builder->DeferredVTables.begin(), E = Builder->DeferredVTables.end(); I != E; ++I) { (*I)->print(out); out << "\n"; } //std::vector<llvm::WeakVH> LLVMUsed; out << " LLVMUsed (std::vector<llvm::WeakVH> > @ "; out << &Builder->LLVMUsed << "\n"; for(auto I = Builder->LLVMUsed.begin(), E = Builder->LLVMUsed.end(); I != E; ++I) { (*I)->print(out); out << "\n"; } // typedef std::vector<std::pair<llvm::Constant*, int> > CtorList; //CtorList GlobalCtors; out << " GlobalCtors (std::vector<std::pair<llvm::Constant*, int> > @ "; out << &Builder->GlobalCtors << "\n"; for(auto I = Builder->GlobalCtors.begin(), E = Builder->GlobalCtors.end(); I != E; ++I) { out << I->Initializer << " : " << I->AssociatedData; out << "\n"; } //CtorList GlobalDtors; out << " GlobalDtors (std::vector<std::pair<llvm::Constant*, int> > @ "; out << &Builder->GlobalDtors << "\n"; for(auto I = Builder->GlobalDtors.begin(), E = Builder->GlobalDtors.end(); I != E; ++I) { out << I->Initializer << " : " << I->AssociatedData; out << "\n"; } //llvm::DenseMap<GlobalDecl, StringRef> MangledDeclNames; //std::vector<llvm::Constant*> Annotations; //llvm::StringMap<llvm::Constant*> AnnotationStrings; //llvm::StringMap<llvm::Constant*> CFConstantStringMap; //llvm::StringMap<llvm::GlobalVariable*> ConstantStringMap; out << " ConstantStringMap (llvm::DenseMap<llvm::Constant *, llvm::GlobalVariable *>) @ "; out << &Builder->ConstantStringMap << "\n"; for(auto I = Builder->ConstantStringMap.begin(), E = Builder->ConstantStringMap.end(); I != E; ++I) { I->first->print(out); I->second->print(out); out << "\n"; } //llvm::DenseMap<const Decl*, llvm::Constant *> StaticLocalDeclMap; //llvm::DenseMap<const Decl*, llvm::GlobalVariable*> StaticLocalDeclGuardMap; //llvm::DenseMap<const Expr*, llvm::Constant *> MaterializedGlobalTemporaryMap; //llvm::DenseMap<QualType, llvm::Constant *> AtomicSetterHelperFnMap; //llvm::DenseMap<QualType, llvm::Constant *> AtomicGetterHelperFnMap; //llvm::DenseMap<QualType, llvm::Constant *> TypeDescriptorMap; //StaticExternCMap StaticExternCValues; //std::vector<std::pair<const VarDecl *, llvm::GlobalVariable *> > // CXXThreadLocals; //std::vector<llvm::Constant*> CXXThreadLocalInits; //std::vector<llvm::Constant*> CXXGlobalInits; //llvm::DenseMap<const Decl*, unsigned> DelayedCXXInitPosition; //SmallVector<GlobalInitData, 8> PrioritizedCXXGlobalInits; //std::vector<std::pair<llvm::WeakVH,llvm::Constant*> > CXXGlobalDtors; //llvm::SetVector<clang::Module *> ImportedModules; //SmallVector<llvm::Value *, 16> LinkerOptionsMetadata; // out.flush(); }