// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//  http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef rr_LLVMReactorDebugInfo_hpp
#define rr_LLVMReactorDebugInfo_hpp

#include "Reactor.hpp"

#ifdef ENABLE_RR_DEBUG_INFO

#include <unordered_set>
#include <unordered_map>
#include <vector>
#include <memory>

// Forward declarations
namespace llvm {

class BasicBlock;
class ConstantFolder;
class DIBuilder;
class DICompileUnit;
class DIFile;
class DILocation;
class DIScope;
class DISubprogram;
class DIType;
class Function;
class Instruction;
class IRBuilderDefaultInserter;
class JITEventListener;
class LLVMContext;
class LoadedObjectInfo;
class Module;
class Type;
class Value;

namespace object
{
	class ObjectFile;
}

template <typename T, typename Inserter> class IRBuilder;

}  // namespace llvm

namespace rr {

class Type;
class Value;

// DebugInfo generates LLVM DebugInfo IR from the C++ source that calls
// into Reactor functions. See docs/ReactorDebugInfo.mk for more information.
class DebugInfo
{
public:
	using IRBuilder = llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>;

	DebugInfo(IRBuilder *builder,
			llvm::LLVMContext *context,
			llvm::Module *module,
			llvm::Function *function);

	~DebugInfo();

	// Finalize debug info generation. Must be called before the LLVM module
	// is built.
	void Finalize();

	// Updates the current source location.
	void EmitLocation();

	// Binds the value to its symbol in the source file.
	// See docs/ReactorDebugInfo.mk for more information.
	void EmitVariable(Value *value);

	// Forcefully flush the binding of the last variable name.
	// Used for binding the initializer of `For` loops.
	void Flush();

	// NotifyObjectEmitted informs any attached debuggers of the JIT'd
	// object.
	static void NotifyObjectEmitted(const llvm::object::ObjectFile &Obj, const llvm::LoadedObjectInfo &L);

	// NotifyFreeingObject informs any attached debuggers that the JIT'd
	// object is now invalid.
	static void NotifyFreeingObject(const llvm::object::ObjectFile &Obj);

private:
	struct Token
	{
		enum Kind
		{
			Identifier,
			Return
		};
		Kind kind;
		std::string identifier;
	};

	using LineTokens = std::unordered_map<unsigned int, Token>;

	struct FunctionLocation
	{
		std::string name;
		std::string file;

		bool operator == (const FunctionLocation &rhs) const { return name == rhs.name && file == rhs.file; }
		bool operator != (const FunctionLocation &rhs) const { return !(*this == rhs); }

		struct Hash
		{
			std::size_t operator()(const FunctionLocation &l) const noexcept
			{
				return std::hash<std::string>()(l.file) * 31 +
						std::hash<std::string>()(l.name);
			}
		};
	};

	struct Location
	{
		FunctionLocation function;
		unsigned int line = 0;

		bool operator == (const Location &rhs) const { return function == rhs.function && line == rhs.line; }
		bool operator != (const Location &rhs) const { return !(*this == rhs); }

		struct Hash
		{
			std::size_t operator()(const Location &l) const noexcept
			{
				return FunctionLocation::Hash()(l.function) * 31 +
						std::hash<unsigned int>()(l.line);
			}
		};
	};

	using Backtrace = std::vector<Location>;

	struct Pending
	{
		std::string name;
		Location location;
		llvm::DILocation *diLocation = nullptr;
		llvm::Value *value = nullptr;
		llvm::Instruction *insertAfter = nullptr;
		llvm::BasicBlock *block = nullptr;
		llvm::DIScope *scope = nullptr;
		bool addNopOnNextLine = false;
	};

	struct Scope
	{
		Location location;
		llvm::DIScope *di;
		std::unordered_set<std::string> symbols;
		Pending pending;
	};

	void registerBasicTypes();

	void emitPending(Scope &scope, IRBuilder *builder);

	// Returns the source location of the non-Reactor calling function.
	Location getCallerLocation() const;

	// Returns the backtrace for the callstack, starting at the first
	// non-Reactor file. If limit is non-zero, then a maximum of limit
	// frames will be returned.
	Backtrace getCallerBacktrace(size_t limit = 0) const;

	llvm::DILocation* getLocation(const Backtrace &backtrace, size_t i);

	llvm::DIType *getOrCreateType(llvm::Type* type);
	llvm::DIFile *getOrCreateFile(const char* path);
	LineTokens const *getOrParseFileTokens(const char* path);

	// Synchronizes diScope with the current backtrace.
	void syncScope(Backtrace const& backtrace);

	IRBuilder *builder;
	llvm::LLVMContext *context;
	llvm::Module *module;
	llvm::Function *function;

	std::unique_ptr<llvm::DIBuilder> diBuilder;
	llvm::DICompileUnit *diCU;
	llvm::DISubprogram *diSubprogram;
	llvm::DILocation *diRootLocation;
	std::vector<Scope> diScope;
	std::unordered_map<std::string, llvm::DIFile*> diFiles;
	std::unordered_map<llvm::Type*, llvm::DIType*> diTypes;
	std::unordered_map<std::string, std::unique_ptr<LineTokens>> fileTokens;
	std::vector<void const*> pushed;
};

}  // namespace rr

#endif // ENABLE_RR_DEBUG_INFO

#endif // rr_LLVMReactorDebugInfo_hpp