X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-mc%2Fllvm-mc.cpp;h=72294caef3bc00dabfee6c2db3bbc113f4cd55a7;hb=26a84a6e7c37b49531feb59466bfe8954403074c;hp=c98641a33a73d09de62dfcc7dfd66148436298be;hpb=59ee62d2418df8db499eca1ae17f5900dc2dcbba;p=oota-llvm.git diff --git a/tools/llvm-mc/llvm-mc.cpp b/tools/llvm-mc/llvm-mc.cpp index c98641a33a7..72294caef3b 100644 --- a/tools/llvm-mc/llvm-mc.cpp +++ b/tools/llvm-mc/llvm-mc.cpp @@ -12,38 +12,33 @@ // //===----------------------------------------------------------------------===// -#include "llvm/MC/MCParser/AsmLexer.h" -#include "llvm/MC/MCParser/MCAsmLexer.h" +#include "Disassembler.h" +#include "llvm/MC/MCAsmBackend.h" +#include "llvm/MC/MCAsmInfo.h" #include "llvm/MC/MCContext.h" -#include "llvm/MC/MCCodeEmitter.h" #include "llvm/MC/MCInstPrinter.h" #include "llvm/MC/MCInstrInfo.h" +#include "llvm/MC/MCObjectFileInfo.h" +#include "llvm/MC/MCParser/AsmLexer.h" +#include "llvm/MC/MCRegisterInfo.h" #include "llvm/MC/MCSectionMachO.h" #include "llvm/MC/MCStreamer.h" #include "llvm/MC/MCSubtargetInfo.h" -#include "llvm/MC/SubtargetFeature.h" -#include "llvm/Target/TargetAsmBackend.h" -#include "llvm/Target/TargetAsmParser.h" -#include "llvm/Target/TargetData.h" -#include "llvm/Target/TargetRegistry.h" -#include "llvm/Target/TargetAsmInfo.h" // FIXME. -#include "llvm/Target/TargetLowering.h" // FIXME. -#include "llvm/Target/TargetLoweringObjectFile.h" // FIXME. -#include "llvm/Target/TargetMachine.h" // FIXME. -#include "llvm/Target/TargetSelect.h" -#include "llvm/ADT/OwningPtr.h" +#include "llvm/MC/MCTargetAsmParser.h" +#include "llvm/MC/MCTargetOptionsCommandFlags.h" #include "llvm/Support/CommandLine.h" +#include "llvm/Support/Compression.h" #include "llvm/Support/FileUtilities.h" #include "llvm/Support/FormattedStream.h" +#include "llvm/Support/Host.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Signals.h" #include "llvm/Support/SourceMgr.h" +#include "llvm/Support/TargetRegistry.h" +#include "llvm/Support/TargetSelect.h" #include "llvm/Support/ToolOutputFile.h" -#include "llvm/Support/Host.h" -#include "llvm/Support/Signals.h" -#include "llvm/Support/system_error.h" -#include "Disassembler.h" using namespace llvm; static cl::opt @@ -56,6 +51,10 @@ OutputFilename("o", cl::desc("Output filename"), static cl::opt ShowEncoding("show-encoding", cl::desc("Show instruction encodings")); +static cl::opt +CompressDebugSections("compress-debug-sections", + cl::desc("Compress DWARF debug sections")); + static cl::opt ShowInst("show-inst", cl::desc("Show internal instruction representation")); @@ -68,13 +67,8 @@ OutputAsmVariant("output-asm-variant", cl::desc("Syntax variant to use for output printing")); static cl::opt -RelaxAll("mc-relax-all", cl::desc("Relax all fixups")); - -static cl::opt -NoExecStack("mc-no-exec-stack", cl::desc("File doesn't need an exec stack")); - -static cl::opt -EnableLogging("enable-api-logging", cl::desc("Enable MC API logging")); +PrintImmHex("print-imm-hex", cl::init(false), + cl::desc("Prefer hex format for immediate values")); enum OutputFileType { OFT_Null, @@ -111,18 +105,70 @@ MCPU("mcpu", cl::value_desc("cpu-name"), cl::init("")); +static cl::list +MAttrs("mattr", + cl::CommaSeparated, + cl::desc("Target specific attributes (-mattr=help for details)"), + cl::value_desc("a1,+a2,-a3,...")); + +static cl::opt +RelocModel("relocation-model", + cl::desc("Choose relocation model"), + cl::init(Reloc::Default), + cl::values( + clEnumValN(Reloc::Default, "default", + "Target default relocation model"), + clEnumValN(Reloc::Static, "static", + "Non-relocatable code"), + clEnumValN(Reloc::PIC_, "pic", + "Fully relocatable, position independent code"), + clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic", + "Relocatable external references, non-relocatable code"), + clEnumValEnd)); + +static cl::opt +CMModel("code-model", + cl::desc("Choose code model"), + cl::init(CodeModel::Default), + cl::values(clEnumValN(CodeModel::Default, "default", + "Target default code model"), + clEnumValN(CodeModel::Small, "small", + "Small code model"), + clEnumValN(CodeModel::Kernel, "kernel", + "Kernel code model"), + clEnumValN(CodeModel::Medium, "medium", + "Medium code model"), + clEnumValN(CodeModel::Large, "large", + "Large code model"), + clEnumValEnd)); + static cl::opt NoInitialTextSection("n", cl::desc("Don't assume assembly file starts " "in the text section")); static cl::opt -SaveTempLabels("L", cl::desc("Don't discard temporary labels")); +GenDwarfForAssembly("g", cl::desc("Generate dwarf debugging info for assembly " + "source files")); + +static cl::opt +DebugCompilationDir("fdebug-compilation-dir", + cl::desc("Specifies the debug info's compilation dir")); + +static cl::opt +MainFileName("main-file-name", + cl::desc("Specifies the name we should consider the input file")); + +static cl::opt SaveTempLabels("save-temp-labels", + cl::desc("Don't discard temporary labels")); + +static cl::opt NoExecStack("no-exec-stack", + cl::desc("File doesn't need an exec stack")); enum ActionType { AC_AsLex, AC_Assemble, AC_Disassemble, - AC_EDisassemble + AC_MDisassemble, }; static cl::opt @@ -134,29 +180,28 @@ Action(cl::desc("Action to perform:"), "Assemble a .s file (default)"), clEnumValN(AC_Disassemble, "disassemble", "Disassemble strings of hex bytes"), - clEnumValN(AC_EDisassemble, "edis", - "Enhanced disassembly of strings of hex bytes"), + clEnumValN(AC_MDisassemble, "mdis", + "Marked up disassembly of strings of hex bytes"), clEnumValEnd)); static const Target *GetTarget(const char *ProgName) { // Figure out the target triple. if (TripleName.empty()) - TripleName = sys::getHostTriple(); - if (!ArchName.empty()) { - llvm::Triple TT(TripleName); - TT.setArchName(ArchName); - TripleName = TT.str(); - } + TripleName = sys::getDefaultTargetTriple(); + Triple TheTriple(Triple::normalize(TripleName)); // Get the target specific parser. std::string Error; - const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error); - if (TheTarget) - return TheTarget; + const Target *TheTarget = TargetRegistry::lookupTarget(ArchName, TheTriple, + Error); + if (!TheTarget) { + errs() << ProgName << ": " << Error; + return nullptr; + } - errs() << ProgName << ": error: unable to get target for '" << TripleName - << "', see --version and --triple.\n"; - return 0; + // Update the triple name and return the found target. + TripleName = TheTriple.getTriple(); + return TheTarget; } static tool_output_file *GetOutputStream() { @@ -164,47 +209,40 @@ static tool_output_file *GetOutputStream() { OutputFilename = "-"; std::string Err; - tool_output_file *Out = new tool_output_file(OutputFilename.c_str(), Err, - raw_fd_ostream::F_Binary); + tool_output_file *Out = + new tool_output_file(OutputFilename.c_str(), Err, sys::fs::F_None); if (!Err.empty()) { errs() << Err << '\n'; delete Out; - return 0; + return nullptr; } return Out; } -static int AsLexInput(const char *ProgName) { - OwningPtr BufferPtr; - if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFilename, BufferPtr)) { - errs() << ProgName << ": " << ec.message() << '\n'; - return 1; +static std::string DwarfDebugFlags; +static void setDwarfDebugFlags(int argc, char **argv) { + if (!getenv("RC_DEBUG_OPTIONS")) + return; + for (int i = 0; i < argc; i++) { + DwarfDebugFlags += argv[i]; + if (i + 1 < argc) + DwarfDebugFlags += " "; } - MemoryBuffer *Buffer = BufferPtr.take(); - - SourceMgr SrcMgr; - - // Tell SrcMgr about this buffer, which is what TGParser will pick up. - SrcMgr.AddNewSourceBuffer(Buffer, SMLoc()); - - // Record the location of the include directories so that the lexer can find - // it later. - SrcMgr.setIncludeDirs(IncludeDirs); - - const Target *TheTarget = GetTarget(ProgName); - if (!TheTarget) - return 1; +} - llvm::OwningPtr MAI(TheTarget->createAsmInfo(TripleName)); - assert(MAI && "Unable to create target asm info!"); +static std::string DwarfDebugProducer; +static void setDwarfDebugProducer(void) { + if(!getenv("DEBUG_PRODUCER")) + return; + DwarfDebugProducer += getenv("DEBUG_PRODUCER"); +} - AsmLexer Lexer(*MAI); - Lexer.setBuffer(SrcMgr.getMemoryBuffer(0)); +static int AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI, + tool_output_file *Out) { - OwningPtr Out(GetOutputStream()); - if (!Out) - return 1; + AsmLexer Lexer(MAI); + Lexer.setBuffer(SrcMgr.getMemoryBuffer(SrcMgr.getMainFileID())->getBuffer()); bool Error = false; while (Lexer.Lex().isNot(AsmToken::Eof)) { @@ -212,7 +250,8 @@ static int AsLexInput(const char *ProgName) { switch (Tok.getKind()) { default: - SrcMgr.PrintMessage(Lexer.getLoc(), "unknown token", "warning"); + SrcMgr.PrintMessage(Lexer.getLoc(), SourceMgr::DK_Warning, + "unknown token"); Error = true; break; case AsmToken::Error: @@ -227,9 +266,6 @@ static int AsLexInput(const char *ProgName) { case AsmToken::Real: Out->os() << "real: " << Lexer.getTok().getString(); break; - case AsmToken::Register: - Out->os() << "register: " << Lexer.getTok().getRegVal(); - break; case AsmToken::String: Out->os() << "string: " << Lexer.getTok().getString(); break; @@ -278,23 +314,66 @@ static int AsLexInput(const char *ProgName) { Out->os() << "\")\n"; } - // Keep output if no errors. - if (Error == 0) Out->keep(); - return Error; } -static int AssembleInput(const char *ProgName) { +static int AssembleInput(const char *ProgName, const Target *TheTarget, + SourceMgr &SrcMgr, MCContext &Ctx, MCStreamer &Str, + MCAsmInfo &MAI, MCSubtargetInfo &STI, + MCInstrInfo &MCII, MCTargetOptions &MCOptions) { + std::unique_ptr Parser( + createMCAsmParser(SrcMgr, Ctx, Str, MAI)); + std::unique_ptr TAP( + TheTarget->createMCAsmParser(STI, *Parser, MCII, MCOptions)); + + if (!TAP) { + errs() << ProgName + << ": error: this target does not support assembly parsing.\n"; + return 1; + } + + Parser->setShowParsedOperands(ShowInstOperands); + Parser->setTargetParser(*TAP.get()); + + int Res = Parser->Run(NoInitialTextSection); + + return Res; +} + +int main(int argc, char **argv) { + // Print a stack trace if we signal out. + sys::PrintStackTraceOnErrorSignal(); + PrettyStackTraceProgram X(argc, argv); + llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. + + // Initialize targets and assembly printers/parsers. + llvm::InitializeAllTargetInfos(); + llvm::InitializeAllTargetMCs(); + llvm::InitializeAllAsmParsers(); + llvm::InitializeAllDisassemblers(); + + // Register the target printer for --version. + cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); + + cl::ParseCommandLineOptions(argc, argv, "llvm machine code playground\n"); + MCTargetOptions MCOptions = InitMCTargetOptionsFromFlags(); + TripleName = Triple::normalize(TripleName); + setDwarfDebugFlags(argc, argv); + + setDwarfDebugProducer(); + + const char *ProgName = argv[0]; const Target *TheTarget = GetTarget(ProgName); if (!TheTarget) return 1; - OwningPtr BufferPtr; - if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFilename, BufferPtr)) { + std::unique_ptr BufferPtr; + if (std::error_code ec = + MemoryBuffer::getFileOrSTDIN(InputFilename, BufferPtr)) { errs() << ProgName << ": " << ec.message() << '\n'; return 1; } - MemoryBuffer *Buffer = BufferPtr.take(); + MemoryBuffer *Buffer = BufferPtr.release(); SourceMgr SrcMgr; @@ -305,175 +384,122 @@ static int AssembleInput(const char *ProgName) { // it later. SrcMgr.setIncludeDirs(IncludeDirs); + std::unique_ptr MRI(TheTarget->createMCRegInfo(TripleName)); + assert(MRI && "Unable to create target register info!"); - llvm::OwningPtr MAI(TheTarget->createAsmInfo(TripleName)); + std::unique_ptr MAI(TheTarget->createMCAsmInfo(*MRI, TripleName)); assert(MAI && "Unable to create target asm info!"); - // Package up features to be passed to target/subtarget - std::string FeaturesStr; - - // FIXME: We shouldn't need to do this (and link in codegen). - // When we split this out, we should do it in a way that makes - // it straightforward to switch subtargets on the fly (.e.g, - // the .cpu and .code16 directives). - OwningPtr TM(TheTarget->createTargetMachine(TripleName, - MCPU, - FeaturesStr)); - - if (!TM) { - errs() << ProgName << ": error: could not create target for triple '" - << TripleName << "'.\n"; - return 1; + if (CompressDebugSections) { + if (!zlib::isAvailable()) { + errs() << ProgName + << ": build tools with zlib to enable -compress-debug-sections"; + return 1; + } + MAI->setCompressDebugSections(true); } - const TargetAsmInfo *tai = new TargetAsmInfo(*TM); - MCContext Ctx(*MAI, tai); + // FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and + // MCObjectFileInfo needs a MCContext reference in order to initialize itself. + MCObjectFileInfo MOFI; + MCContext Ctx(MAI.get(), MRI.get(), &MOFI, &SrcMgr); + MOFI.InitMCObjectFileInfo(TripleName, RelocModel, CMModel, Ctx); + if (SaveTempLabels) Ctx.setAllowTemporaryLabels(false); - OwningPtr Out(GetOutputStream()); - if (!Out) + Ctx.setGenDwarfForAssembly(GenDwarfForAssembly); + // Default to 4 for dwarf version. + unsigned DwarfVersion = MCOptions.DwarfVersion ? MCOptions.DwarfVersion : 4; + if (DwarfVersion < 2 || DwarfVersion > 4) { + errs() << ProgName << ": Dwarf version " << DwarfVersion + << " is not supported." << '\n'; return 1; - - formatted_raw_ostream FOS(Out->os()); - OwningPtr Str; - - const TargetLoweringObjectFile &TLOF = - TM->getTargetLowering()->getObjFileLowering(); - const_cast(TLOF).Initialize(Ctx, *TM); - - OwningPtr MCII(TheTarget->createMCInstrInfo()); - OwningPtr - STI(TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr)); - - // FIXME: There is a bit of code duplication with addPassesToEmitFile. - if (FileType == OFT_AssemblyFile) { - MCInstPrinter *IP = - TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI); - MCCodeEmitter *CE = 0; - TargetAsmBackend *TAB = 0; - if (ShowEncoding) { - CE = TheTarget->createCodeEmitter(*MCII, *STI, Ctx); - TAB = TheTarget->createAsmBackend(TripleName); - } - Str.reset(TheTarget->createAsmStreamer(Ctx, FOS, /*asmverbose*/true, - /*useLoc*/ true, - /*useCFI*/ true, IP, CE, TAB, - ShowInst)); - } else if (FileType == OFT_Null) { - Str.reset(createNullStreamer(Ctx)); - } else { - assert(FileType == OFT_ObjectFile && "Invalid file type!"); - MCCodeEmitter *CE = TheTarget->createCodeEmitter(*MCII, *STI, Ctx); - TargetAsmBackend *TAB = TheTarget->createAsmBackend(TripleName); - Str.reset(TheTarget->createObjectStreamer(TripleName, Ctx, *TAB, - FOS, CE, RelaxAll, - NoExecStack)); } + Ctx.setDwarfVersion(DwarfVersion); + if (!DwarfDebugFlags.empty()) + Ctx.setDwarfDebugFlags(StringRef(DwarfDebugFlags)); + if (!DwarfDebugProducer.empty()) + Ctx.setDwarfDebugProducer(StringRef(DwarfDebugProducer)); + if (!DebugCompilationDir.empty()) + Ctx.setCompilationDir(DebugCompilationDir); + if (!MainFileName.empty()) + Ctx.setMainFileName(MainFileName); - if (EnableLogging) { - Str.reset(createLoggingStreamer(Str.take(), errs())); + // Package up features to be passed to target/subtarget + std::string FeaturesStr; + if (MAttrs.size()) { + SubtargetFeatures Features; + for (unsigned i = 0; i != MAttrs.size(); ++i) + Features.AddFeature(MAttrs[i]); + FeaturesStr = Features.getString(); } - OwningPtr Parser(createMCAsmParser(*TheTarget, SrcMgr, Ctx, - *Str.get(), *MAI)); - OwningPtr TAP(TheTarget->createAsmParser(*STI, *Parser)); - if (!TAP) { - errs() << ProgName - << ": error: this target does not support assembly parsing.\n"; + std::unique_ptr Out(GetOutputStream()); + if (!Out) return 1; - } - Parser->setShowParsedOperands(ShowInstOperands); - Parser->setTargetParser(*TAP.get()); - - int Res = Parser->Run(NoInitialTextSection); - - // Keep output if no errors. - if (Res == 0) Out->keep(); - - return Res; -} + formatted_raw_ostream FOS(Out->os()); + std::unique_ptr Str; -static int DisassembleInput(const char *ProgName, bool Enhanced) { - const Target *TheTarget = GetTarget(ProgName); - if (!TheTarget) - return 0; + std::unique_ptr MCII(TheTarget->createMCInstrInfo()); + std::unique_ptr STI( + TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr)); - OwningPtr Buffer; - if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputFilename, Buffer)) { - errs() << ProgName << ": " << ec.message() << '\n'; - return 1; - } + MCInstPrinter *IP = nullptr; + if (FileType == OFT_AssemblyFile) { + IP = + TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI, *MCII, *MRI, *STI); - OwningPtr Out(GetOutputStream()); - if (!Out) - return 1; + // Set the display preference for hex vs. decimal immediates. + IP->setPrintImmHex(PrintImmHex); - int Res; - if (Enhanced) { - Res = - Disassembler::disassembleEnhanced(TripleName, *Buffer.take(), Out->os()); - } else { - // Package up features to be passed to target/subtarget - std::string FeaturesStr; - - // FIXME: We shouldn't need to do this (and link in codegen). - // When we split this out, we should do it in a way that makes - // it straightforward to switch subtargets on the fly (.e.g, - // the .cpu and .code16 directives). - OwningPtr TM(TheTarget->createTargetMachine(TripleName, - MCPU, - FeaturesStr)); - - if (!TM) { - errs() << ProgName << ": error: could not create target for triple '" - << TripleName << "'.\n"; - return 1; + // Set up the AsmStreamer. + MCCodeEmitter *CE = nullptr; + MCAsmBackend *MAB = nullptr; + if (ShowEncoding) { + CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, *STI, Ctx); + MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU); } + Str.reset(TheTarget->createAsmStreamer(Ctx, FOS, /*asmverbose*/ true, + /*useDwarfDirectory*/ true, IP, CE, + MAB, ShowInst)); - Res = Disassembler::disassemble(*TheTarget, TripleName, - *Buffer.take(), Out->os()); + } else if (FileType == OFT_Null) { + Str.reset(createNullStreamer(Ctx)); + } else { + assert(FileType == OFT_ObjectFile && "Invalid file type!"); + MCCodeEmitter *CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, *STI, Ctx); + MCAsmBackend *MAB = TheTarget->createMCAsmBackend(*MRI, TripleName, MCPU); + Str.reset(TheTarget->createMCObjectStreamer(TripleName, Ctx, *MAB, + FOS, CE, *STI, RelaxAll, + NoExecStack)); } - // Keep output if no errors. - if (Res == 0) Out->keep(); - - return Res; -} - - -int main(int argc, char **argv) { - // Print a stack trace if we signal out. - sys::PrintStackTraceOnErrorSignal(); - PrettyStackTraceProgram X(argc, argv); - llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - - // Initialize targets and assembly printers/parsers. - llvm::InitializeAllTargetInfos(); - // FIXME: We shouldn't need to initialize the Target(Machine)s. - llvm::InitializeAllTargets(); - llvm::InitializeAllMCInstrInfos(); - llvm::InitializeAllMCSubtargetInfos(); - llvm::InitializeAllAsmPrinters(); - llvm::InitializeAllAsmParsers(); - llvm::InitializeAllDisassemblers(); - - cl::ParseCommandLineOptions(argc, argv, "llvm machine code playground\n"); - TripleName = Triple::normalize(TripleName); - + int Res = 1; + bool disassemble = false; switch (Action) { - default: case AC_AsLex: - return AsLexInput(argv[0]); + Res = AsLexInput(SrcMgr, *MAI, Out.get()); + break; case AC_Assemble: - return AssembleInput(argv[0]); + Res = AssembleInput(ProgName, TheTarget, SrcMgr, Ctx, *Str, *MAI, *STI, + *MCII, MCOptions); + break; + case AC_MDisassemble: + assert(IP && "Expected assembly output"); + IP->setUseMarkup(1); + disassemble = true; + break; case AC_Disassemble: - return DisassembleInput(argv[0], false); - case AC_EDisassemble: - return DisassembleInput(argv[0], true); + disassemble = true; + break; } + if (disassemble) + Res = Disassembler::disassemble(*TheTarget, TripleName, *STI, *Str, + *Buffer, SrcMgr, Out->os()); - return 0; + // Keep output if no errors. + if (Res == 0) Out->keep(); + return Res; } -