haiku.git

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2014-2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */
#ifndef TEAM_DEBUG_INFO_H
#define TEAM_DEBUG_INFO_H


#include <Locker.h>

#include <ObjectList.h>
#include <Referenceable.h>
#include <util/OpenHashTable.h>

#include "GlobalTypeLookup.h"
#include "ImageInfo.h"
#include "TeamFunctionSourceInformation.h"
#include "TeamTypeInformation.h"

class Architecture;
class DebuggerInterface;
class DisassembledCode;
class FileManager;
class FileSourceCode;
class Function;
class FunctionID;
class FunctionInstance;
class ImageDebugInfo;
class ImageDebugInfoLoadingState;
class ImageInfo;
class LocatableFile;
class SourceCode;
class SourceLocation;
class SpecificTeamDebugInfo;


class TeamDebugInfo : public BReferenceable, public GlobalTypeLookup,
	public TeamTypeInformation, public TeamFunctionSourceInformation {
public:
								TeamDebugInfo(
									DebuggerInterface* debuggerInterface,
									Architecture* architecture,
									FileManager* fileManager);
								~TeamDebugInfo();

			status_t			Init();

	virtual	status_t			GetType(GlobalTypeCache* cache,
									const BString& name,
									const TypeLookupConstraints& constraints,
									Type*& _type);
	virtual	bool				HasType(GlobalTypeCache* cache,
									const BString& name,
									const TypeLookupConstraints& constraints);

	virtual status_t			LookupTypeByName(const BString& name,
									const TypeLookupConstraints& constraints,
									Type*& _type);
	virtual	bool				TypeExistsByName(const BString& name,
									const TypeLookupConstraints& constraints);

	virtual	status_t			GetActiveSourceCode(FunctionDebugInfo* info,
									SourceCode*& _code);

			status_t			LoadImageDebugInfo(const ImageInfo& imageInfo,
									LocatableFile* imageFile,
									ImageDebugInfoLoadingState& state,
									ImageDebugInfo*& _imageDebugInfo);

			status_t			LoadSourceCode(LocatableFile* file,
									FileSourceCode*& _sourceCode);
										// returns reference
			void				ClearSourceCode(LocatableFile* file);

			status_t			DisassembleFunction(
									FunctionInstance* functionInstance,
									DisassembledCode*& _sourceCode);
										// returns reference
			FunctionInstance*	MainFunction() const
									{ return fMainFunction; }

			// team is locked
			status_t			AddImageDebugInfo(
									ImageDebugInfo* imageDebugInfo);
			void				RemoveImageDebugInfo(
									ImageDebugInfo* imageDebugInfo);
			ImageDebugInfo*		ImageDebugInfoByName(const char* name) const;

			Function*			FunctionAtSourceLocation(LocatableFile* file,
									const SourceLocation& location) const;
			Function*			FunctionByID(FunctionID* functionID) const;

private:
			struct FunctionHashDefinition;
			struct SourceFileEntry;
			struct SourceFileHashDefinition;

			typedef BObjectList<SpecificTeamDebugInfo, true> SpecificInfoList;
			typedef BObjectList<ImageDebugInfo> ImageList;
			typedef BOpenHashTable<FunctionHashDefinition> FunctionTable;
			typedef BOpenHashTable<SourceFileHashDefinition> SourceFileTable;

private:
			status_t			_AddFunction(Function* function);
			void				_RemoveFunction(Function* function);

private:
			BLocker				fLock;
			DebuggerInterface*	fDebuggerInterface;
			Architecture*		fArchitecture;
			FileManager*		fFileManager;
			SpecificInfoList	fSpecificInfos;
			ImageList			fImages;
			FunctionTable*		fFunctions;
			SourceFileTable*	fSourceFiles;
			GlobalTypeCache*	fTypeCache;
			FunctionInstance*	fMainFunction;
};


#endif	// TEAM_DEBUG_INFO_H