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();
}