diff options
Diffstat (limited to 'tools')
-rw-r--r-- | tools/gccas/Makefile | 28 | ||||
-rw-r--r-- | tools/gccas/gccas.sh | 64 | ||||
-rw-r--r-- | tools/gccld/Makefile | 29 | ||||
-rw-r--r-- | tools/gccld/gccld.sh | 23 | ||||
-rw-r--r-- | tools/llvm-db/CLICommand.h | 111 | ||||
-rw-r--r-- | tools/llvm-db/CLIDebugger.cpp | 309 | ||||
-rw-r--r-- | tools/llvm-db/CLIDebugger.h | 208 | ||||
-rw-r--r-- | tools/llvm-db/CMakeLists.txt | 8 | ||||
-rw-r--r-- | tools/llvm-db/Commands.cpp | 865 | ||||
-rw-r--r-- | tools/llvm-db/Makefile | 15 | ||||
-rw-r--r-- | tools/llvm-db/llvm-db.cpp | 102 | ||||
-rw-r--r-- | tools/llvm-mc/AsmExpr.cpp | 162 | ||||
-rw-r--r-- | tools/llvm-mc/AsmExpr.h | 179 | ||||
-rw-r--r-- | tools/llvm-mc/MC-X86Specific.cpp | 266 |
14 files changed, 0 insertions, 2369 deletions
diff --git a/tools/gccas/Makefile b/tools/gccas/Makefile deleted file mode 100644 index ff84d96..0000000 --- a/tools/gccas/Makefile +++ /dev/null @@ -1,28 +0,0 @@ -##===- tools/gccas/Makefile --------------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## -LEVEL = ../.. - -include $(LEVEL)/Makefile.common - -install-local:: $(PROJ_bindir)/gccas - -$(PROJ_bindir)/gccas : gccas.sh Makefile - $(Echo) Installing gccas shell script. - $(Verb) sed "s#@TOOLDIR@#$(PROJ_bindir)#" $< > $@ - $(Verb) chmod 0755 $@ - -all-local:: $(ToolDir)/gccas - -$(ToolDir)/gccas : gccas.sh Makefile - $(Echo) Making $(ToolDir)/gccas shell script. - $(Verb) sed "s#@TOOLDIR@#$(ToolDir)#" $< > $@ - $(Verb) chmod 0755 $@ - -clean-local:: - $(Verb)$(RM) -f $(ToolDir)/gccas diff --git a/tools/gccas/gccas.sh b/tools/gccas/gccas.sh deleted file mode 100644 index 9cacad4..0000000 --- a/tools/gccas/gccas.sh +++ /dev/null @@ -1,64 +0,0 @@ -#!/bin/sh -##===- tools/gccas.sh ------------------------------------------*- bash -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## -# -# Synopsis: This shell script is a replacement for the old "gccas" tool that -# existed in LLVM versions before 2.0. The functionality of gccas has -# now been moved to opt and llvm-as. This shell script provides -# backwards compatibility so build environments invoking gccas can -# still get the net effect of llvm-as/opt by running gccas. -# -# Syntax: gccas OPTIONS... [asm file] -# -##===----------------------------------------------------------------------===## -# -echo "gccas: This tool is deprecated, please use opt" 1>&2 -TOOLDIR=@TOOLDIR@ -OPTOPTS="-std-compile-opts -f" -ASOPTS="" -lastwasdasho=0 -for option in "$@" ; do - option=`echo "$option" | sed 's/^--/-/'` - case "$option" in - -disable-opt) - OPTOPTS="$OPTOPTS $option" - ;; - -disable-inlining) - OPTOPTS="$OPTOPTS $option" - ;; - -verify) - OPTOPTS="$OPTOPTS -verify-each" - ;; - -strip-debug) - OPTOPTS="$OPTOPTS $option" - ;; - -o) - OPTOPTS="$OPTOPTS -o" - lastwasdasho=1 - ;; - -disable-compression) - # ignore - ;; - -traditional-format) - # ignore - ;; - -*) - OPTOPTS="$OPTOPTS $option" - ;; - *) - if test $lastwasdasho -eq 1 ; then - OPTOPTS="$OPTOPTS $option" - lastwasdasho=0 - else - ASOPTS="$ASOPTS $option" - fi - ;; - esac -done -${TOOLDIR}/llvm-as $ASOPTS -o - | ${TOOLDIR}/opt $OPTOPTS diff --git a/tools/gccld/Makefile b/tools/gccld/Makefile deleted file mode 100644 index b2d3f73..0000000 --- a/tools/gccld/Makefile +++ /dev/null @@ -1,29 +0,0 @@ -##===- tools/gccld/Makefile --------------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LEVEL = ../.. - -include $(LEVEL)/Makefile.common - -install-local:: $(PROJ_bindir)/gccld - -$(PROJ_bindir)/gccld : gccld.sh Makefile - $(Echo) Installing gccld shell script. - $(Verb) sed "s#@TOOLDIR@#$(PROJ_bindir)#" $< > $@ - $(Verb) chmod 0755 $@ - -all-local:: $(ToolDir)/gccld - -$(ToolDir)/gccld : gccld.sh Makefile - $(Echo) Making $(ToolDir)/gccld shell script. - $(Verb) sed "s#@TOOLDIR@#$(ToolDir)#" $< > $@ - $(Verb) chmod 0755 $@ - -clean-local:: - $(Verb)$(RM) -f $(ToolDir)/gccld diff --git a/tools/gccld/gccld.sh b/tools/gccld/gccld.sh deleted file mode 100644 index b092607..0000000 --- a/tools/gccld/gccld.sh +++ /dev/null @@ -1,23 +0,0 @@ -#!/bin/sh -##===- tools/gccld/gccld.sh ------------------------------------*- bash -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## -# -# Synopsis: This shell script is a replacement for the old "gccld" tool that -# existed in LLVM versions before 2.0. The functionality of gccld has -# now been moved to llvm-ld. This shell script provides backwards -# compatibility so build environments invoking gccld can still get -# link (under the covers) with llvm-ld. -# -# Syntax: gccld OPTIONS... (see llvm-ld for details) -# -##===----------------------------------------------------------------------===## -# -echo "gccld: This tool is deprecated, please use llvm-ld" 1>&2 -TOOLDIR=@TOOLDIR@ -$TOOLDIR/llvm-ld "$@" diff --git a/tools/llvm-db/CLICommand.h b/tools/llvm-db/CLICommand.h deleted file mode 100644 index 0beec91..0000000 --- a/tools/llvm-db/CLICommand.h +++ /dev/null @@ -1,111 +0,0 @@ -//===- CLICommand.h - Classes used to represent commands --------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines a small class hierarchy used to represent the various types -// of commands in the CLI debugger front-end. -// -//===----------------------------------------------------------------------===// - -#ifndef CLICOMMAND_H -#define CLICOMMAND_H - -#include <string> -#include <vector> -#include <cassert> - -namespace llvm { - class CLIDebugger; - - /// CLICommand - Base class of the hierarchy, used to provide the abstract - /// interface common to all commands. - /// - class CLICommand { - /// ShortHelp, LongHelp - The short and long helps strings printed for the - /// command. The ShortHelp string should be a single line of text without a - /// newline. The LongHelp string should be a full description with - /// terminating newline. - std::string ShortHelp, LongHelp; - - /// RefCount - This contains the number of entries in the CLIDebugger - /// CommandTable that points to this command. - unsigned RefCount; - - /// OptionNames - This contains a list of names for the option. Keeping - /// track of this is done just to make the help output more helpful. - /// - std::vector<std::string> OptionNames; - public: - CLICommand(const std::string &SH, const std::string &LH) - : ShortHelp(SH), LongHelp(LH), RefCount(0) {} - - virtual ~CLICommand() {} - - /// addRef/dropRef - Implement a simple reference counting scheme to make - /// sure we delete commands that are no longer used. - void addRef() { ++RefCount; } - void dropRef() { - if (--RefCount == 0) delete this; - } - - /// getPrimaryOptionName - Return the first name the option was added under. - /// This is the name we report for the option in the help output. - std::string getPrimaryOptionName() const { - return OptionNames.empty() ? "" : OptionNames[0]; - } - - /// getOptionName - Return all of the names the option is registered as. - /// - const std::vector<std::string> &getOptionNames() const { - return OptionNames; - } - - /// addOptionName - Add a name that this option is known as. - /// - void addOptionName(const std::string &Name) { - OptionNames.push_back(Name); - } - - /// removeOptionName - Eliminate one of the names for this option. - /// - void removeOptionName(const std::string &Name) { - unsigned i = 0; - for (; OptionNames[i] != Name; ++i) - assert(i+1 < OptionNames.size() && "Didn't find option name!"); - OptionNames.erase(OptionNames.begin()+i); - } - - - /// getShortHelp - Return the short help string for this command. - /// - const std::string &getShortHelp() { return ShortHelp; } - - /// getLongHelp - Return the long help string for this command, if it - /// exists. - const std::string &getLongHelp() { return LongHelp; } - - virtual void runCommand(CLIDebugger &D, std::string &Arguments) = 0; - }; - - /// BuiltinCLICommand - This class represents commands that are built directly - /// into the debugger. - class BuiltinCLICommand : public CLICommand { - // Impl - Pointer to the method that implements the command - void (CLIDebugger::*Impl)(std::string&); - public: - BuiltinCLICommand(const std::string &ShortHelp, const std::string &LongHelp, - void (CLIDebugger::*impl)(std::string&)) - : CLICommand(ShortHelp, LongHelp), Impl(impl) {} - - void runCommand(CLIDebugger &D, std::string &Arguments) { - (D.*Impl)(Arguments); - } - }; -} - -#endif diff --git a/tools/llvm-db/CLIDebugger.cpp b/tools/llvm-db/CLIDebugger.cpp deleted file mode 100644 index 31476f7..0000000 --- a/tools/llvm-db/CLIDebugger.cpp +++ /dev/null @@ -1,309 +0,0 @@ -//===-- CLIDebugger.cpp - Command Line Interface to the Debugger ----------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file contains the main implementation of the Command Line Interface to -// the debugger. -// -//===----------------------------------------------------------------------===// - -#include "CLIDebugger.h" -#include "CLICommand.h" -#include "llvm/Debugger/SourceFile.h" -#include "llvm/ADT/StringExtras.h" -#include <iostream> -using namespace llvm; - -/// CLIDebugger constructor - This initializes the debugger to its default -/// state, and initializes the command table. -/// -CLIDebugger::CLIDebugger(LLVMContext& ctxt) - : Context(ctxt), TheProgramInfo(0), TheRuntimeInfo(0), - Prompt("(llvm-db) "), ListSize(10) { - // Initialize instance variables - CurrentFile = 0; - LineListedStart = 1; - LineListedEnd = 1; - LastCurrentFrame = 0; - CurrentLanguage = 0; - - CLICommand *C; - //===--------------------------------------------------------------------===// - // Program startup and shutdown options - // - addCommand("file", new BuiltinCLICommand( - "Use specified file as the program to be debugged", - "The debugger looks in the current directory and the program $PATH for the" - " specified LLVM program. It then unloads the currently loaded program and" - " loads the specified program.\n", - &CLIDebugger::fileCommand)); - - addCommand("create", new BuiltinCLICommand( - "Start the program, halting its execution in main", - "This command creates an instance of the current program, but stops" - "\nexecution immediately.\n", - &CLIDebugger::createCommand)); - - addCommand("kill", new BuiltinCLICommand( - "Kills the execution of the current program being debugged", "", - &CLIDebugger::killCommand)); - - addCommand("quit", new BuiltinCLICommand( - "Exit the debugger", "", - &CLIDebugger::quitCommand)); - - //===--------------------------------------------------------------------===// - // Program execution commands - // - addCommand("run", C = new BuiltinCLICommand( - "Start the program running from the beginning", "", - &CLIDebugger::runCommand)); - addCommand("r", C); - - addCommand("cont", C = new BuiltinCLICommand( - "Continue program being debugged until the next stop point", "", - &CLIDebugger::contCommand)); - addCommand("c", C); addCommand("fg", C); - - addCommand("step", C = new BuiltinCLICommand( - "Step program until it reaches a new source line", "", - &CLIDebugger::stepCommand)); - addCommand("s", C); - - addCommand("next", C = new BuiltinCLICommand( - "Step program until it reaches a new source line, stepping over calls", "", - &CLIDebugger::nextCommand)); - addCommand("n", C); - - addCommand("finish", new BuiltinCLICommand( - "Execute until the selected stack frame returns", - "Upon return, the value returned is printed and put in the value history.\n", - &CLIDebugger::finishCommand)); - - //===--------------------------------------------------------------------===// - // Stack frame commands - // - addCommand("backtrace", C = new BuiltinCLICommand( - "Print backtrace of all stack frames, or innermost COUNT frames", - "FIXME: describe. Takes 'n', '-n' or 'full'\n", - &CLIDebugger::backtraceCommand)); - addCommand("bt", C); - - addCommand("up", new BuiltinCLICommand( - "Select and print stack frame that called this one", - "An argument says how many frames up to go.\n", - &CLIDebugger::upCommand)); - - addCommand("down", new BuiltinCLICommand( - "Select and print stack frame called by this one", - "An argument says how many frames down go.\n", - &CLIDebugger::downCommand)); - - addCommand("frame", C = new BuiltinCLICommand( - "Select and print a stack frame", - "With no argument, print the selected stack frame. (See also 'info frame').\n" - "An argument specifies the frame to select.\n", - &CLIDebugger::frameCommand)); - addCommand("f", C); - - //===--------------------------------------------------------------------===// - // Breakpoint related commands - // - addCommand("break", C = new BuiltinCLICommand( - "Set breakpoint at specified line or function", - "FIXME: describe.\n", - &CLIDebugger::breakCommand)); - addCommand("b", C); - - - //===--------------------------------------------------------------------===// - // Miscellaneous commands - // - addCommand("info", new BuiltinCLICommand( - "Generic command for showing things about the program being debugged", - "info functions: display information about functions in the program.\ninfo" - " source : display information about the current source file.\ninfo source" - "s : Display source file names for the program\ninfo target : print status" - " of inferior process\n", - &CLIDebugger::infoCommand)); - - addCommand("list", C = new BuiltinCLICommand( - "List specified function or line", - "FIXME: document\n", - &CLIDebugger::listCommand)); - addCommand("l", C); - - addCommand("set", new BuiltinCLICommand( - "Change program or debugger variable", - "FIXME: document\n", - &CLIDebugger::setCommand)); - - addCommand("show", new BuiltinCLICommand( - "Generic command for showing things about the debugger", - "FIXME: document\n", - &CLIDebugger::showCommand)); - - addCommand("help", C = new BuiltinCLICommand( - "Prints information about available commands", "", - &CLIDebugger::helpCommand)); - addCommand("h", C); -} - - -/// addCommand - Add a command to the CommandTable, potentially displacing a -/// preexisting command. -void CLIDebugger::addCommand(const std::string &Option, CLICommand *Cmd) { - assert(Cmd && "Cannot set a null command!"); - CLICommand *&CS = CommandTable[Option]; - if (CS == Cmd) return; // noop - - // If we already have a command, decrement the command's reference count. - if (CS) { - CS->removeOptionName(Option); - CS->dropRef(); - } - CS = Cmd; - - // Remember that we are using this command. - Cmd->addRef(); - Cmd->addOptionName(Option); -} - -static bool isValidPrefix(const std::string &Prefix, const std::string &Option){ - return Prefix.size() <= Option.size() && - Prefix == std::string(Option.begin(), Option.begin()+Prefix.size()); -} - -/// getCommand - This looks up the specified command using a fuzzy match. -/// If the string exactly matches a command or is an unambiguous prefix of a -/// command, it returns the command. Otherwise it throws an exception -/// indicating the possible ambiguous choices. -CLICommand *CLIDebugger::getCommand(const std::string &Command) { - - // Look up the command in the table. - std::map<std::string, CLICommand*>::iterator CI = - CommandTable.lower_bound(Command); - - if (Command == "") { - throw "Null command should not get here!"; - } else if (CI == CommandTable.end() || - !isValidPrefix(Command, CI->first)) { - // If this command has no relation to anything in the command table, - // print the error message. - throw "Unknown command: '" + Command + - "'. Use 'help' for list of commands."; - } else if (CI->first == Command) { - // We have an exact match on the command - return CI->second; - } else { - // Otherwise, we have a prefix match. Check to see if this is - // unambiguous, and if so, run it. - std::map<std::string, CLICommand*>::iterator CI2 = CI; - - // If the next command is a valid completion of this one, we are - // ambiguous. - if (++CI2 != CommandTable.end() && isValidPrefix(Command, CI2->first)) { - std::string ErrorMsg = - "Ambiguous command '" + Command + "'. Options: " + CI->first; - for (++CI; CI != CommandTable.end() && - isValidPrefix(Command, CI->first); ++CI) - ErrorMsg += ", " + CI->first; - throw ErrorMsg; - } else { - // It's an unambiguous prefix of a command, use it. - return CI->second; - } - } -} - - -/// run - Start the debugger, returning when the user exits the debugger. This -/// starts the main event loop of the CLI debugger. -/// -int CLIDebugger::run() { - std::string Command; - std::cout << Prompt; - - // Keep track of the last command issued, so that we can reissue it if the - // user hits enter as the command. - CLICommand *LastCommand = 0; - std::string LastArgs; - - // Continue reading commands until the end of file. - while (getline(std::cin, Command)) { - std::string Arguments = Command; - - // Split off the command from the arguments to the command. - Command = getToken(Arguments, " \t\n\v\f\r\\/;.*&"); - - try { - CLICommand *CurCommand; - - if (Command == "") { - CurCommand = LastCommand; - Arguments = LastArgs; - } else { - CurCommand = getCommand(Command); - } - - // Save the command we are running in case the user wants us to repeat it - // next time. - LastCommand = CurCommand; - LastArgs = Arguments; - - // Finally, execute the command. - if (CurCommand) - CurCommand->runCommand(*this, Arguments); - - } catch (int RetVal) { - // The quit command exits the command loop by throwing an integer return - // code. - return RetVal; - } catch (const std::string &Error) { - std::cout << "Error: " << Error << "\n"; - } catch (const char *Error) { - std::cout << "Error: " << Error << "\n"; - } catch (const NonErrorException &E) { - std::cout << E.getMessage() << "\n"; - } catch (...) { - std::cout << "ERROR: Debugger caught unexpected exception!\n"; - // Attempt to continue. - } - - // Write the prompt to get the next bit of user input - std::cout << Prompt; - } - - return 0; -} - - -/// askYesNo - Ask the user a question, and demand a yes/no response. If -/// the user says yes, return true. -/// -bool CLIDebugger::askYesNo(const std::string &Message) const { - std::string Answer; - std::cout << Message << " (y or n) " << std::flush; - while (getline(std::cin, Answer)) { - std::string Val = getToken(Answer); - if (getToken(Answer).empty()) { - if (Val == "yes" || Val == "y" || Val == "YES" || Val == "Y" || - Val == "Yes") - return true; - if (Val == "no" || Val == "n" || Val == "NO" || Val == "N" || - Val == "No") - return false; - } - - std::cout << "Please answer y or n.\n" << Message << " (y or n) " - << std::flush; - } - - // Ran out of input? - return false; -} diff --git a/tools/llvm-db/CLIDebugger.h b/tools/llvm-db/CLIDebugger.h deleted file mode 100644 index 9904559..0000000 --- a/tools/llvm-db/CLIDebugger.h +++ /dev/null @@ -1,208 +0,0 @@ -//===- CLIDebugger.h - LLVM Command Line Interface Debugger -----*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file defines the CLIDebugger class, which implements a command line -// interface to the LLVM Debugger library. -// -//===----------------------------------------------------------------------===// - -#ifndef CLIDEBUGGER_H -#define CLIDEBUGGER_H - -#include "llvm/Debugger/Debugger.h" -#include <map> - -namespace llvm { - class CLICommand; - class SourceFile; - class SourceLanguage; - class ProgramInfo; - class RuntimeInfo; - class LLVMContext; - - /// CLIDebugger - This class implements the command line interface for the - /// LLVM debugger. - class CLIDebugger { - LLVMContext& Context; - - /// Dbg - The low-level LLVM debugger object that we use to do our dirty - /// work. - Debugger Dbg; - - /// CommandTable - This table contains a mapping from command names to the - /// CLICommand object that implements the command. - std::map<std::string, CLICommand*> CommandTable; - - //===------------------------------------------------------------------===// - // Data related to the program that is currently loaded. Note that the Dbg - // variable also captures some information about the loaded program. This - // pointer is non-null iff Dbg.isProgramLoaded() is true. - // - ProgramInfo *TheProgramInfo; - - //===------------------------------------------------------------------===// - // Data related to the program that is currently executing, but has stopped. - // Note that the Dbg variable also captures some information about the - // loaded program. This pointer is non-null iff Dbg.isProgramRunning() is - // true. - // - RuntimeInfo *TheRuntimeInfo; - - /// LastCurrentFrame - This variable holds the Frame ID of the top-level - /// stack frame from the last time that the program was executed. We keep - /// this because we only want to print the source location when the current - /// function changes. - void *LastCurrentFrame; - - //===------------------------------------------------------------------===// - // Data directly exposed through the debugger prompt - // - std::string Prompt; // set prompt, show prompt - unsigned ListSize; // set listsize, show listsize - - //===------------------------------------------------------------------===// - // Data to support user interaction - // - - /// CurrentFile - The current source file we are inspecting, or null if - /// none. - const SourceFile *CurrentFile; - unsigned LineListedStart, LineListedEnd; - - /// CurrentLanguage - This contains the source language in use, if one is - /// explicitly set by the user. If this is null (the default), the language - /// is automatically determined from the current stack frame. - /// - const SourceLanguage *CurrentLanguage; - - public: - CLIDebugger(LLVMContext& ctxt); - - /// getDebugger - Return the current LLVM debugger implementation being - /// used. - Debugger &getDebugger() { return Dbg; } - - /// run - Start the debugger, returning when the user exits the debugger. - /// This starts the main event loop of the CLI debugger. - /// - int run(); - - /// addCommand - Add a command to the CommandTable, potentially displacing a - /// preexisting command. - void addCommand(const std::string &Option, CLICommand *Cmd); - - /// addSourceDirectory - Add a directory to search when looking for the - /// source code of the program. - void addSourceDirectory(const std::string &Dir) { - // FIXME: implement - } - - /// getCurrentLanguage - Return the current source language that the user is - /// playing around with. This is aquired from the current stack frame of a - /// running program if one exists, but this value can be explicitly set by - /// the user as well. - const SourceLanguage &getCurrentLanguage() const; - - /// getProgramInfo - Return a reference to the ProgramInfo object for the - /// currently loaded program. If there is no program loaded, throw an - /// exception. - ProgramInfo &getProgramInfo() const { - if (TheProgramInfo == 0) - throw "No program is loaded."; - return *TheProgramInfo; - } - - /// getRuntimeInfo - Return a reference to the current RuntimeInfo object. - /// If there is no program running, throw an exception. - RuntimeInfo &getRuntimeInfo() const { - if (TheRuntimeInfo == 0) - throw "No program is running."; - return *TheRuntimeInfo; - } - - private: // Internal implementation methods - - /// getCommand - This looks up the specified command using a fuzzy match. - /// If the string exactly matches a command or is an unambiguous prefix of a - /// command, it returns the command. Otherwise it throws an exception - /// indicating the possible ambiguous choices. - CLICommand *getCommand(const std::string &Command); - - /// askYesNo - Ask the user a question, and demand a yes/no response. If - /// the user says yes, return true. - bool askYesNo(const std::string &Message) const; - - /// printProgramLocation - Given a loaded and created child process that has - /// stopped, print its current source location. - void printProgramLocation(bool PrintLocation = true); - - /// eliminateRunInfo - We are about to run the program. Forget any state - /// about how the program used to be stopped. - void eliminateRunInfo(); - - /// programStoppedSuccessfully - This method updates internal data - /// structures to reflect the fact that the program just executed a while, - /// and has successfully stopped. - void programStoppedSuccessfully(); - - public: /// Builtin debugger commands, invokable by the user - // Program startup and shutdown options - void fileCommand(std::string &Options); // file - void createCommand(std::string &Options); // create - void killCommand(std::string &Options); // kill - void quitCommand(std::string &Options); // quit - - // Program execution commands - void runCommand(std::string &Options); // run|r - void contCommand(std::string &Options); // cont|c|fg - void stepCommand(std::string &Options); // step|s [count] - void nextCommand(std::string &Options); // next|n [count] - void finishCommand(std::string &Options); // finish - - // Stack frame commands - void backtraceCommand(std::string &Options); // backtrace|bt [count] - void upCommand(std::string &Options); // up - void downCommand(std::string &Options); // down - void frameCommand(std::string &Options); // frame - - - // Breakpoint related commands - void breakCommand(std::string &Options); // break|b <id> - - // Miscellaneous commands - void infoCommand(std::string &Options); // info - void listCommand(std::string &Options); // list - void setCommand(std::string &Options); // set - void showCommand(std::string &Options); // show - void helpCommand(std::string &Options); // help - - private: - /// startProgramRunning - If the program has been updated, reload it, then - /// start executing the program. - void startProgramRunning(); - - /// printSourceLine - Print the specified line of the current source file. - /// If the specified line is invalid (the source file could not be loaded or - /// the line number is out of range), don't print anything, but return true. - bool printSourceLine(unsigned LineNo); - - /// parseLineSpec - Parses a line specifier, for use by the 'list' command. - /// If SourceFile is returned as a void pointer, then it was not specified. - /// If the line specifier is invalid, an exception is thrown. - void parseLineSpec(std::string &LineSpec, const SourceFile *&SourceFile, - unsigned &LineNo); - - /// parseProgramOptions - This method parses the Options string and loads it - /// as options to be passed to the program. This is used by the run command - /// and by 'set args'. - void parseProgramOptions(std::string &Options); - }; -} - -#endif diff --git a/tools/llvm-db/CMakeLists.txt b/tools/llvm-db/CMakeLists.txt deleted file mode 100644 index af64908..0000000 --- a/tools/llvm-db/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -set(LLVM_LINK_COMPONENTS debugger) -set(LLVM_REQUIRES_EH 1) - -add_llvm_tool(llvm-db - CLIDebugger.cpp - Commands.cpp - llvm-db.cpp - ) diff --git a/tools/llvm-db/Commands.cpp b/tools/llvm-db/Commands.cpp deleted file mode 100644 index 4c916f4..0000000 --- a/tools/llvm-db/Commands.cpp +++ /dev/null @@ -1,865 +0,0 @@ -//===-- Commands.cpp - Implement various commands for the CLI -------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements many builtin user commands. -// -//===----------------------------------------------------------------------===// - -#include "CLIDebugger.h" -#include "CLICommand.h" -#include "llvm/Debugger/ProgramInfo.h" -#include "llvm/Debugger/RuntimeInfo.h" -#include "llvm/Debugger/SourceLanguage.h" -#include "llvm/Debugger/SourceFile.h" -#include "llvm/Debugger/InferiorProcess.h" -#include "llvm/Support/FileUtilities.h" -#include "llvm/ADT/StringExtras.h" -#include <iostream> -#include <cstdlib> -using namespace llvm; - -/// getCurrentLanguage - Return the current source language that the user is -/// playing around with. This is aquired from the current stack frame of a -/// running program if one exists, but this value can be explicitly set by the -/// user as well. -const SourceLanguage &CLIDebugger::getCurrentLanguage() const { - // If the user explicitly switched languages with 'set language', use what - // they asked for. - if (CurrentLanguage) { - return *CurrentLanguage; - } else if (Dbg.isProgramRunning()) { - // Otherwise, if the program is running, infer the current language from it. - const GlobalVariable *FuncDesc = - getRuntimeInfo().getCurrentFrame().getFunctionDesc(); - return getProgramInfo().getFunction(FuncDesc).getSourceFile().getLanguage(); - } else { - // Otherwise, default to C like GDB apparently does. - return SourceLanguage::getCFamilyInstance(); - } -} - -/// startProgramRunning - If the program has been updated, reload it, then -/// start executing the program. -void CLIDebugger::startProgramRunning() { - eliminateRunInfo(); - - // If the program has been modified, reload it! - sys::PathWithStatus Program(Dbg.getProgramPath()); - std::string Err; - const sys::FileStatus *Status = Program.getFileStatus(false, &Err); - if (!Status) - throw Err; - if (TheProgramInfo->getProgramTimeStamp() != Status->getTimestamp()) { - std::cout << "'" << Program << "' has changed; re-reading program.\n"; - - // Unload an existing program. This kills the program if necessary. - Dbg.unloadProgram(); - delete TheProgramInfo; - TheProgramInfo = 0; - CurrentFile = 0; - - Dbg.loadProgram(Program.toString(), Context); - TheProgramInfo = new ProgramInfo(Dbg.getProgram()); - } - - std::cout << "Starting program: " << Dbg.getProgramPath() << "\n"; - Dbg.createProgram(); - - // There was no current frame. - LastCurrentFrame = 0; -} - -/// printSourceLine - Print the specified line of the current source file. -/// If the specified line is invalid (the source file could not be loaded or -/// the line number is out of range), don't print anything, but return true. -bool CLIDebugger::printSourceLine(unsigned LineNo) { - assert(CurrentFile && "There is no current source file to print!"); - const char *LineStart, *LineEnd; - CurrentFile->getSourceLine(LineNo-1, LineStart, LineEnd); - if (LineStart == 0) return true; - std::cout << LineNo; - - // If this is the line the program is currently stopped at, print a marker. - if (Dbg.isProgramRunning()) { - unsigned CurLineNo, CurColNo; - const SourceFileInfo *CurSFI; - getRuntimeInfo().getCurrentFrame().getSourceLocation(CurLineNo, CurColNo, - CurSFI); - - if (CurLineNo == LineNo && CurrentFile == &CurSFI->getSourceText()) - std::cout << " ->"; - } - - std::cout << "\t" << std::string(LineStart, LineEnd) << "\n"; - return false; -} - -/// printProgramLocation - Print a line of the place where the current stack -/// frame has stopped and the source line it is on. -/// -void CLIDebugger::printProgramLocation(bool PrintLocation) { - assert(Dbg.isProgramLoaded() && Dbg.isProgramRunning() && - "Error program is not loaded and running!"); - - // Figure out where the program stopped... - StackFrame &SF = getRuntimeInfo().getCurrentFrame(); - unsigned LineNo, ColNo; - const SourceFileInfo *FileDesc; - SF.getSourceLocation(LineNo, ColNo, FileDesc); - - // If requested, print out some program information about WHERE we are. - if (PrintLocation) { - // FIXME: print the current function arguments - if (const GlobalVariable *FuncDesc = SF.getFunctionDesc()) - std::cout << getProgramInfo().getFunction(FuncDesc).getSymbolicName(); - else - std::cout << "<unknown function>"; - - CurrentFile = &FileDesc->getSourceText(); - - std::cout << " at " << CurrentFile->getFilename() << ":" << LineNo; - if (ColNo) std::cout << ":" << ColNo; - std::cout << "\n"; - } - - if (printSourceLine(LineNo)) - std::cout << "<could not load source file>\n"; - else { - LineListedStart = LineNo-ListSize/2+1; - if ((int)LineListedStart < 1) LineListedStart = 1; - LineListedEnd = LineListedStart+1; - } -} - -/// eliminateRunInfo - We are about to run the program. Forget any state -/// about how the program used to be stopped. -void CLIDebugger::eliminateRunInfo() { - delete TheRuntimeInfo; - TheRuntimeInfo = 0; -} - -/// programStoppedSuccessfully - This method updates internal data -/// structures to reflect the fact that the program just executed a while, -/// and has successfully stopped. -void CLIDebugger::programStoppedSuccessfully() { - assert(TheRuntimeInfo==0 && "Someone forgot to release the old RuntimeInfo!"); - - TheRuntimeInfo = new RuntimeInfo(TheProgramInfo, Dbg.getRunningProcess()); - - // FIXME: if there are any breakpoints at the current location, print them as - // well. - - // Since the program as successfully stopped, print its location. - void *CurrentFrame = getRuntimeInfo().getCurrentFrame().getFrameID(); - printProgramLocation(CurrentFrame != LastCurrentFrame); - LastCurrentFrame = CurrentFrame; -} - - - -/// getUnsignedIntegerOption - Get an unsigned integer number from the Val -/// string. Check to make sure that the string contains an unsigned integer -/// token, and if not, throw an exception. If isOnlyOption is set, also throw -/// an exception if there is extra junk at the end of the string. -static unsigned getUnsignedIntegerOption(const char *Msg, std::string &Val, - bool isOnlyOption = true) { - std::string Tok = getToken(Val); - if (Tok.empty() || (isOnlyOption && !getToken(Val).empty())) - throw std::string(Msg) + " expects an unsigned integer argument."; - - char *EndPtr; - unsigned Result = strtoul(Tok.c_str(), &EndPtr, 0); - if (EndPtr != Tok.c_str()+Tok.size()) - throw std::string(Msg) + " expects an unsigned integer argument."; - - return Result; -} - -/// getOptionalUnsignedIntegerOption - This method is just like -/// getUnsignedIntegerOption, but if the argument value is not specified, a -/// default is returned instead of causing an error. -static unsigned -getOptionalUnsignedIntegerOption(const char *Msg, unsigned Default, - std::string &Val, bool isOnlyOption = true) { - // Check to see if the value was specified... - std::string TokVal = getToken(Val); - if (TokVal.empty()) return Default; - - // If it was specified, add it back to the value we are parsing... - Val = TokVal+Val; - - // And parse normally. - return getUnsignedIntegerOption(Msg, Val, isOnlyOption); -} - - -/// parseProgramOptions - This method parses the Options string and loads it -/// as options to be passed to the program. This is used by the run command -/// and by 'set args'. -void CLIDebugger::parseProgramOptions(std::string &Options) { - // FIXME: tokenizing by whitespace is clearly incorrect. Instead we should - // honor quotes and other things that a shell would. Also in the future we - // should support redirection of standard IO. - - std::vector<std::string> Arguments; - for (std::string A = getToken(Options); !A.empty(); A = getToken(Options)) - Arguments.push_back(A); - Dbg.setProgramArguments(Arguments.begin(), Arguments.end()); -} - - -//===----------------------------------------------------------------------===// -// Program startup and shutdown options -//===----------------------------------------------------------------------===// - - -/// file command - If the user specifies an option, search the PATH for the -/// specified program/bitcode file and load it. If the user does not specify -/// an option, unload the current program. -void CLIDebugger::fileCommand(std::string &Options) { - std::string Prog = getToken(Options); - if (!getToken(Options).empty()) - throw "file command takes at most one argument."; - - // Check to make sure the user knows what they are doing - if (Dbg.isProgramRunning() && - !askYesNo("A program is already loaded. Kill it?")) - return; - - // Unload an existing program. This kills the program if necessary. - eliminateRunInfo(); - delete TheProgramInfo; - TheProgramInfo = 0; - Dbg.unloadProgram(); - CurrentFile = 0; - - // If requested, start the new program. - if (Prog.empty()) { - std::cout << "Unloaded program.\n"; - } else { - std::cout << "Loading program... " << std::flush; - Dbg.loadProgram(Prog, Context); - assert(Dbg.isProgramLoaded() && - "loadProgram succeeded, but not program loaded!"); - TheProgramInfo = new ProgramInfo(Dbg.getProgram()); - std::cout << "successfully loaded '" << Dbg.getProgramPath() << "'!\n"; - } -} - - -void CLIDebugger::createCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "create command does not take any arguments."; - if (!Dbg.isProgramLoaded()) throw "No program loaded."; - if (Dbg.isProgramRunning() && - !askYesNo("The program is already running. Restart from the beginning?")) - return; - - // Start the program running. - startProgramRunning(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::killCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "kill command does not take any arguments."; - if (!Dbg.isProgramRunning()) - throw "No program is currently being run."; - - if (askYesNo("Kill the program being debugged?")) - Dbg.killProgram(); - eliminateRunInfo(); -} - -void CLIDebugger::quitCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "quit command does not take any arguments."; - - if (Dbg.isProgramRunning() && - !askYesNo("The program is running. Exit anyway?")) - return; - - // Throw exception to get out of the user-input loop. - throw 0; -} - - -//===----------------------------------------------------------------------===// -// Program execution commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::runCommand(std::string &Options) { - if (!Dbg.isProgramLoaded()) throw "No program loaded."; - if (Dbg.isProgramRunning() && - !askYesNo("The program is already running. Restart from the beginning?")) - return; - - // Parse all of the options to the run command, which specify program - // arguments to run with. - parseProgramOptions(Options); - - eliminateRunInfo(); - - // Start the program running. - startProgramRunning(); - - // Start the program running... - Options = ""; - contCommand(Options); -} - -void CLIDebugger::contCommand(std::string &Options) { - if (!getToken(Options).empty()) throw "cont argument not supported yet."; - if (!Dbg.isProgramRunning()) throw "Program is not running."; - - eliminateRunInfo(); - - Dbg.contProgram(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::stepCommand(std::string &Options) { - if (!Dbg.isProgramRunning()) throw "Program is not running."; - - // Figure out how many times to step. - unsigned Amount = - getOptionalUnsignedIntegerOption("'step' command", 1, Options); - - eliminateRunInfo(); - - // Step the specified number of times. - for (; Amount; --Amount) - Dbg.stepProgram(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::nextCommand(std::string &Options) { - if (!Dbg.isProgramRunning()) throw "Program is not running."; - unsigned Amount = - getOptionalUnsignedIntegerOption("'next' command", 1, Options); - - eliminateRunInfo(); - - for (; Amount; --Amount) - Dbg.nextProgram(); - - // The program stopped! - programStoppedSuccessfully(); -} - -void CLIDebugger::finishCommand(std::string &Options) { - if (!getToken(Options).empty()) - throw "finish command does not take any arguments."; - if (!Dbg.isProgramRunning()) throw "Program is not running."; - - // Figure out where we are exactly. If the user requests that we return from - // a frame that is not the top frame, make sure we get it. - void *CurrentFrame = getRuntimeInfo().getCurrentFrame().getFrameID(); - - eliminateRunInfo(); - - Dbg.finishProgram(CurrentFrame); - - // The program stopped! - programStoppedSuccessfully(); -} - -//===----------------------------------------------------------------------===// -// Stack frame commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::backtraceCommand(std::string &Options) { - // Accepts "full", n, -n - if (!getToken(Options).empty()) - throw "FIXME: bt command argument not implemented yet!"; - - RuntimeInfo &RI = getRuntimeInfo(); - ProgramInfo &PI = getProgramInfo(); - - try { - for (unsigned i = 0; ; ++i) { - StackFrame &SF = RI.getStackFrame(i); - std::cout << "#" << i; - if (i == RI.getCurrentFrameIdx()) - std::cout << " ->"; - std::cout << "\t" << SF.getFrameID() << " in "; - if (const GlobalVariable *G = SF.getFunctionDesc()) - std::cout << PI.getFunction(G).getSymbolicName(); - - unsigned LineNo, ColNo; - const SourceFileInfo *SFI; - SF.getSourceLocation(LineNo, ColNo, SFI); - if (!SFI->getBaseName().empty()) { - std::cout << " at " << SFI->getBaseName(); - if (LineNo) { - std::cout << ":" << LineNo; - if (ColNo) - std::cout << ":" << ColNo; - } - } - - // FIXME: when we support shared libraries, we should print ' from foo.so' - // if the stack frame is from a different object than the current one. - - std::cout << "\n"; - } - } catch (...) { - // Stop automatically when we run off the bottom of the stack. - } -} - -void CLIDebugger::upCommand(std::string &Options) { - unsigned Num = - getOptionalUnsignedIntegerOption("'up' command", 1, Options); - - RuntimeInfo &RI = getRuntimeInfo(); - unsigned CurFrame = RI.getCurrentFrameIdx(); - - // Check to see if we go can up the specified number of frames. - try { - RI.getStackFrame(CurFrame+Num); - } catch (...) { - if (Num == 1) - throw "Initial frame selected; you cannot go up."; - else - throw "Cannot go up " + utostr(Num) + " frames!"; - } - - RI.setCurrentFrameIdx(CurFrame+Num); - printProgramLocation(); -} - -void CLIDebugger::downCommand(std::string &Options) { - unsigned Num = - getOptionalUnsignedIntegerOption("'down' command", 1, Options); - - RuntimeInfo &RI = getRuntimeInfo(); - unsigned CurFrame = RI.getCurrentFrameIdx(); - - // Check to see if we can go up the specified number of frames. - if (CurFrame < Num) { - if (Num == 1) - throw "Bottom (i.e., innermost) frame selected; you cannot go down."; - else - throw "Cannot go down " + utostr(Num) + " frames!"; - } - - RI.setCurrentFrameIdx(CurFrame-Num); - printProgramLocation(); -} - -void CLIDebugger::frameCommand(std::string &Options) { - RuntimeInfo &RI = getRuntimeInfo(); - unsigned CurFrame = RI.getCurrentFrameIdx(); - - unsigned Num = - getOptionalUnsignedIntegerOption("'frame' command", CurFrame, Options); - - // Check to see if we go to the specified frame. - RI.getStackFrame(Num); - - RI.setCurrentFrameIdx(Num); - printProgramLocation(); -} - - -//===----------------------------------------------------------------------===// -// Breakpoint related commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::breakCommand(std::string &Options) { - // Figure out where the user wants a breakpoint. - const SourceFile *File; - unsigned LineNo; - - // Check to see if the user specified a line specifier. - std::string Option = getToken(Options); // strip whitespace - if (!Option.empty()) { - Options = Option + Options; // reconstruct string - - // Parse the line specifier. - parseLineSpec(Options, File, LineNo); - } else { - // Build a line specifier for the current stack frame. - throw "FIXME: breaking at the current location is not implemented yet!"; - } - - if (!File) File = CurrentFile; - if (File == 0) - throw "Unknown file to place breakpoint!"; - - std::cerr << "Break: " << File->getFilename() << ":" << LineNo << "\n"; - - throw "breakpoints not implemented yet!"; -} - -//===----------------------------------------------------------------------===// -// Miscellaneous commands -//===----------------------------------------------------------------------===// - -void CLIDebugger::infoCommand(std::string &Options) { - std::string What = getToken(Options); - - if (What.empty() || !getToken(Options).empty()){ - std::string infoStr("info"); - helpCommand(infoStr); - return; - } - - if (What == "frame") { - } else if (What == "functions") { - const std::map<const GlobalVariable*, SourceFunctionInfo*> &Functions - = getProgramInfo().getSourceFunctions(); - std::cout << "All defined functions:\n"; - // FIXME: GDB groups these by source file. We could do that I guess. - for (std::map<const GlobalVariable*, SourceFunctionInfo*>::const_iterator - I = Functions.begin(), E = Functions.end(); I != E; ++I) { - std::cout << I->second->getSymbolicName() << "\n"; - } - - } else if (What == "source") { - if (CurrentFile == 0) - throw "No current source file."; - - // Get the SourceFile information for the current file. - const SourceFileInfo &SF = - getProgramInfo().getSourceFile(CurrentFile->getDescriptor()); - - std::cout << "Current source file is: " << SF.getBaseName() << "\n" - << "Compilation directory is: " << SF.getDirectory() << "\n"; - if (unsigned NL = CurrentFile->getNumLines()) - std::cout << "Located in: " << CurrentFile->getFilename() << "\n" - << "Contains " << NL << " lines\n"; - else - std::cout << "Could not find source file.\n"; - std::cout << "Source language is " - << SF.getLanguage().getSourceLanguageName() << "\n"; - - } else if (What == "sources") { - const std::map<const GlobalVariable*, SourceFileInfo*> &SourceFiles = - getProgramInfo().getSourceFiles(); - std::cout << "Source files for the program:\n"; - for (std::map<const GlobalVariable*, SourceFileInfo*>::const_iterator I = - SourceFiles.begin(), E = SourceFiles.end(); I != E;) { - std::cout << I->second->getDirectory() << "/" - << I->second->getBaseName(); - ++I; - if (I != E) std::cout << ", "; - } - std::cout << "\n"; - } else if (What == "target") { - std::cout << Dbg.getRunningProcess().getStatus(); - } else { - // See if this is something handled by the current language. - if (getCurrentLanguage().printInfo(What)) - return; - - throw "Unknown info command '" + What + "'. Try 'help info'."; - } -} - -/// parseLineSpec - Parses a line specifier, for use by the 'list' command. -/// If SourceFile is returned as a void pointer, then it was not specified. -/// If the line specifier is invalid, an exception is thrown. -void CLIDebugger::parseLineSpec(std::string &LineSpec, - const SourceFile *&SourceFile, - unsigned &LineNo) { - SourceFile = 0; - LineNo = 0; - - // First, check to see if we have a : separator. - std::string FirstPart = getToken(LineSpec, ":"); - std::string SecondPart = getToken(LineSpec, ":"); - if (!getToken(LineSpec).empty()) throw "Malformed line specification!"; - - // If there is no second part, we must have either "function", "number", - // "+offset", or "-offset". - if (SecondPart.empty()) { - if (FirstPart.empty()) throw "Malformed line specification!"; - if (FirstPart[0] == '+') { - FirstPart.erase(FirstPart.begin(), FirstPart.begin()+1); - // For +n, return LineListedEnd+n - LineNo = LineListedEnd + - getUnsignedIntegerOption("Line specifier '+'", FirstPart); - - } else if (FirstPart[0] == '-') { - FirstPart.erase(FirstPart.begin(), FirstPart.begin()+1); - // For -n, return LineListedEnd-n - LineNo = LineListedEnd - - getUnsignedIntegerOption("Line specifier '-'", FirstPart); - if ((int)LineNo < 1) LineNo = 1; - } else if (FirstPart[0] == '*') { - throw "Address expressions not supported as source locations!"; - } else { - // Ok, check to see if this is just a line number. - std::string Saved = FirstPart; - try { - LineNo = getUnsignedIntegerOption("", Saved); - } catch (...) { - // Ok, it's not a valid line number. It must be a source-language - // entity name. - std::string Name = getToken(FirstPart); - if (!getToken(FirstPart).empty()) - throw "Extra junk in line specifier after '" + Name + "'."; - SourceFunctionInfo *SFI = - getCurrentLanguage().lookupFunction(Name, getProgramInfo(), - TheRuntimeInfo); - if (SFI == 0) - throw "Unknown identifier '" + Name + "'."; - - unsigned L, C; - SFI->getSourceLocation(L, C); - if (L == 0) throw "Could not locate '" + Name + "'!"; - LineNo = L; - SourceFile = &SFI->getSourceFile().getSourceText(); - return; - } - } - - } else { - // Ok, this must be a filename qualified line number or function name. - // First, figure out the source filename. - std::string SourceFilename = getToken(FirstPart); - if (!getToken(FirstPart).empty()) - throw "Invalid filename qualified source location!"; - - // Next, check to see if this is just a line number. - std::string Saved = SecondPart; - try { - LineNo = getUnsignedIntegerOption("", Saved); - } catch (...) { - // Ok, it's not a valid line number. It must be a function name. - throw "FIXME: Filename qualified function names are not support " - "as line specifiers yet!"; - } - - // Ok, we got the line number. Now check out the source file name to make - // sure it's all good. If it is, return it. If not, throw exception. - SourceFile =&getProgramInfo().getSourceFile(SourceFilename).getSourceText(); - } -} - -void CLIDebugger::listCommand(std::string &Options) { - if (!Dbg.isProgramLoaded()) - throw "No program is loaded. Use the 'file' command."; - - // Handle "list foo," correctly, by returning " " as the second token - Options += " "; - - std::string FirstLineSpec = getToken(Options, ","); - std::string SecondLineSpec = getToken(Options, ","); - if (!getToken(Options, ",").empty()) - throw "list command only expects two source location specifiers!"; - - // StartLine, EndLine - The starting and ending line numbers to print. - unsigned StartLine = 0, EndLine = 0; - - if (SecondLineSpec.empty()) { // No second line specifier provided? - // Handle special forms like "", "+", "-", etc. - std::string TmpSpec = FirstLineSpec; - std::string Tok = getToken(TmpSpec); - if (getToken(TmpSpec).empty() && (Tok == "" || Tok == "+" || Tok == "-")) { - if (Tok == "+" || Tok == "") { - StartLine = LineListedEnd; - EndLine = StartLine + ListSize; - } else { - assert(Tok == "-"); - StartLine = LineListedStart-ListSize; - EndLine = LineListedStart; - if ((int)StartLine <= 0) StartLine = 1; - } - } else { - // Must be a normal line specifier. - const SourceFile *File; - unsigned LineNo; - parseLineSpec(FirstLineSpec, File, LineNo); - - // If the user only specified one file specifier, we should display - // ListSize lines centered at the specified line. - if (File != 0) CurrentFile = File; - StartLine = LineNo - (ListSize+1)/2; - if ((int)StartLine <= 0) StartLine = 1; - EndLine = StartLine + ListSize; - } - - } else { - // Parse two line specifiers... - const SourceFile *StartFile, *EndFile; - unsigned StartLineNo, EndLineNo; - parseLineSpec(FirstLineSpec, StartFile, StartLineNo); - unsigned SavedLLE = LineListedEnd; - LineListedEnd = StartLineNo; - try { - parseLineSpec(SecondLineSpec, EndFile, EndLineNo); - } catch (...) { - LineListedEnd = SavedLLE; - throw; - } - - // Inherit file specified by the first line spec if there was one. - if (EndFile == 0) EndFile = StartFile; - - if (StartFile != EndFile) - throw "Start and end line specifiers are in different files!"; - CurrentFile = StartFile; - StartLine = StartLineNo; - EndLine = EndLineNo+1; - } - - assert((int)StartLine > 0 && (int)EndLine > 0 && StartLine <= EndLine && - "Error reading line specifiers!"); - - // If there was no current file, and the user didn't specify one to list, we - // have an error. - if (CurrentFile == 0) - throw "There is no current file to list."; - - // Remember for next time. - LineListedStart = StartLine; - LineListedEnd = StartLine; - - for (unsigned LineNo = StartLine; LineNo != EndLine; ++LineNo) { - // Print the source line, unless it is invalid. - if (printSourceLine(LineNo)) - break; - LineListedEnd = LineNo+1; - } - - // If we didn't print any lines, find out why. - if (LineListedEnd == StartLine) { - // See if we can read line #0 from the file, if not, we couldn't load the - // file. - const char *LineStart, *LineEnd; - CurrentFile->getSourceLine(0, LineStart, LineEnd); - if (LineStart == 0) - throw "Could not load source file '" + CurrentFile->getFilename() + "'!"; - else - std::cout << "<end of file>\n"; - } -} - -void CLIDebugger::setCommand(std::string &Options) { - std::string What = getToken(Options); - - if (What.empty()) - throw "set command expects at least two arguments."; - if (What == "args") { - parseProgramOptions(Options); - } else if (What == "language") { - std::string Lang = getToken(Options); - if (!getToken(Options).empty()) - throw "set language expects one argument at most."; - if (Lang == "") { - std::cout << "The currently understood settings are:\n\n" - << "local or auto Automatic setting based on source file\n" - << "c Use the C language\n" - << "c++ Use the C++ language\n" - << "unknown Use when source language is not supported\n"; - } else if (Lang == "local" || Lang == "auto") { - CurrentLanguage = 0; - } else if (Lang == "c") { - CurrentLanguage = &SourceLanguage::getCFamilyInstance(); - } else if (Lang == "c++") { - CurrentLanguage = &SourceLanguage::getCPlusPlusInstance(); - } else if (Lang == "unknown") { - CurrentLanguage = &SourceLanguage::getUnknownLanguageInstance(); - } else { - throw "Unknown language '" + Lang + "'."; - } - - } else if (What == "listsize") { - ListSize = getUnsignedIntegerOption("'set prompt' command", Options); - } else if (What == "prompt") { - // Include any trailing whitespace or other tokens, but not leading - // whitespace. - Prompt = getToken(Options); // Strip leading whitespace - Prompt += Options; // Keep trailing whitespace or other stuff - } else { - // FIXME: Try to parse this as a source-language program expression. - throw "Don't know how to set '" + What + "'!"; - } -} - -void CLIDebugger::showCommand(std::string &Options) { - std::string What = getToken(Options); - - if (What.empty() || !getToken(Options).empty()) - throw "show command expects one argument."; - - if (What == "args") { - std::cout << "Argument list to give program when started is \""; - // FIXME: This doesn't print stuff correctly if the arguments have spaces in - // them, but currently the only way to get that is to use the --args command - // line argument. This should really handle escaping all hard characters as - // needed. - for (unsigned i = 0, e = Dbg.getNumProgramArguments(); i != e; ++i) - std::cout << (i ? " " : "") << Dbg.getProgramArgument(i); - std::cout << "\"\n"; - - } else if (What == "language") { - std::cout << "The current source language is '"; - if (CurrentLanguage) - std::cout << CurrentLanguage->getSourceLanguageName(); - else - std::cout << "auto; currently " - << getCurrentLanguage().getSourceLanguageName(); - std::cout << "'.\n"; - } else if (What == "listsize") { - std::cout << "Number of source lines llvm-db will list by default is " - << ListSize << ".\n"; - } else if (What == "prompt") { - std::cout << "llvm-db's prompt is \"" << Prompt << "\".\n"; - } else { - throw "Unknown show command '" + What + "'. Try 'help show'."; - } -} - -void CLIDebugger::helpCommand(std::string &Options) { - // Print out all of the commands in the CommandTable - std::string Command = getToken(Options); - if (!getToken(Options).empty()) - throw "help command takes at most one argument."; - - // Getting detailed help on a particular command? - if (!Command.empty()) { - CLICommand *C = getCommand(Command); - std::cout << C->getShortHelp() << ".\n" << C->getLongHelp(); - - // If there are aliases for this option, print them out. - const std::vector<std::string> &Names = C->getOptionNames(); - if (Names.size() > 1) { - std::cout << "The '" << Command << "' command is known as: '" - << Names[0] << "'"; - for (unsigned i = 1, e = Names.size(); i != e; ++i) - std::cout << ", '" << Names[i] << "'"; - std::cout << "\n"; - } - - } else { - unsigned MaxSize = 0; - for (std::map<std::string, CLICommand*>::iterator I = CommandTable.begin(), - E = CommandTable.end(); I != E; ++I) - if (I->first.size() > MaxSize && - I->first == I->second->getPrimaryOptionName()) - MaxSize = I->first.size(); - - // Loop over all of the commands, printing the short help version - for (std::map<std::string, CLICommand*>::iterator I = CommandTable.begin(), - E = CommandTable.end(); I != E; ++I) - if (I->first == I->second->getPrimaryOptionName()) - std::cout << I->first << std::string(MaxSize - I->first.size(), ' ') - << " - " << I->second->getShortHelp() << "\n"; - } -} diff --git a/tools/llvm-db/Makefile b/tools/llvm-db/Makefile deleted file mode 100644 index df81649..0000000 --- a/tools/llvm-db/Makefile +++ /dev/null @@ -1,15 +0,0 @@ -##===- tools/llvm-db/Makefile ------------------------------*- Makefile -*-===## -# -# The LLVM Compiler Infrastructure -# -# This file is distributed under the University of Illinois Open Source -# License. See LICENSE.TXT for details. -# -##===----------------------------------------------------------------------===## - -LEVEL = ../.. -TOOLNAME = llvm-db -LINK_COMPONENTS := debugger -REQUIRES_EH := 1 - -include $(LEVEL)/Makefile.common diff --git a/tools/llvm-db/llvm-db.cpp b/tools/llvm-db/llvm-db.cpp deleted file mode 100644 index 78dbf71..0000000 --- a/tools/llvm-db/llvm-db.cpp +++ /dev/null @@ -1,102 +0,0 @@ -//===- llvm-db.cpp - LLVM Debugger ----------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This utility implements a simple text-mode front-end to the LLVM debugger -// library. -// -//===----------------------------------------------------------------------===// - -#include "CLIDebugger.h" -#include "llvm/LLVMContext.h" -#include "llvm/Support/CommandLine.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/PrettyStackTrace.h" -#include "llvm/System/Signals.h" -#include <iostream> -using namespace llvm; - -namespace { - // Command line options for specifying the program to debug and options to use - cl::opt<std::string> - InputFile(cl::desc("<program>"), cl::Positional, cl::init("")); - - cl::list<std::string> - InputArgs("args", cl::Positional, cl::desc("<program and arguments>"), - cl::ZeroOrMore); - - // Command line options to control various directory related stuff - cl::list<std::string> - SourceDirectories("directory", cl::value_desc("directory"), - cl::desc("Add directory to the search for source files")); - cl::alias SDA("d", cl::desc("Alias for --directory"), - cl::aliasopt(SourceDirectories)); - - cl::opt<std::string> - WorkingDirectory("cd", cl::desc("Use directory as current working directory"), - cl::value_desc("directory")); - - // Command line options specific to the llvm-db debugger driver - cl::opt<bool> Quiet("quiet", cl::desc("Do not print introductory messages")); - cl::alias QA1("silent", cl::desc("Alias for -quiet"), cl::aliasopt(Quiet)); - cl::alias QA2("q", cl::desc("Alias for -quiet"), cl::aliasopt(Quiet)); -} - -//===----------------------------------------------------------------------===// -// main Driver function -// -int main(int argc, char **argv, char * const *envp) { - // Print a stack trace if we signal out. - sys::PrintStackTraceOnErrorSignal(); - PrettyStackTraceProgram X(argc, argv); - - LLVMContext Context; - llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. - std::cout << "NOTE: llvm-db is known useless right now.\n"; - try { - cl::ParseCommandLineOptions(argc, argv, - "llvm source-level debugger\n"); - - if (!Quiet) - std::cout << "llvm-db: The LLVM source-level debugger\n"; - - // Merge Inputfile and InputArgs into the InputArgs list... - if (!InputFile.empty() && InputArgs.empty()) - InputArgs.push_back(InputFile); - - // Create the CLI debugger... - CLIDebugger D(Context); - - // Initialize the debugger with the command line options we read... - Debugger &Dbg = D.getDebugger(); - - // Initialize the debugger environment. - Dbg.initializeEnvironment(envp); - Dbg.setWorkingDirectory(WorkingDirectory); - for (unsigned i = 0, e = SourceDirectories.size(); i != e; ++i) - D.addSourceDirectory(SourceDirectories[i]); - - if (!InputArgs.empty()) { - try { - D.fileCommand(InputArgs[0]); - } catch (const std::string &Error) { - std::cout << "Error: " << Error << "\n"; - } - - Dbg.setProgramArguments(InputArgs.begin()+1, InputArgs.end()); - } - - // Now that we have initialized the debugger, run it. - return D.run(); - } catch (const std::string& msg) { - std::cerr << argv[0] << ": " << msg << "\n"; - } catch (...) { - std::cerr << argv[0] << ": Unexpected unknown exception occurred.\n"; - } - return 1; -} diff --git a/tools/llvm-mc/AsmExpr.cpp b/tools/llvm-mc/AsmExpr.cpp deleted file mode 100644 index c3362e4..0000000 --- a/tools/llvm-mc/AsmExpr.cpp +++ /dev/null @@ -1,162 +0,0 @@ -//===- AsmExpr.cpp - Assembly file expressions ----------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "AsmExpr.h" -#include "llvm/MC/MCContext.h" -#include "llvm/MC/MCSymbol.h" -#include "llvm/MC/MCValue.h" -using namespace llvm; - -AsmExpr::~AsmExpr() { -} - -bool AsmExpr::EvaluateAsAbsolute(MCContext &Ctx, int64_t &Res) const { - MCValue Value; - - if (!EvaluateAsRelocatable(Ctx, Value) || !Value.isAbsolute()) - return false; - - Res = Value.getConstant(); - return true; -} - -static bool EvaluateSymbolicAdd(const MCValue &LHS, MCSymbol *RHS_A, - MCSymbol *RHS_B, int64_t RHS_Cst, - MCValue &Res) { - // We can't add or subtract two symbols. - if ((LHS.getSymA() && RHS_A) || - (LHS.getSymB() && RHS_B)) - return false; - - MCSymbol *A = LHS.getSymA() ? LHS.getSymA() : RHS_A; - MCSymbol *B = LHS.getSymB() ? LHS.getSymB() : RHS_B; - if (B) { - // If we have a negated symbol, then we must have also have a non-negated - // symbol in order to encode the expression. We can do this check later to - // permit expressions which eventually fold to a representable form -- such - // as (a + (0 - b)) -- if necessary. - if (!A) - return false; - } - Res = MCValue::get(A, B, LHS.getConstant() + RHS_Cst); - return true; -} - -bool AsmExpr::EvaluateAsRelocatable(MCContext &Ctx, MCValue &Res) const { - switch (getKind()) { - default: - assert(0 && "Invalid assembly expression kind!"); - - case Constant: - Res = MCValue::get(cast<AsmConstantExpr>(this)->getValue()); - return true; - - case SymbolRef: { - MCSymbol *Sym = cast<AsmSymbolRefExpr>(this)->getSymbol(); - if (const MCValue *Value = Ctx.GetSymbolValue(Sym)) - Res = *Value; - else - Res = MCValue::get(Sym, 0, 0); - return true; - } - - case Unary: { - const AsmUnaryExpr *AUE = cast<AsmUnaryExpr>(this); - MCValue Value; - - if (!AUE->getSubExpr()->EvaluateAsRelocatable(Ctx, Value)) - return false; - - switch (AUE->getOpcode()) { - case AsmUnaryExpr::LNot: - if (!Value.isAbsolute()) - return false; - Res = MCValue::get(!Value.getConstant()); - break; - case AsmUnaryExpr::Minus: - /// -(a - b + const) ==> (b - a - const) - if (Value.getSymA() && !Value.getSymA()) - return false; - Res = MCValue::get(Value.getSymB(), Value.getSymA(), - -Value.getConstant()); - break; - case AsmUnaryExpr::Not: - if (!Value.isAbsolute()) - return false; - Res = MCValue::get(~Value.getConstant()); - break; - case AsmUnaryExpr::Plus: - Res = Value; - break; - } - - return true; - } - - case Binary: { - const AsmBinaryExpr *ABE = cast<AsmBinaryExpr>(this); - MCValue LHSValue, RHSValue; - - if (!ABE->getLHS()->EvaluateAsRelocatable(Ctx, LHSValue) || - !ABE->getRHS()->EvaluateAsRelocatable(Ctx, RHSValue)) - return false; - - // We only support a few operations on non-constant expressions, handle - // those first. - if (!LHSValue.isAbsolute() || !RHSValue.isAbsolute()) { - switch (ABE->getOpcode()) { - default: - return false; - case AsmBinaryExpr::Sub: - // Negate RHS and add. - return EvaluateSymbolicAdd(LHSValue, - RHSValue.getSymB(), RHSValue.getSymA(), - -RHSValue.getConstant(), - Res); - - case AsmBinaryExpr::Add: - return EvaluateSymbolicAdd(LHSValue, - RHSValue.getSymA(), RHSValue.getSymB(), - RHSValue.getConstant(), - Res); - } - } - - // FIXME: We need target hooks for the evaluation. It may be limited in - // width, and gas defines the result of comparisons differently from Apple - // as (the result is sign extended). - int64_t LHS = LHSValue.getConstant(), RHS = RHSValue.getConstant(); - int64_t Result = 0; - switch (ABE->getOpcode()) { - case AsmBinaryExpr::Add: Result = LHS + RHS; break; - case AsmBinaryExpr::And: Result = LHS & RHS; break; - case AsmBinaryExpr::Div: Result = LHS / RHS; break; - case AsmBinaryExpr::EQ: Result = LHS == RHS; break; - case AsmBinaryExpr::GT: Result = LHS > RHS; break; - case AsmBinaryExpr::GTE: Result = LHS >= RHS; break; - case AsmBinaryExpr::LAnd: Result = LHS && RHS; break; - case AsmBinaryExpr::LOr: Result = LHS || RHS; break; - case AsmBinaryExpr::LT: Result = LHS < RHS; break; - case AsmBinaryExpr::LTE: Result = LHS <= RHS; break; - case AsmBinaryExpr::Mod: Result = LHS % RHS; break; - case AsmBinaryExpr::Mul: Result = LHS * RHS; break; - case AsmBinaryExpr::NE: Result = LHS != RHS; break; - case AsmBinaryExpr::Or: Result = LHS | RHS; break; - case AsmBinaryExpr::Shl: Result = LHS << RHS; break; - case AsmBinaryExpr::Shr: Result = LHS >> RHS; break; - case AsmBinaryExpr::Sub: Result = LHS - RHS; break; - case AsmBinaryExpr::Xor: Result = LHS ^ RHS; break; - } - - Res = MCValue::get(Result); - return true; - } - } -} - diff --git a/tools/llvm-mc/AsmExpr.h b/tools/llvm-mc/AsmExpr.h deleted file mode 100644 index 84e58ff..0000000 --- a/tools/llvm-mc/AsmExpr.h +++ /dev/null @@ -1,179 +0,0 @@ -//===- AsmExpr.h - Assembly file expressions --------------------*- C++ -*-===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef ASMEXPR_H -#define ASMEXPR_H - -#include "llvm/Support/Casting.h" -#include "llvm/Support/DataTypes.h" - -namespace llvm { -class MCContext; -class MCSymbol; -class MCValue; - -/// AsmExpr - Base class for the full range of assembler expressions which are -/// needed for parsing. -class AsmExpr { -public: - enum AsmExprKind { - Binary, ///< Binary expressions. - Constant, ///< Constant expressions. - SymbolRef, ///< References to labels and assigned expressions. - Unary ///< Unary expressions. - }; - -private: - AsmExprKind Kind; - -protected: - AsmExpr(AsmExprKind _Kind) : Kind(_Kind) {} - -public: - virtual ~AsmExpr(); - - AsmExprKind getKind() const { return Kind; } - - /// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value. - /// - /// @param Res - The absolute value, if evaluation succeeds. - /// @result - True on success. - bool EvaluateAsAbsolute(MCContext &Ctx, int64_t &Res) const; - - /// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable - /// value, i.e. an expression of the fixed form (a - b + constant). - /// - /// @param Res - The relocatable value, if evaluation succeeds. - /// @result - True on success. - bool EvaluateAsRelocatable(MCContext &Ctx, MCValue &Res) const; - - static bool classof(const AsmExpr *) { return true; } -}; - -//// AsmConstantExpr - Represent a constant integer expression. -class AsmConstantExpr : public AsmExpr { - int64_t Value; - -public: - AsmConstantExpr(int64_t _Value) - : AsmExpr(AsmExpr::Constant), Value(_Value) {} - - int64_t getValue() const { return Value; } - - static bool classof(const AsmExpr *E) { - return E->getKind() == AsmExpr::Constant; - } - static bool classof(const AsmConstantExpr *) { return true; } -}; - -/// AsmSymbolRefExpr - Represent a reference to a symbol from inside an -/// expression. -/// -/// A symbol reference in an expression may be a use of a label, a use of an -/// assembler variable (defined constant), or constitute an implicit definition -/// of the symbol as external. -class AsmSymbolRefExpr : public AsmExpr { - MCSymbol *Symbol; - -public: - AsmSymbolRefExpr(MCSymbol *_Symbol) - : AsmExpr(AsmExpr::SymbolRef), Symbol(_Symbol) {} - - MCSymbol *getSymbol() const { return Symbol; } - - static bool classof(const AsmExpr *E) { - return E->getKind() == AsmExpr::SymbolRef; - } - static bool classof(const AsmSymbolRefExpr *) { return true; } -}; - -/// AsmUnaryExpr - Unary assembler expressions. -class AsmUnaryExpr : public AsmExpr { -public: - enum Opcode { - LNot, ///< Logical negation. - Minus, ///< Unary minus. - Not, ///< Bitwise negation. - Plus ///< Unary plus. - }; - -private: - Opcode Op; - AsmExpr *Expr; - -public: - AsmUnaryExpr(Opcode _Op, AsmExpr *_Expr) - : AsmExpr(AsmExpr::Unary), Op(_Op), Expr(_Expr) {} - ~AsmUnaryExpr() { - delete Expr; - } - - Opcode getOpcode() const { return Op; } - - AsmExpr *getSubExpr() const { return Expr; } - - static bool classof(const AsmExpr *E) { - return E->getKind() == AsmExpr::Unary; - } - static bool classof(const AsmUnaryExpr *) { return true; } -}; - -/// AsmBinaryExpr - Binary assembler expressions. -class AsmBinaryExpr : public AsmExpr { -public: - enum Opcode { - Add, ///< Addition. - And, ///< Bitwise and. - Div, ///< Division. - EQ, ///< Equality comparison. - GT, ///< Greater than comparison. - GTE, ///< Greater than or equal comparison. - LAnd, ///< Logical and. - LOr, ///< Logical or. - LT, ///< Less than comparison. - LTE, ///< Less than or equal comparison. - Mod, ///< Modulus. - Mul, ///< Multiplication. - NE, ///< Inequality comparison. - Or, ///< Bitwise or. - Shl, ///< Bitwise shift left. - Shr, ///< Bitwise shift right. - Sub, ///< Subtraction. - Xor ///< Bitwise exclusive or. - }; - -private: - Opcode Op; - AsmExpr *LHS, *RHS; - -public: - AsmBinaryExpr(Opcode _Op, AsmExpr *_LHS, AsmExpr *_RHS) - : AsmExpr(AsmExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {} - ~AsmBinaryExpr() { - delete LHS; - delete RHS; - } - - Opcode getOpcode() const { return Op; } - - /// getLHS - Get the left-hand side expression of the binary operator. - AsmExpr *getLHS() const { return LHS; } - - /// getRHS - Get the right-hand side expression of the binary operator. - AsmExpr *getRHS() const { return RHS; } - - static bool classof(const AsmExpr *E) { - return E->getKind() == AsmExpr::Binary; - } - static bool classof(const AsmBinaryExpr *) { return true; } -}; - -} // end namespace llvm - -#endif diff --git a/tools/llvm-mc/MC-X86Specific.cpp b/tools/llvm-mc/MC-X86Specific.cpp deleted file mode 100644 index fec13ce..0000000 --- a/tools/llvm-mc/MC-X86Specific.cpp +++ /dev/null @@ -1,266 +0,0 @@ -//===- MC-X86Specific.cpp - X86-Specific code for MC ----------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// -// -// This file implements X86-specific parsing, encoding and decoding stuff for -// MC. -// -//===----------------------------------------------------------------------===// - -#include "AsmParser.h" -#include "llvm/MC/MCInst.h" -#include "llvm/Support/SourceMgr.h" -using namespace llvm; - -/// X86Operand - Instances of this class represent one X86 machine instruction. -struct AsmParser::X86Operand { - enum { - Register, - Immediate, - Memory - } Kind; - - union { - struct { - unsigned RegNo; - } Reg; - - struct { - MCValue Val; - } Imm; - - struct { - unsigned SegReg; - MCValue Disp; - unsigned BaseReg; - unsigned IndexReg; - unsigned Scale; - } Mem; - }; - - unsigned getReg() const { - assert(Kind == Register && "Invalid access!"); - return Reg.RegNo; - } - - static X86Operand CreateReg(unsigned RegNo) { - X86Operand Res; - Res.Kind = Register; - Res.Reg.RegNo = RegNo; - return Res; - } - static X86Operand CreateImm(MCValue Val) { - X86Operand Res; - Res.Kind = Immediate; - Res.Imm.Val = Val; - return Res; - } - static X86Operand CreateMem(unsigned SegReg, MCValue Disp, unsigned BaseReg, - unsigned IndexReg, unsigned Scale) { - // If there is no index register, we should never have a scale, and we - // should always have a scale (in {1,2,4,8}) if we do. - assert(((Scale == 0 && !IndexReg) || - (IndexReg && (Scale == 1 || Scale == 2 || - Scale == 4 || Scale == 8))) && - "Invalid scale!"); - X86Operand Res; - Res.Kind = Memory; - Res.Mem.SegReg = SegReg; - Res.Mem.Disp = Disp; - Res.Mem.BaseReg = BaseReg; - Res.Mem.IndexReg = IndexReg; - Res.Mem.Scale = Scale; - return Res; - } -}; - -bool AsmParser::ParseX86Register(X86Operand &Op) { - assert(Lexer.getKind() == asmtok::Register && "Invalid token kind!"); - - // FIXME: Decode register number. - Op = X86Operand::CreateReg(123); - Lexer.Lex(); // Eat register token. - - return false; -} - -bool AsmParser::ParseX86Operand(X86Operand &Op) { - switch (Lexer.getKind()) { - default: - return ParseX86MemOperand(Op); - case asmtok::Register: - // FIXME: if a segment register, this could either be just the seg reg, or - // the start of a memory operand. - return ParseX86Register(Op); - case asmtok::Dollar: { - // $42 -> immediate. - Lexer.Lex(); - MCValue Val; - if (ParseRelocatableExpression(Val)) - return true; - Op = X86Operand::CreateImm(Val); - return false; - } - case asmtok::Star: { - Lexer.Lex(); // Eat the star. - - if (Lexer.is(asmtok::Register)) { - if (ParseX86Register(Op)) - return true; - } else if (ParseX86MemOperand(Op)) - return true; - - // FIXME: Note the '*' in the operand for use by the matcher. - return false; - } - } -} - -/// ParseX86MemOperand: segment: disp(basereg, indexreg, scale) -bool AsmParser::ParseX86MemOperand(X86Operand &Op) { - // FIXME: If SegReg ':' (e.g. %gs:), eat and remember. - unsigned SegReg = 0; - - // We have to disambiguate a parenthesized expression "(4+5)" from the start - // of a memory operand with a missing displacement "(%ebx)" or "(,%eax)". The - // only way to do this without lookahead is to eat the ( and see what is after - // it. - MCValue Disp = MCValue::get(0, 0, 0); - if (Lexer.isNot(asmtok::LParen)) { - if (ParseRelocatableExpression(Disp)) return true; - - // After parsing the base expression we could either have a parenthesized - // memory address or not. If not, return now. If so, eat the (. - if (Lexer.isNot(asmtok::LParen)) { - Op = X86Operand::CreateMem(SegReg, Disp, 0, 0, 0); - return false; - } - - // Eat the '('. - Lexer.Lex(); - } else { - // Okay, we have a '('. We don't know if this is an expression or not, but - // so we have to eat the ( to see beyond it. - Lexer.Lex(); // Eat the '('. - - if (Lexer.is(asmtok::Register) || Lexer.is(asmtok::Comma)) { - // Nothing to do here, fall into the code below with the '(' part of the - // memory operand consumed. - } else { - // It must be an parenthesized expression, parse it now. - if (ParseParenRelocatableExpression(Disp)) - return true; - - // After parsing the base expression we could either have a parenthesized - // memory address or not. If not, return now. If so, eat the (. - if (Lexer.isNot(asmtok::LParen)) { - Op = X86Operand::CreateMem(SegReg, Disp, 0, 0, 0); - return false; - } - - // Eat the '('. - Lexer.Lex(); - } - } - - // If we reached here, then we just ate the ( of the memory operand. Process - // the rest of the memory operand. - unsigned BaseReg = 0, IndexReg = 0, Scale = 0; - - if (Lexer.is(asmtok::Register)) { - if (ParseX86Register(Op)) - return true; - BaseReg = Op.getReg(); - } - - if (Lexer.is(asmtok::Comma)) { - Lexer.Lex(); // Eat the comma. - - // Following the comma we should have either an index register, or a scale - // value. We don't support the later form, but we want to parse it - // correctly. - // - // Not that even though it would be completely consistent to support syntax - // like "1(%eax,,1)", the assembler doesn't. - if (Lexer.is(asmtok::Register)) { - if (ParseX86Register(Op)) - return true; - IndexReg = Op.getReg(); - Scale = 1; // If not specified, the scale defaults to 1. - - if (Lexer.isNot(asmtok::RParen)) { - // Parse the scale amount: - // ::= ',' [scale-expression] - if (Lexer.isNot(asmtok::Comma)) - return true; - Lexer.Lex(); // Eat the comma. - - if (Lexer.isNot(asmtok::RParen)) { - int64_t ScaleVal; - if (ParseAbsoluteExpression(ScaleVal)) - return true; - - // Validate the scale amount. - if (ScaleVal != 1 && ScaleVal != 2 && ScaleVal != 4 && ScaleVal != 8) - return TokError("scale factor in address must be 1, 2, 4 or 8"); - Scale = (unsigned)ScaleVal; - } - } - } else if (Lexer.isNot(asmtok::RParen)) { - // Otherwise we have the unsupported form of a scale amount without an - // index. - SMLoc Loc = Lexer.getLoc(); - - int64_t Value; - if (ParseAbsoluteExpression(Value)) - return true; - - return Error(Loc, "cannot have scale factor without index register"); - } - } - - // Ok, we've eaten the memory operand, verify we have a ')' and eat it too. - if (Lexer.isNot(asmtok::RParen)) - return TokError("unexpected token in memory operand"); - Lexer.Lex(); // Eat the ')'. - - Op = X86Operand::CreateMem(SegReg, Disp, BaseReg, IndexReg, Scale); - return false; -} - -/// MatchX86Inst - Convert a parsed instruction name and operand list into a -/// concrete instruction. -static bool MatchX86Inst(const char *Name, - llvm::SmallVector<AsmParser::X86Operand, 3> &Operands, - MCInst &Inst) { - return false; -} - -/// ParseX86InstOperands - Parse the operands of an X86 instruction and return -/// them as the operands of an MCInst. -bool AsmParser::ParseX86InstOperands(const char *InstName, MCInst &Inst) { - llvm::SmallVector<X86Operand, 3> Operands; - - if (Lexer.isNot(asmtok::EndOfStatement)) { - // Read the first operand. - Operands.push_back(X86Operand()); - if (ParseX86Operand(Operands.back())) - return true; - - while (Lexer.is(asmtok::Comma)) { - Lexer.Lex(); // Eat the comma. - - // Parse and remember the operand. - Operands.push_back(X86Operand()); - if (ParseX86Operand(Operands.back())) - return true; - } - } - - return MatchX86Inst(InstName, Operands, Inst); -} |