vendor/llvm/llvm-release_360-r226102

4 files changed, 0 insertions, 515 deletions

diff --git a/include/llvm/MC/MCAnalysis/MCAtom.h b/include/llvm/MC/MCAnalysis/MCAtom.h
deleted file mode 100644
index 33f3431a59a9..000000000000
--- a/include/llvm/MC/MCAnalysis/MCAtom.h
+++ /dev/null
@@ -1,199 +0,0 @@
-//===-- MCAtom.h ------------------------------------------------*- C++ -*-===//
-//
-//                     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 declaration of the MCAtom class, which is used to
-// represent a contiguous region in a decoded object that is uniformly data or
-// instructions.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCANALYSIS_MCATOM_H
-#define LLVM_MC_MCANALYSIS_MCATOM_H
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/MC/MCInst.h"
-#include "llvm/Support/DataTypes.h"
-#include <vector>
-
-namespace llvm {
-
-class MCModule;
-
-class MCAtom;
-class MCTextAtom;
-class MCDataAtom;
-
-/// \brief Represents a contiguous range of either instructions (a TextAtom)
-/// or data (a DataAtom).  Address ranges are expressed as _closed_ intervals.
-class MCAtom {
-  virtual void anchor();
-public:
-  virtual ~MCAtom() {}
-
-  enum AtomKind { TextAtom, DataAtom };
-  AtomKind getKind() const { return Kind; }
-
-  /// \brief Get the start address of the atom.
-  uint64_t getBeginAddr() const { return Begin; }
-  /// \brief Get the end address, i.e. the last one inside the atom.
-  uint64_t getEndAddr() const { return End; }
-
-  /// \name Atom modification methods:
-  /// When modifying a TextAtom, keep instruction boundaries in mind.
-  /// For instance, split must me given the start address of an instruction.
-  /// @{
-
-  /// \brief Splits the atom in two at a given address.
-  /// \param SplitPt Address at which to start a new atom, splitting this one.
-  /// \returns The newly created atom starting at \p SplitPt.
-  virtual MCAtom *split(uint64_t SplitPt) = 0;
-
-  /// \brief Truncates an atom, discarding everything after \p TruncPt.
-  /// \param TruncPt Last byte address to be contained in this atom.
-  virtual void truncate(uint64_t TruncPt) = 0;
-  /// @}
-
-  /// \name Naming:
-  ///
-  /// This is mostly for display purposes, and may contain anything that hints
-  /// at what the atom contains: section or symbol name, BB start address, ..
-  /// @{
-  StringRef getName() const { return Name; }
-  void setName(StringRef NewName) { Name = NewName.str(); }
-  /// @}
-
-protected:
-  const AtomKind Kind;
-  std::string Name;
-  MCModule *Parent;
-  uint64_t Begin, End;
-
-  friend class MCModule;
-  MCAtom(AtomKind K, MCModule *P, uint64_t B, uint64_t E)
-    : Kind(K), Name("(unknown)"), Parent(P), Begin(B), End(E) { }
-
-  /// \name Atom remapping helpers
-  /// @{
-
-  /// \brief Remap the atom, using the given range, updating Begin/End.
-  /// One or both of the bounds can remain the same, but overlapping with other
-  /// atoms in the module is still forbidden.
-  void remap(uint64_t NewBegin, uint64_t NewEnd);
-
-  /// \brief Remap the atom to prepare for a truncation at TruncPt.
-  /// Equivalent to:
-  /// \code
-  ///   // Bound checks
-  ///   remap(Begin, TruncPt);
-  /// \endcode
-  void remapForTruncate(uint64_t TruncPt);
-
-  /// \brief Remap the atom to prepare for a split at SplitPt.
-  /// The bounds for the resulting atoms are returned in {L,R}{Begin,End}.
-  /// The current atom is truncated to \p LEnd.
-  void remapForSplit(uint64_t SplitPt,
-                     uint64_t &LBegin, uint64_t &LEnd,
-                     uint64_t &RBegin, uint64_t &REnd);
-  /// @}
-};
-
-/// \name Text atom
-/// @{
-
-/// \brief An entry in an MCTextAtom: a disassembled instruction.
-/// NOTE: Both the Address and Size field are actually redundant when taken in
-/// the context of the text atom, and may better be exposed in an iterator
-/// instead of stored in the atom, which would replace this class.
-class MCDecodedInst {
-public:
-  MCInst Inst;
-  uint64_t Address;
-  uint64_t Size;
-  MCDecodedInst(const MCInst &Inst, uint64_t Address, uint64_t Size)
-    : Inst(Inst), Address(Address), Size(Size) {}
-};
-
-/// \brief An atom consisting of disassembled instructions.
-class MCTextAtom : public MCAtom {
-private:
-  typedef std::vector<MCDecodedInst> InstListTy;
-  InstListTy Insts;
-
-  /// \brief The address of the next appended instruction, i.e., the
-  /// address immediately after the last instruction in the atom.
-  uint64_t NextInstAddress;
-public:
-  /// Append an instruction, expanding the atom if necessary.
-  void addInst(const MCInst &Inst, uint64_t Size);
-
-  /// \name Instruction list access
-  /// @{
-  typedef InstListTy::const_iterator const_iterator;
-  const_iterator begin() const { return Insts.begin(); }
-  const_iterator end()   const { return Insts.end(); }
-
-  const MCDecodedInst &back() const { return Insts.back(); }
-  const MCDecodedInst &at(size_t n) const { return Insts.at(n); }
-  size_t size() const { return Insts.size(); }
-  /// @}
-
-  /// \name Atom type specific split/truncate logic.
-  /// @{
-  MCTextAtom *split(uint64_t SplitPt) override;
-  void     truncate(uint64_t TruncPt) override;
-  /// @}
-
-  // Class hierarchy.
-  static bool classof(const MCAtom *A) { return A->getKind() == TextAtom; }
-private:
-  friend class MCModule;
-  // Private constructor - only callable by MCModule
-  MCTextAtom(MCModule *P, uint64_t Begin, uint64_t End)
-    : MCAtom(TextAtom, P, Begin, End), NextInstAddress(Begin) {}
-};
-/// @}
-
-/// \name Data atom
-/// @{
-
-/// \brief An entry in an MCDataAtom.
-// NOTE: This may change to a more complex type in the future.
-typedef uint8_t MCData;
-
-/// \brief An atom consising of a sequence of bytes.
-class MCDataAtom : public MCAtom {
-  std::vector<MCData> Data;
-
-public:
-  /// Append a data entry, expanding the atom if necessary.
-  void addData(const MCData &D);
-
-  /// Get a reference to the data in this atom.
-  ArrayRef<MCData> getData() const { return Data; }
-
-  /// \name Atom type specific split/truncate logic.
-  /// @{
-  MCDataAtom *split(uint64_t SplitPt) override;
-  void     truncate(uint64_t TruncPt) override;
-  /// @}
-
-  // Class hierarchy.
-  static bool classof(const MCAtom *A) { return A->getKind() == DataAtom; }
-private:
-  friend class MCModule;
-  // Private constructor - only callable by MCModule
-  MCDataAtom(MCModule *P, uint64_t Begin, uint64_t End)
-    : MCAtom(DataAtom, P, Begin, End) {
-    Data.reserve(End + 1 - Begin);
-  }
-};
-
-}
-
-#endif
diff --git a/include/llvm/MC/MCAnalysis/MCFunction.h b/include/llvm/MC/MCAnalysis/MCFunction.h
deleted file mode 100644
index 44fa4503b8e0..000000000000
--- a/include/llvm/MC/MCAnalysis/MCFunction.h
+++ /dev/null
@@ -1,142 +0,0 @@
-//===-- MCFunction.h --------------------------------------------*- 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 data structures to hold a CFG reconstructed from
-// machine code.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCANALYSIS_MCFUNCTION_H
-#define LLVM_MC_MCANALYSIS_MCFUNCTION_H
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCInst.h"
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace llvm {
-
-class MCFunction;
-class MCModule;
-class MCTextAtom;
-
-/// \brief Basic block containing a sequence of disassembled instructions.
-/// The basic block is backed by an MCTextAtom, which holds the instructions,
-/// and the address range it covers.
-/// Create a basic block using MCFunction::createBlock.
-class MCBasicBlock {
-  const MCTextAtom *Insts;
-
-  // MCFunction owns the basic block.
-  MCFunction *Parent;
-  friend class MCFunction;
-  MCBasicBlock(const MCTextAtom &Insts, MCFunction *Parent);
-
-  /// \name Predecessors/Successors, to represent the CFG.
-  /// @{
-  typedef std::vector<const MCBasicBlock *> BasicBlockListTy;
-  BasicBlockListTy Successors;
-  BasicBlockListTy Predecessors;
-  /// @}
-public:
-
-  /// \brief Get the backing MCTextAtom, containing the instruction sequence.
-  const MCTextAtom *getInsts() const { return Insts; }
-
-  /// \name Get the owning MCFunction.
-  /// @{
-  const MCFunction *getParent() const { return Parent; }
-        MCFunction *getParent()       { return Parent; }
-  /// @}
-
-  /// MC CFG access: Predecessors/Successors.
-  /// @{
-  typedef BasicBlockListTy::const_iterator succ_const_iterator;
-  succ_const_iterator succ_begin() const { return Successors.begin(); }
-  succ_const_iterator succ_end()   const { return Successors.end(); }
-
-  typedef BasicBlockListTy::const_iterator pred_const_iterator;
-  pred_const_iterator pred_begin() const { return Predecessors.begin(); }
-  pred_const_iterator pred_end()   const { return Predecessors.end(); }
-
-  void addSuccessor(const MCBasicBlock *MCBB);
-  bool isSuccessor(const MCBasicBlock *MCBB) const;
-
-  void addPredecessor(const MCBasicBlock *MCBB);
-  bool isPredecessor(const MCBasicBlock *MCBB) const;
-
-  /// \brief Split block, mirrorring NewAtom = Insts->split(..).
-  /// This moves all successors to \p SplitBB, and
-  /// adds a fallthrough to it.
-  /// \p SplitBB The result of splitting Insts, a basic block directly following
-  /// this basic block.
-  void splitBasicBlock(MCBasicBlock *SplitBB);
-  /// @}
-};
-
-/// \brief Represents a function in machine code, containing MCBasicBlocks.
-/// MCFunctions are created by MCModule.
-class MCFunction {
-  MCFunction           (const MCFunction&) LLVM_DELETED_FUNCTION;
-  MCFunction& operator=(const MCFunction&) LLVM_DELETED_FUNCTION;
-
-  std::string Name;
-  MCModule *ParentModule;
-  typedef std::vector<std::unique_ptr<MCBasicBlock>> BasicBlockListTy;
-  BasicBlockListTy Blocks;
-
-  // MCModule owns the function.
-  friend class MCModule;
-  MCFunction(StringRef Name, MCModule *Parent);
-
-public:
-  /// \brief Create an MCBasicBlock backed by Insts and add it to this function.
-  /// \param Insts Sequence of straight-line code backing the basic block.
-  /// \returns The newly created basic block.
-  MCBasicBlock &createBlock(const MCTextAtom &Insts);
-
-  StringRef getName() const { return Name; }
-
-  /// \name Get the owning MC Module.
-  /// @{
-  const MCModule *getParent() const { return ParentModule; }
-        MCModule *getParent()       { return ParentModule; }
-  /// @}
-
-  /// \name Access to the function's basic blocks. No ordering is enforced,
-  /// except that the first block is the entry block.
-  /// @{
-  /// \brief Get the entry point basic block.
-  const MCBasicBlock *getEntryBlock() const { return front(); }
-        MCBasicBlock *getEntryBlock()       { return front(); }
-
-  bool empty() const { return Blocks.empty(); }
-
-  typedef BasicBlockListTy::const_iterator const_iterator;
-  typedef BasicBlockListTy::      iterator       iterator;
-  const_iterator begin() const { return Blocks.begin(); }
-        iterator begin()       { return Blocks.begin(); }
-  const_iterator   end() const { return Blocks.end(); }
-        iterator   end()       { return Blocks.end(); }
-
-  const MCBasicBlock* front() const { return Blocks.front().get(); }
-        MCBasicBlock* front()       { return Blocks.front().get(); }
-  const MCBasicBlock*  back() const { return Blocks.back().get(); }
-        MCBasicBlock*  back()       { return Blocks.back().get(); }
-
-  /// \brief Find the basic block, if any, that starts at \p StartAddr.
-  const MCBasicBlock *find(uint64_t StartAddr) const;
-        MCBasicBlock *find(uint64_t StartAddr);
-  /// @}
-};
-
-}
-
-#endif
diff --git a/include/llvm/MC/MCAnalysis/MCModule.h b/include/llvm/MC/MCAnalysis/MCModule.h
deleted file mode 100644
index cf7e2c0a645e..000000000000
--- a/include/llvm/MC/MCAnalysis/MCModule.h
+++ /dev/null
@@ -1,134 +0,0 @@
-//===-- MCModule.h - MCModule class -----------------------------*- C++ -*-===//
-//
-//                     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 declaration of the MCModule class, which is used to
-// represent a complete, disassembled object file or executable.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCANALYSIS_MCMODULE_H
-#define LLVM_MC_MCANALYSIS_MCMODULE_H
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/Support/DataTypes.h"
-#include <memory>
-#include <vector>
-
-namespace llvm {
-
-class MCAtom;
-class MCBasicBlock;
-class MCDataAtom;
-class MCFunction;
-class MCObjectDisassembler;
-class MCTextAtom;
-
-/// \brief A completely disassembled object file or executable.
-/// It comprises a list of MCAtom's, each representing a contiguous range of
-/// either instructions or data.
-/// An MCModule is created using MCObjectDisassembler::buildModule.
-class MCModule {
-  /// \name Atom tracking
-  /// @{
-
-  /// \brief Atoms in this module, sorted by begin address.
-  /// FIXME: This doesn't handle overlapping atoms (which happen when a basic
-  /// block starts in the middle of an instruction of another basic block.)
-  typedef std::vector<MCAtom*> AtomListTy;
-  AtomListTy Atoms;
-
-  // For access to map/remap.
-  friend class MCAtom;
-
-  /// \brief Remap \p Atom to the given range, and update its Begin/End fields.
-  /// \param Atom An atom belonging to this module.
-  /// An atom should always use this method to update its bounds, because this
-  /// enables the owning MCModule to keep track of its atoms.
-  void remap(MCAtom *Atom, uint64_t NewBegin, uint64_t NewEnd);
-
-  /// \brief Insert an atom in the module, using its Begin and End addresses.
-  void map(MCAtom *NewAtom);
-  /// @}
-
-  /// \name Basic block tracking
-  /// @{
-  typedef std::vector<MCBasicBlock*> BBsByAtomTy;
-  BBsByAtomTy BBsByAtom;
-
-  // For access to basic block > atom tracking.
-  friend class MCBasicBlock;
-  friend class MCTextAtom;
-
-  /// \brief Keep track of \p BBBackedByAtom as being backed by \p Atom.
-  /// This is used to update succs/preds when \p Atom is split.
-  void trackBBForAtom(const MCTextAtom *Atom, MCBasicBlock *BBBackedByAtom);
-  void splitBasicBlocksForAtom(const MCTextAtom *TA, const MCTextAtom *NewTA);
-  /// @}
-
-  /// \name Function tracking
-  /// @{
-  typedef std::vector<std::unique_ptr<MCFunction>> FunctionListTy;
-  FunctionListTy Functions;
-  /// @}
-
-  /// The address of the entrypoint function.
-  uint64_t Entrypoint;
-
-  MCModule           (const MCModule &) LLVM_DELETED_FUNCTION;
-  MCModule& operator=(const MCModule &) LLVM_DELETED_FUNCTION;
-
-  // MCObjectDisassembler creates MCModules.
-  friend class MCObjectDisassembler;
-
-public:
-  MCModule();
-  ~MCModule();
-
-  /// \name Create a new MCAtom covering the specified offset range.
-  /// @{
-  MCTextAtom *createTextAtom(uint64_t Begin, uint64_t End);
-  MCDataAtom *createDataAtom(uint64_t Begin, uint64_t End);
-  /// @}
-
-  /// \name Access to the owned atom list, ordered by begin address.
-  /// @{
-  const MCAtom *findAtomContaining(uint64_t Addr) const;
-        MCAtom *findAtomContaining(uint64_t Addr);
-  const MCAtom *findFirstAtomAfter(uint64_t Addr) const;
-        MCAtom *findFirstAtomAfter(uint64_t Addr);
-
-  typedef AtomListTy::const_iterator const_atom_iterator;
-  typedef AtomListTy::      iterator       atom_iterator;
-  const_atom_iterator atom_begin() const { return Atoms.begin(); }
-        atom_iterator atom_begin()       { return Atoms.begin(); }
-  const_atom_iterator atom_end()   const { return Atoms.end(); }
-        atom_iterator atom_end()         { return Atoms.end(); }
-  /// @}
-
-  /// \brief Create a new MCFunction.
-  MCFunction *createFunction(StringRef Name);
-
-  /// \name Access to the owned function list.
-  /// @{
-  typedef FunctionListTy::const_iterator const_func_iterator;
-  typedef FunctionListTy::      iterator       func_iterator;
-  const_func_iterator func_begin() const { return Functions.begin(); }
-        func_iterator func_begin()       { return Functions.begin(); }
-  const_func_iterator func_end()   const { return Functions.end(); }
-        func_iterator func_end()         { return Functions.end(); }
-  /// @}
-
-  /// \brief Get the address of the entrypoint function, or 0 if there is none.
-  uint64_t getEntrypoint() const { return Entrypoint; }
-};
-
-}
-
-#endif
diff --git a/include/llvm/MC/MCAnalysis/MCModuleYAML.h b/include/llvm/MC/MCAnalysis/MCModuleYAML.h
deleted file mode 100644
index 48562777677b..000000000000
--- a/include/llvm/MC/MCAnalysis/MCModuleYAML.h
+++ /dev/null
@@ -1,40 +0,0 @@
-//===- MCModuleYAML.h - MCModule YAMLIO implementation ----------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-///
-/// \file
-/// \brief This file declares classes for handling the YAML representation
-/// of MCModule.
-///
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_MC_MCANALYSIS_MCMODULEYAML_H
-#define LLVM_MC_MCANALYSIS_MCMODULEYAML_H
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/MC/MCAnalysis/MCModule.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace llvm {
-
-class MCInstrInfo;
-class MCRegisterInfo;
-
-/// \brief Dump a YAML representation of the MCModule \p MCM to \p OS.
-/// \returns The empty string on success, an error message on failure.
-StringRef mcmodule2yaml(raw_ostream &OS, const MCModule &MCM,
-                        const MCInstrInfo &MII, const MCRegisterInfo &MRI);
-
-/// \brief Creates a new module and returns it in \p MCM.
-/// \returns The empty string on success, an error message on failure.
-StringRef yaml2mcmodule(std::unique_ptr<MCModule> &MCM, StringRef YamlContent,
-                        const MCInstrInfo &MII, const MCRegisterInfo &MRI);
-
-} // end namespace llvm
-
-#endif