This is an archive of the discontinued LLVM Phabricator instance.

Remove IRToDWARF.h
ClosedPublic

Authored by brucem on Sep 21 2015, 9:16 PM.

Download Raw Diff

Details

Reviewers

spyffe
clayborg

Commits

rG126b8b111a92: Remove IRToDWARF.h
rLLDB248286: Remove IRToDWARF.h
rL248286: Remove IRToDWARF.h

Summary

The corresponding .cpp file was removed in September of 2011 in
r139772.

Diff Detail

Repository: rL LLVM

Event Timeline

brucem updated this revision to Diff 35340.Sep 21 2015, 9:16 PM

brucem retitled this revision from to Remove IRToDWARF.h.

brucem updated this object.

brucem added reviewers: spyffe, clayborg.

brucem added a subscriber: lldb-commits.

clayborg accepted this revision.Sep 22 2015, 9:22 AM

clayborg edited edge metadata.

This revision is now accepted and ready to land.Sep 22 2015, 9:22 AM

Closed by commit rL248286: Remove IRToDWARF.h (authored by brucem). · Explain WhySep 22 2015, 9:31 AM

This revision was automatically updated to reflect the committed changes.

Revision Contents

Path

Size

lldb/

trunk/

include/

lldb/

Expression/

IRToDWARF.h

111 lines

Diff 35377

lldb/trunk/include/lldb/Expression/IRToDWARF.h

	//===-- IRToDWARF.h ---------------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#ifndef liblldb_IRToDWARF_h_
	#define liblldb_IRToDWARF_h_

	#include "llvm/Pass.h"
	#include "llvm/IR/LegacyPassManager.h"

	#include "lldb/lldb-public.h"

	class Relocator;
	//----------------------------------------------------------------------
	/// @class IRToDWARF IRToDWARF.h "lldb/Expression/IRToDWARF.h"
	/// @brief Transforms the IR for a function into a DWARF location expression
	///
	/// Once an expression has been parsed and converted to IR, it can run
	/// in two contexts: interpreted by LLDB as a DWARF location expression,
	/// or compiled by the JIT and inserted into the target process for
	/// execution.
	///
	/// IRToDWARF makes the first possible, by traversing the control flow
	/// graph and writing the code for each basic block out as location
	/// expression bytecode. To ensure that the links between the basic blocks
	/// remain intact, it uses a relocator that records the location of every
	/// location expression instruction that has a relocatable operand, the
	/// target of that operand (as a basic block), and the mapping of each basic
	/// block to an actual location. After all code has been written out, the
	/// relocator post-processes it and performs all necessary relocations.
	//----------------------------------------------------------------------
	class IRToDWARF : public llvm::ModulePass
	{
	public:
	//------------------------------------------------------------------
	/// Constructor
	///
	/// @param[in] local_vars
	/// A list of variables to populate with the local variables this
	/// expression uses.
	///
	/// @param[in] decl_map
	/// The list of externally-referenced variables for the expression,
	/// for use in looking up globals.
	///
	/// @param[in] stream
	/// The stream to dump DWARF bytecode onto.
	///
	/// @param[in] func_name
	/// The name of the function to translate to DWARF.
	//------------------------------------------------------------------
	IRToDWARF(lldb_private::ClangExpressionVariableList &local_vars,
	lldb_private::ClangExpressionDeclMap *decl_map,
	lldb_private::StreamString &strm,
	const char* func_name = "$__lldb_expr");

	//------------------------------------------------------------------
	/// Destructor
	//------------------------------------------------------------------
	virtual ~IRToDWARF();

	//------------------------------------------------------------------
	/// Run this IR transformer on a single module
	///
	/// @param[in] M
	/// The module to run on. This module is searched for the function
	/// $__lldb_expr, and that function is converted to a location
	/// expression.
	///
	/// @return
	/// True on success; false otherwise
	//------------------------------------------------------------------
	bool runOnModule(llvm::Module &M);

	//------------------------------------------------------------------
	/// Interface stub
	//------------------------------------------------------------------
	void assignPassManager(llvm::PMStack &PMS,
	llvm::PassManagerType T = llvm::PMT_ModulePassManager);

	//------------------------------------------------------------------
	/// Returns PMT_ModulePassManager
	//------------------------------------------------------------------
	llvm::PassManagerType getPotentialPassManagerType() const;
	private:
	//------------------------------------------------------------------
	/// Run this IR transformer on a single basic block
	///
	/// @param[in] BB
	/// The basic block to transform.
	///
	/// @param[in] Relocator
	/// The relocator to use when registering branches.
	///
	/// @return
	/// True on success; false otherwise
	//------------------------------------------------------------------
	bool runOnBasicBlock(llvm::BasicBlock &BB, Relocator &Relocator);

	std::string m_func_name; ///< The name of the function to translate
	lldb_private::ClangExpressionVariableList &m_local_vars; ///< The list of local variables to populate while transforming
	lldb_private::ClangExpressionDeclMap *m_decl_map; ///< The list of external variables
	lldb_private::StreamString &m_strm; ///< The stream to write bytecode to
	};

	#endif