2009-06-18 23:05:21 +00:00
|
|
|
//===-- llvm-mc.cpp - Machine Code Hacking Driver -------------------------===//
|
2009-06-18 23:04:45 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
2009-06-18 23:05:21 +00:00
|
|
|
// This utility is a simple driver that allows command line hacking on machine
|
|
|
|
// code.
|
2009-06-18 23:04:45 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-01-22 01:44:57 +00:00
|
|
|
#include "llvm/MC/MCParser/MCAsmLexer.h"
|
2009-06-24 00:52:40 +00:00
|
|
|
#include "llvm/MC/MCContext.h"
|
2009-08-27 00:51:57 +00:00
|
|
|
#include "llvm/MC/MCCodeEmitter.h"
|
2009-09-14 03:02:37 +00:00
|
|
|
#include "llvm/MC/MCInstPrinter.h"
|
2009-08-10 18:15:01 +00:00
|
|
|
#include "llvm/MC/MCSectionMachO.h"
|
2009-06-24 00:52:40 +00:00
|
|
|
#include "llvm/MC/MCStreamer.h"
|
2010-04-05 23:07:18 +00:00
|
|
|
#include "llvm/MC/MCParser/AsmParser.h"
|
|
|
|
#include "llvm/Target/TargetAsmBackend.h"
|
|
|
|
#include "llvm/Target/TargetAsmParser.h"
|
|
|
|
#include "llvm/Target/TargetData.h"
|
|
|
|
#include "llvm/Target/TargetRegistry.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h" // FIXME.
|
|
|
|
#include "llvm/Target/TargetSelect.h"
|
2009-06-24 00:52:40 +00:00
|
|
|
#include "llvm/ADT/OwningPtr.h"
|
2009-06-18 23:04:45 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2009-08-14 03:48:55 +00:00
|
|
|
#include "llvm/Support/FormattedStream.h"
|
2009-06-18 23:04:45 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
2009-06-21 05:22:37 +00:00
|
|
|
#include "llvm/Support/SourceMgr.h"
|
2009-06-18 23:04:45 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-03-13 02:20:38 +00:00
|
|
|
#include "llvm/System/Host.h"
|
2009-06-18 23:04:45 +00:00
|
|
|
#include "llvm/System/Signals.h"
|
2009-12-22 22:50:29 +00:00
|
|
|
#include "Disassembler.h"
|
2009-06-18 23:04:45 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
static cl::opt<std::string>
|
|
|
|
InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
|
|
|
|
|
|
|
|
static cl::opt<std::string>
|
|
|
|
OutputFilename("o", cl::desc("Output filename"),
|
|
|
|
cl::value_desc("filename"));
|
|
|
|
|
2009-08-27 07:56:39 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
ShowEncoding("show-encoding", cl::desc("Show instruction encodings"));
|
|
|
|
|
2010-02-03 18:18:30 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
ShowInst("show-inst", cl::desc("Show internal instruction representation"));
|
|
|
|
|
2009-09-20 07:17:49 +00:00
|
|
|
static cl::opt<unsigned>
|
|
|
|
OutputAsmVariant("output-asm-variant",
|
|
|
|
cl::desc("Syntax variant to use for output printing"));
|
|
|
|
|
2010-03-25 22:49:09 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
RelaxAll("mc-relax-all", cl::desc("Relax all fixups"));
|
|
|
|
|
2010-05-23 17:44:06 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
EnableLogging("enable-api-logging", cl::desc("Enable MC API logging"));
|
|
|
|
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
enum OutputFileType {
|
2010-03-23 23:47:12 +00:00
|
|
|
OFT_Null,
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
OFT_AssemblyFile,
|
|
|
|
OFT_ObjectFile
|
|
|
|
};
|
|
|
|
static cl::opt<OutputFileType>
|
|
|
|
FileType("filetype", cl::init(OFT_AssemblyFile),
|
|
|
|
cl::desc("Choose an output file type:"),
|
|
|
|
cl::values(
|
|
|
|
clEnumValN(OFT_AssemblyFile, "asm",
|
|
|
|
"Emit an assembly ('.s') file"),
|
2010-03-23 23:47:12 +00:00
|
|
|
clEnumValN(OFT_Null, "null",
|
|
|
|
"Don't emit anything (for timing purposes)"),
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
clEnumValN(OFT_ObjectFile, "obj",
|
|
|
|
"Emit a native object ('.o') file"),
|
|
|
|
clEnumValEnd));
|
|
|
|
|
2009-06-21 05:22:37 +00:00
|
|
|
static cl::list<std::string>
|
|
|
|
IncludeDirs("I", cl::desc("Directory of include files"),
|
|
|
|
cl::value_desc("directory"), cl::Prefix);
|
2009-06-18 23:04:45 +00:00
|
|
|
|
2010-03-13 02:20:38 +00:00
|
|
|
static cl::opt<std::string>
|
|
|
|
ArchName("arch", cl::desc("Target arch to assemble for, "
|
|
|
|
"see -version for available targets"));
|
|
|
|
|
2009-07-17 22:38:58 +00:00
|
|
|
static cl::opt<std::string>
|
2009-11-01 22:07:54 +00:00
|
|
|
TripleName("triple", cl::desc("Target triple to assemble for, "
|
2010-03-13 02:20:38 +00:00
|
|
|
"see -version for available targets"));
|
2009-07-17 22:38:58 +00:00
|
|
|
|
2010-03-13 02:20:57 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
NoInitialTextSection("n", cl::desc(
|
|
|
|
"Don't assume assembly file starts in the text section"));
|
|
|
|
|
2009-06-21 05:22:37 +00:00
|
|
|
enum ActionType {
|
2009-06-21 20:16:42 +00:00
|
|
|
AC_AsLex,
|
2009-12-17 01:49:59 +00:00
|
|
|
AC_Assemble,
|
2010-04-12 19:43:00 +00:00
|
|
|
AC_Disassemble,
|
|
|
|
AC_EDisassemble
|
2009-06-21 05:22:37 +00:00
|
|
|
};
|
2009-06-18 23:04:45 +00:00
|
|
|
|
2009-06-21 05:22:37 +00:00
|
|
|
static cl::opt<ActionType>
|
|
|
|
Action(cl::desc("Action to perform:"),
|
2009-06-21 20:16:42 +00:00
|
|
|
cl::init(AC_Assemble),
|
|
|
|
cl::values(clEnumValN(AC_AsLex, "as-lex",
|
|
|
|
"Lex tokens from a .s file"),
|
|
|
|
clEnumValN(AC_Assemble, "assemble",
|
2009-06-21 05:22:37 +00:00
|
|
|
"Assemble a .s file (default)"),
|
2009-12-17 01:49:59 +00:00
|
|
|
clEnumValN(AC_Disassemble, "disassemble",
|
|
|
|
"Disassemble strings of hex bytes"),
|
2010-04-12 19:43:00 +00:00
|
|
|
clEnumValN(AC_EDisassemble, "edis",
|
|
|
|
"Enhanced disassembly of strings of hex bytes"),
|
2009-06-21 05:22:37 +00:00
|
|
|
clEnumValEnd));
|
2009-06-18 23:04:45 +00:00
|
|
|
|
2009-09-04 21:45:34 +00:00
|
|
|
static const Target *GetTarget(const char *ProgName) {
|
2010-03-13 02:20:38 +00:00
|
|
|
// Figure out the target triple.
|
|
|
|
if (TripleName.empty())
|
|
|
|
TripleName = sys::getHostTriple();
|
|
|
|
if (!ArchName.empty()) {
|
|
|
|
llvm::Triple TT(TripleName);
|
|
|
|
TT.setArchName(ArchName);
|
|
|
|
TripleName = TT.str();
|
|
|
|
}
|
|
|
|
|
2009-09-04 21:45:34 +00:00
|
|
|
// Get the target specific parser.
|
|
|
|
std::string Error;
|
|
|
|
const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
|
|
|
|
if (TheTarget)
|
|
|
|
return TheTarget;
|
|
|
|
|
|
|
|
errs() << ProgName << ": error: unable to get target for '" << TripleName
|
|
|
|
<< "', see --version and --triple.\n";
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-21 20:16:42 +00:00
|
|
|
static int AsLexInput(const char *ProgName) {
|
2009-06-21 05:22:37 +00:00
|
|
|
std::string ErrorMessage;
|
|
|
|
MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(InputFilename,
|
|
|
|
&ErrorMessage);
|
2009-06-18 23:04:45 +00:00
|
|
|
if (Buffer == 0) {
|
2009-06-21 05:22:37 +00:00
|
|
|
errs() << ProgName << ": ";
|
2009-06-18 23:04:45 +00:00
|
|
|
if (ErrorMessage.size())
|
|
|
|
errs() << ErrorMessage << "\n";
|
|
|
|
else
|
|
|
|
errs() << "input file didn't read correctly.\n";
|
|
|
|
return 1;
|
|
|
|
}
|
2009-06-21 05:22:37 +00:00
|
|
|
|
|
|
|
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);
|
2009-06-21 07:19:10 +00:00
|
|
|
|
2009-09-04 21:45:34 +00:00
|
|
|
const Target *TheTarget = GetTarget(ProgName);
|
|
|
|
if (!TheTarget)
|
|
|
|
return 1;
|
|
|
|
|
2010-04-03 21:03:50 +00:00
|
|
|
llvm::OwningPtr<MCAsmInfo> MAI(TheTarget->createAsmInfo(TripleName));
|
2009-09-04 21:45:34 +00:00
|
|
|
assert(MAI && "Unable to create target asm info!");
|
|
|
|
|
2010-01-21 00:19:58 +00:00
|
|
|
AsmLexer Lexer(*MAI);
|
2009-06-18 23:04:45 +00:00
|
|
|
|
2009-06-21 20:16:42 +00:00
|
|
|
bool Error = false;
|
|
|
|
|
2009-07-28 16:56:42 +00:00
|
|
|
while (Lexer.Lex().isNot(AsmToken::Eof)) {
|
|
|
|
switch (Lexer.getKind()) {
|
2009-06-21 20:16:42 +00:00
|
|
|
default:
|
2010-01-20 23:19:55 +00:00
|
|
|
SrcMgr.PrintMessage(Lexer.getLoc(), "unknown token", "warning");
|
2009-06-21 20:16:42 +00:00
|
|
|
Error = true;
|
|
|
|
break;
|
2009-07-28 16:08:33 +00:00
|
|
|
case AsmToken::Error:
|
2009-06-21 20:16:42 +00:00
|
|
|
Error = true; // error already printed.
|
2009-06-21 19:21:25 +00:00
|
|
|
break;
|
2009-07-28 16:08:33 +00:00
|
|
|
case AsmToken::Identifier:
|
2009-07-28 16:38:40 +00:00
|
|
|
outs() << "identifier: " << Lexer.getTok().getString() << '\n';
|
2009-06-21 07:19:10 +00:00
|
|
|
break;
|
2009-07-28 16:08:33 +00:00
|
|
|
case AsmToken::String:
|
2009-07-28 16:38:40 +00:00
|
|
|
outs() << "string: " << Lexer.getTok().getString() << '\n';
|
2009-06-21 19:56:35 +00:00
|
|
|
break;
|
2009-07-28 16:08:33 +00:00
|
|
|
case AsmToken::Integer:
|
2009-07-28 16:38:40 +00:00
|
|
|
outs() << "int: " << Lexer.getTok().getString() << '\n';
|
2009-06-21 07:19:10 +00:00
|
|
|
break;
|
2009-07-01 06:56:54 +00:00
|
|
|
|
2009-07-28 16:08:33 +00:00
|
|
|
case AsmToken::Amp: outs() << "Amp\n"; break;
|
|
|
|
case AsmToken::AmpAmp: outs() << "AmpAmp\n"; break;
|
|
|
|
case AsmToken::Caret: outs() << "Caret\n"; break;
|
|
|
|
case AsmToken::Colon: outs() << "Colon\n"; break;
|
|
|
|
case AsmToken::Comma: outs() << "Comma\n"; break;
|
|
|
|
case AsmToken::Dollar: outs() << "Dollar\n"; break;
|
|
|
|
case AsmToken::EndOfStatement: outs() << "EndOfStatement\n"; break;
|
|
|
|
case AsmToken::Eof: outs() << "Eof\n"; break;
|
|
|
|
case AsmToken::Equal: outs() << "Equal\n"; break;
|
|
|
|
case AsmToken::EqualEqual: outs() << "EqualEqual\n"; break;
|
|
|
|
case AsmToken::Exclaim: outs() << "Exclaim\n"; break;
|
|
|
|
case AsmToken::ExclaimEqual: outs() << "ExclaimEqual\n"; break;
|
|
|
|
case AsmToken::Greater: outs() << "Greater\n"; break;
|
|
|
|
case AsmToken::GreaterEqual: outs() << "GreaterEqual\n"; break;
|
|
|
|
case AsmToken::GreaterGreater: outs() << "GreaterGreater\n"; break;
|
|
|
|
case AsmToken::LParen: outs() << "LParen\n"; break;
|
|
|
|
case AsmToken::Less: outs() << "Less\n"; break;
|
|
|
|
case AsmToken::LessEqual: outs() << "LessEqual\n"; break;
|
|
|
|
case AsmToken::LessGreater: outs() << "LessGreater\n"; break;
|
|
|
|
case AsmToken::LessLess: outs() << "LessLess\n"; break;
|
|
|
|
case AsmToken::Minus: outs() << "Minus\n"; break;
|
|
|
|
case AsmToken::Percent: outs() << "Percent\n"; break;
|
|
|
|
case AsmToken::Pipe: outs() << "Pipe\n"; break;
|
|
|
|
case AsmToken::PipePipe: outs() << "PipePipe\n"; break;
|
|
|
|
case AsmToken::Plus: outs() << "Plus\n"; break;
|
|
|
|
case AsmToken::RParen: outs() << "RParen\n"; break;
|
|
|
|
case AsmToken::Slash: outs() << "Slash\n"; break;
|
|
|
|
case AsmToken::Star: outs() << "Star\n"; break;
|
|
|
|
case AsmToken::Tilde: outs() << "Tilde\n"; break;
|
2009-06-21 07:19:10 +00:00
|
|
|
}
|
|
|
|
}
|
2009-06-18 23:04:45 +00:00
|
|
|
|
2009-06-21 20:16:42 +00:00
|
|
|
return Error;
|
2009-06-21 05:22:37 +00:00
|
|
|
}
|
|
|
|
|
2009-08-14 03:48:55 +00:00
|
|
|
static formatted_raw_ostream *GetOutputStream() {
|
2009-08-23 02:51:22 +00:00
|
|
|
if (OutputFilename == "")
|
|
|
|
OutputFilename = "-";
|
2009-08-11 04:34:48 +00:00
|
|
|
|
|
|
|
// Make sure that the Out file gets unlinked from the disk if we get a
|
2009-08-23 02:51:22 +00:00
|
|
|
// SIGINT.
|
|
|
|
if (OutputFilename != "-")
|
|
|
|
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
|
2009-08-11 04:34:48 +00:00
|
|
|
|
|
|
|
std::string Err;
|
2009-08-23 02:51:22 +00:00
|
|
|
raw_fd_ostream *Out = new raw_fd_ostream(OutputFilename.c_str(), Err,
|
2009-08-25 15:34:52 +00:00
|
|
|
raw_fd_ostream::F_Binary);
|
2009-08-11 04:34:48 +00:00
|
|
|
if (!Err.empty()) {
|
|
|
|
errs() << Err << '\n';
|
|
|
|
delete Out;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-14 03:48:55 +00:00
|
|
|
return new formatted_raw_ostream(*Out, formatted_raw_ostream::DELETE_STREAM);
|
2009-08-11 04:34:48 +00:00
|
|
|
}
|
|
|
|
|
2009-07-28 20:47:52 +00:00
|
|
|
static int AssembleInput(const char *ProgName) {
|
2009-08-14 03:48:55 +00:00
|
|
|
const Target *TheTarget = GetTarget(ProgName);
|
|
|
|
if (!TheTarget)
|
|
|
|
return 1;
|
|
|
|
|
2009-07-28 20:47:52 +00:00
|
|
|
std::string Error;
|
|
|
|
MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(InputFilename, &Error);
|
2009-06-21 20:16:42 +00:00
|
|
|
if (Buffer == 0) {
|
|
|
|
errs() << ProgName << ": ";
|
2009-07-28 20:47:52 +00:00
|
|
|
if (Error.size())
|
|
|
|
errs() << Error << "\n";
|
2009-06-21 20:16:42 +00:00
|
|
|
else
|
|
|
|
errs() << "input file didn't read correctly.\n";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
SourceMgr SrcMgr;
|
|
|
|
|
2009-08-19 16:25:53 +00:00
|
|
|
// Tell SrcMgr about this buffer, which is what the parser will pick up.
|
2009-06-21 20:16:42 +00:00
|
|
|
SrcMgr.AddNewSourceBuffer(Buffer, SMLoc());
|
|
|
|
|
|
|
|
// Record the location of the include directories so that the lexer can find
|
|
|
|
// it later.
|
|
|
|
SrcMgr.setIncludeDirs(IncludeDirs);
|
|
|
|
|
2010-03-11 22:53:35 +00:00
|
|
|
|
2010-04-03 21:03:50 +00:00
|
|
|
llvm::OwningPtr<MCAsmInfo> MAI(TheTarget->createAsmInfo(TripleName));
|
2010-03-11 22:53:35 +00:00
|
|
|
assert(MAI && "Unable to create target asm info!");
|
|
|
|
|
|
|
|
MCContext Ctx(*MAI);
|
2009-08-14 03:48:55 +00:00
|
|
|
formatted_raw_ostream *Out = GetOutputStream();
|
2009-08-11 04:34:48 +00:00
|
|
|
if (!Out)
|
|
|
|
return 1;
|
2009-08-14 03:48:55 +00:00
|
|
|
|
|
|
|
|
|
|
|
// FIXME: We shouldn't need to do this (and link in codegen).
|
|
|
|
OwningPtr<TargetMachine> TM(TheTarget->createTargetMachine(TripleName, ""));
|
|
|
|
|
2009-08-17 04:23:44 +00:00
|
|
|
if (!TM) {
|
|
|
|
errs() << ProgName << ": error: could not create target for triple '"
|
|
|
|
<< TripleName << "'.\n";
|
|
|
|
return 1;
|
2009-08-14 03:48:55 +00:00
|
|
|
}
|
|
|
|
|
2009-08-27 00:51:57 +00:00
|
|
|
OwningPtr<MCCodeEmitter> CE;
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
OwningPtr<MCStreamer> Str;
|
2010-03-11 01:34:27 +00:00
|
|
|
OwningPtr<TargetAsmBackend> TAB;
|
2009-08-17 04:23:44 +00:00
|
|
|
|
2009-09-04 21:45:34 +00:00
|
|
|
if (FileType == OFT_AssemblyFile) {
|
2010-03-19 05:48:53 +00:00
|
|
|
MCInstPrinter *IP =
|
2010-04-04 05:04:31 +00:00
|
|
|
TheTarget->createMCInstPrinter(OutputAsmVariant, *MAI);
|
2009-08-27 07:56:39 +00:00
|
|
|
if (ShowEncoding)
|
2010-02-12 23:12:47 +00:00
|
|
|
CE.reset(TheTarget->createCodeEmitter(*TM, Ctx));
|
2010-03-12 18:28:53 +00:00
|
|
|
Str.reset(createAsmStreamer(Ctx, *Out,TM->getTargetData()->isLittleEndian(),
|
2010-03-19 05:48:53 +00:00
|
|
|
/*asmverbose*/true, IP, CE.get(), ShowInst));
|
2010-03-23 23:47:12 +00:00
|
|
|
} else if (FileType == OFT_Null) {
|
|
|
|
Str.reset(createNullStreamer(Ctx));
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
} else {
|
|
|
|
assert(FileType == OFT_ObjectFile && "Invalid file type!");
|
2010-02-12 23:12:47 +00:00
|
|
|
CE.reset(TheTarget->createCodeEmitter(*TM, Ctx));
|
2010-03-11 01:34:27 +00:00
|
|
|
TAB.reset(TheTarget->createAsmBackend(TripleName));
|
2010-05-21 12:54:43 +00:00
|
|
|
Str.reset(TheTarget->createObjectStreamer(TripleName, Ctx, *TAB,
|
|
|
|
*Out, CE.get(), RelaxAll));
|
llvm-mc: Start MCAssembler and MCMachOStreamer.
- Together these form the (Mach-O) back end of the assembler.
- MCAssembler is the actual assembler backend, which is designed to have a
reasonable API. This will eventually grow to support multiple object file
implementations, but for now its Mach-O/i386 only.
- MCMachOStreamer adapts the MCStreamer "actions" API to the MCAssembler API,
e.g. converting the various directives into fragments, managing state like
the current section, and so on.
- llvm-mc will use the new backend via '-filetype=obj', which may eventually
be, but is not yet, since I hear that people like assemblers which actually
assemble.
- The only thing that works at the moment is changing sections. For the time
being I have a Python Mach-O dumping tool in test/scripts so this stuff can
be easily tested, eventually I expect to replace this with a real LLVM tool.
- More doxyments to come.
I assume that since this stuff doesn't touch any of the things which are part of
2.6 that it is ok to put this in not so long before the freeze, but if someone
objects let me know, I can pull it.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79612 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-21 09:11:24 +00:00
|
|
|
}
|
2009-06-24 23:30:00 +00:00
|
|
|
|
2010-05-23 17:44:06 +00:00
|
|
|
if (EnableLogging) {
|
|
|
|
Str.reset(createLoggingStreamer(Str.take(), errs()));
|
|
|
|
}
|
|
|
|
|
2009-09-04 21:45:34 +00:00
|
|
|
AsmParser Parser(SrcMgr, Ctx, *Str.get(), *MAI);
|
2009-08-14 03:48:55 +00:00
|
|
|
OwningPtr<TargetAsmParser> TAP(TheTarget->createAsmParser(Parser));
|
|
|
|
if (!TAP) {
|
|
|
|
errs() << ProgName
|
|
|
|
<< ": error: this target does not support assembly parsing.\n";
|
2009-07-28 20:47:52 +00:00
|
|
|
return 1;
|
2009-08-14 03:48:55 +00:00
|
|
|
}
|
|
|
|
|
2009-07-28 22:40:46 +00:00
|
|
|
Parser.setTargetParser(*TAP.get());
|
2009-08-11 04:34:48 +00:00
|
|
|
|
2010-03-13 02:20:57 +00:00
|
|
|
int Res = Parser.Run(NoInitialTextSection);
|
2010-05-27 19:47:36 +00:00
|
|
|
delete Out;
|
2009-08-11 04:34:48 +00:00
|
|
|
|
2010-03-13 19:31:47 +00:00
|
|
|
// Delete output on errors.
|
|
|
|
if (Res && OutputFilename != "-")
|
|
|
|
sys::Path(OutputFilename).eraseFromDisk();
|
|
|
|
|
2009-08-11 04:34:48 +00:00
|
|
|
return Res;
|
2009-12-17 01:49:59 +00:00
|
|
|
}
|
|
|
|
|
2010-04-12 19:43:00 +00:00
|
|
|
static int DisassembleInput(const char *ProgName, bool Enhanced) {
|
2010-03-19 18:07:50 +00:00
|
|
|
const Target *TheTarget = GetTarget(ProgName);
|
|
|
|
if (!TheTarget)
|
2009-12-17 01:49:59 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
std::string ErrorMessage;
|
|
|
|
|
|
|
|
MemoryBuffer *Buffer = MemoryBuffer::getFileOrSTDIN(InputFilename,
|
|
|
|
&ErrorMessage);
|
|
|
|
|
|
|
|
if (Buffer == 0) {
|
|
|
|
errs() << ProgName << ": ";
|
|
|
|
if (ErrorMessage.size())
|
|
|
|
errs() << ErrorMessage << "\n";
|
|
|
|
else
|
|
|
|
errs() << "input file didn't read correctly.\n";
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-04-12 19:43:00 +00:00
|
|
|
if (Enhanced)
|
|
|
|
return Disassembler::disassembleEnhanced(TripleName, *Buffer);
|
|
|
|
else
|
|
|
|
return Disassembler::disassemble(*TheTarget, TripleName, *Buffer);
|
2009-12-17 01:49:59 +00:00
|
|
|
}
|
2009-06-21 20:16:42 +00:00
|
|
|
|
2009-06-21 05:22:37 +00:00
|
|
|
|
|
|
|
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.
|
2009-07-17 22:38:58 +00:00
|
|
|
|
2009-08-14 03:48:55 +00:00
|
|
|
// Initialize targets and assembly printers/parsers.
|
2009-07-17 22:38:58 +00:00
|
|
|
llvm::InitializeAllTargetInfos();
|
2009-08-14 03:48:55 +00:00
|
|
|
// FIXME: We shouldn't need to initialize the Target(Machine)s.
|
|
|
|
llvm::InitializeAllTargets();
|
|
|
|
llvm::InitializeAllAsmPrinters();
|
2009-07-17 22:38:58 +00:00
|
|
|
llvm::InitializeAllAsmParsers();
|
2009-12-17 01:49:59 +00:00
|
|
|
llvm::InitializeAllDisassemblers();
|
2009-07-17 22:38:58 +00:00
|
|
|
|
2009-06-21 05:22:37 +00:00
|
|
|
cl::ParseCommandLineOptions(argc, argv, "llvm machine code playground\n");
|
|
|
|
|
|
|
|
switch (Action) {
|
|
|
|
default:
|
2009-06-21 20:16:42 +00:00
|
|
|
case AC_AsLex:
|
|
|
|
return AsLexInput(argv[0]);
|
2009-06-21 05:22:37 +00:00
|
|
|
case AC_Assemble:
|
|
|
|
return AssembleInput(argv[0]);
|
2009-12-17 01:49:59 +00:00
|
|
|
case AC_Disassemble:
|
2010-04-12 19:43:00 +00:00
|
|
|
return DisassembleInput(argv[0], false);
|
|
|
|
case AC_EDisassemble:
|
|
|
|
return DisassembleInput(argv[0], true);
|
2009-06-21 05:22:37 +00:00
|
|
|
}
|
|
|
|
|
2009-06-18 23:04:45 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|